diff --git a/.circleci/config.yml b/.circleci/config.yml index de7f52f81426..a75f669af6f4 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -18,6 +18,20 @@ jobs: steps: - checkout: + + - run: + name: Check-skip + command: | + export git_log=$(git log --max-count=1 --pretty=format:"%B" | tr "\n" " ") + echo "Got commit message:" + echo "${git_log}" + if [[ -v CIRCLE_PULL_REQUEST ]] && \ + ([[ "$git_log" == *"[skip circle]"* ]] || \ + [[ "$git_log" == *"[circle skip]"* ]]) + then + echo "Skip detected, exiting job ${CIRCLE_JOB} for PR ${CIRCLE_PULL_REQUEST}." + circleci-agent step halt; + fi - run: name: pull changes from merge command: | @@ -44,14 +58,13 @@ jobs: . venv/bin/activate pip install --progress-bar=off --upgrade pip 'setuptools<49.2.0' pip install --progress-bar=off -r test_requirements.txt - pip install . pip install --progress-bar=off -r doc_requirements.txt + pip install . - run: name: create release notes command: | . venv/bin/activate - pip install towncrier VERSION=$(python -c "import setup; print(setup.VERSION)") towncrier build --version $VERSION --yes ./tools/ci/test_all_newsfragments_used.py diff --git a/.cirrus.star b/.cirrus.star new file mode 100644 index 000000000000..20460b8b2365 --- /dev/null +++ b/.cirrus.star @@ -0,0 +1,38 @@ +# The guide to programming cirrus-ci tasks using starlark is found at +# https://cirrus-ci.org/guide/programming-tasks/ +# +# In this simple starlark script we simply check conditions for whether +# a CI run should go ahead. If the conditions are met, then we just +# return the yaml containing the tasks to be run. + +load("cirrus", "env", "fs", "http") + +def main(ctx): + ###################################################################### + # Should wheels be built? + # Only test on the numpy/numpy repository + ###################################################################### + + if env.get("CIRRUS_REPO_FULL_NAME") != "numpy/numpy": + return [] + + # if env.get("CIRRUS_CRON", "") == "nightly": + # return fs.read("ci/cirrus_wheels.yml") + + # Obtain commit message for the event. Unfortunately CIRRUS_CHANGE_MESSAGE + # only contains the actual commit message on a non-PR trigger event. + # For a PR event it contains the PR title and description. + SHA = env.get("CIRRUS_CHANGE_IN_REPO") + url = "https://api.github.com/repos/scipy/scipy/git/commits/" + SHA + dct = http.get(url).json() + # if "[wheel build]" in dct["message"]: + # return fs.read("ci/cirrus_wheels.yml") + + if "[skip cirrus]" in dct["message"] or "[skip ci]" in dct["message"]: + return [] + + config = fs.read("tools/ci/cirrus_general.yml") + + # add extra jobs to the cirrus run by += adding to config + + return config diff --git a/.github/CODE_OF_CONDUCT.md b/.github/CODE_OF_CONDUCT.md deleted file mode 100644 index 079098fae68a..000000000000 --- a/.github/CODE_OF_CONDUCT.md +++ /dev/null @@ -1 +0,0 @@ -NumPy has a Code of Conduct, please see: https://numpy.org/code-of-conduct diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml deleted file mode 100644 index 8c3502443d19..000000000000 --- a/.github/FUNDING.yml +++ /dev/null @@ -1,3 +0,0 @@ -github: [numfocus] -tidelift: pypi/numpy -custom: https://numpy.org/about#donate diff --git a/.github/ISSUE_TEMPLATE/bug-report.yml b/.github/ISSUE_TEMPLATE/bug-report.yml index 29d0d0dd0f22..cfb07f450284 100644 --- a/.github/ISSUE_TEMPLATE/bug-report.yml +++ b/.github/ISSUE_TEMPLATE/bug-report.yml @@ -48,4 +48,14 @@ body: label: "NumPy/Python version information:" description: Output from `import sys, numpy; print(numpy.__version__, sys.version)`. validations: - required: true \ No newline at end of file + required: true + +- type: textarea + attributes: + label: "Context for the issue:" + description: | + Please explain how this issue affects your work or why it should be prioritized. + placeholder: | + << your explanation here >> + validations: + required: false \ No newline at end of file diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md index 704d2d16fd9c..3cb690fa494c 100644 --- a/.github/PULL_REQUEST_TEMPLATE.md +++ b/.github/PULL_REQUEST_TEMPLATE.md @@ -3,14 +3,14 @@ ---------------------------------------------------------------- * FORMAT IT RIGHT: - http://www.numpy.org/devdocs/dev/development_workflow.html#writing-the-commit-message + https://www.numpy.org/devdocs/dev/development_workflow.html#writing-the-commit-message * IF IT'S A NEW FEATURE OR API CHANGE, TEST THE WATERS: - http://www.numpy.org/devdocs/dev/development_workflow.html#get-the-mailing-list-s-opinion + https://www.numpy.org/devdocs/dev/development_workflow.html#get-the-mailing-list-s-opinion * HIT ALL THE GUIDELINES: https://numpy.org/devdocs/dev/index.html#guidelines * WHAT TO DO IF WE HAVEN'T GOTTEN BACK TO YOU: - http://www.numpy.org/devdocs/dev/development_workflow.html#getting-your-pr-reviewed + https://www.numpy.org/devdocs/dev/development_workflow.html#getting-your-pr-reviewed --> diff --git a/.github/actions/action.yml b/.github/actions/action.yml index 43a7d0c7ac03..20a239026e4f 100644 --- a/.github/actions/action.yml +++ b/.github/actions/action.yml @@ -7,7 +7,6 @@ runs: shell: bash run: | echo NPY_RELAXED_STRIDES_DEBUG $NPY_RELAXED_STRIDES_DEBUG - echo NPY_RELAXED_STRIDES_CHECKING $NPY_RELAXED_STRIDES_CHECKING echo CHECK_BLAS $CHECK_BLAS echo DOWNLOAD_OPENBLAS $DOWNLOAD_OPENBLAS echo USE_DEBUG $USE_DEBUG diff --git a/.github/pr-prefix-labeler.yml b/.github/pr-prefix-labeler.yml index ab7ad9d28b9b..2b95f1f314f6 100644 --- a/.github/pr-prefix-labeler.yml +++ b/.github/pr-prefix-labeler.yml @@ -12,3 +12,4 @@ "TST": "05 - Testing" "REL": "14 - Release" "WIP": "25 - WIP" +"TYP": "static typing" diff --git a/.github/workflows/build_test.yml b/.github/workflows/build_test.yml index 86fb094c6f99..d7c3b5093792 100644 --- a/.github/workflows/build_test.yml +++ b/.github/workflows/build_test.yml @@ -18,17 +18,24 @@ env: DOWNLOAD_OPENBLAS: 1 PYTHON_VERSION: 3.8 +concurrency: + group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }} + cancel-in-progress: true + +permissions: + contents: read # to fetch code (actions/checkout) + jobs: lint: if: "github.repository == 'numpy/numpy' && github.ref != 'refs/heads/main' && !contains(github.event.head_commit.message, '[ci skip]') && !contains(github.event.head_commit.message, '[skip ci]') && !contains(github.event.head_commit.message, '[skip github]')" runs-on: ubuntu-latest continue-on-error: true steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v3 with: submodules: recursive fetch-depth: 0 - - uses: actions/setup-python@v2 + - uses: actions/setup-python@v4 with: python-version: ${{ env.PYTHON_VERSION }} - name: Install linter requirements @@ -41,12 +48,14 @@ jobs: smoke_test: if: "github.repository == 'numpy/numpy' && !contains(github.event.head_commit.message, '[ci skip]') && !contains(github.event.head_commit.message, '[skip ci]') && !contains(github.event.head_commit.message, '[skip github]')" runs-on: ubuntu-latest + env: + WITHOUT_SIMD: 1 steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v3 with: submodules: recursive fetch-depth: 0 - - uses: actions/setup-python@v2 + - uses: actions/setup-python@v4 with: python-version: ${{ env.PYTHON_VERSION }} - uses: ./.github/actions @@ -56,28 +65,127 @@ jobs: runs-on: ubuntu-latest strategy: matrix: - python-version: ["3.9", "3.10"] + python-version: ["3.9", "3.10", "3.11"] + env: + EXPECT_CPU_FEATURES: "SSE SSE2 SSE3 SSSE3 SSE41 POPCNT SSE42 AVX F16C FMA3 AVX2 AVX512F AVX512CD AVX512_KNL AVX512_KNM AVX512_SKX AVX512_CLX AVX512_CNL AVX512_ICL" steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v3 with: submodules: recursive fetch-depth: 0 - - uses: actions/setup-python@v2 + - uses: actions/setup-python@v4 with: python-version: ${{ matrix.python-version }} - uses: ./.github/actions + old_gcc: + needs: [smoke_test] + # provides GCC 7, 8 + runs-on: ubuntu-20.04 + steps: + - uses: actions/checkout@v3 + with: + submodules: recursive + fetch-depth: 0 + # comes with python3.6 + - name: Install Python3.8 + run: | + sudo apt update + # for add-apt-repository + sudo apt install software-properties-common -y + sudo add-apt-repository ppa:deadsnakes/ppa -y + sudo apt install python3.8-dev -y + sudo ln -s /usr/bin/python3.8 /usr/bin/pythonx + pythonx -m pip install --upgrade pip setuptools wheel + pythonx -m pip install -r test_requirements.txt + - name: Install Compilers + run: sudo apt install g++-7 g++-8 -y + - name: Build gcc-7 + run: | + export CC=/usr/bin/gcc-7 + export CXX=/usr/bin/g++-7 + rm -rf build && pythonx setup.py install --user + - name: Runtests gcc-7 + run: pythonx runtests.py -n + - name: Build gcc-8 + run: | + export CC=/usr/bin/gcc-8 + export CXX=/usr/bin/g++-8 + rm -rf build && pythonx setup.py install --user + - name: Runtests gcc-8 + run: pythonx runtests.py -n + + without_optimizations: + needs: [smoke_test] + runs-on: ubuntu-latest + env: + WITHOUT_OPTIMIZATIONS: 1 + steps: + - uses: actions/checkout@v3 + with: + submodules: recursive + fetch-depth: 0 + - uses: actions/setup-python@v4 + with: + python-version: ${{ env.PYTHON_VERSION }} + - uses: ./.github/actions + + with_baseline_only: + needs: [smoke_test] + runs-on: ubuntu-latest + env: + CPU_DISPATCH: "none" + steps: + - uses: actions/checkout@v3 + with: + submodules: recursive + fetch-depth: 0 + - uses: actions/setup-python@v4 + with: + python-version: ${{ env.PYTHON_VERSION }} + - uses: ./.github/actions + + without_avx512: + needs: [smoke_test] + runs-on: ubuntu-latest + env: + CPU_DISPATCH: "max -xop -fma4 -avx512f -avx512cd -avx512_knl -avx512_knm -avx512_skx -avx512_clx -avx512_cnl -avx512_icl" + steps: + - uses: actions/checkout@v3 + with: + submodules: recursive + fetch-depth: 0 + - uses: actions/setup-python@v4 + with: + python-version: ${{ env.PYTHON_VERSION }} + - uses: ./.github/actions + + without_avx512_avx2_fma3: + needs: [smoke_test] + runs-on: ubuntu-latest + env: + CPU_DISPATCH: "SSSE3 SSE41 POPCNT SSE42 AVX F16C" + steps: + - uses: actions/checkout@v3 + with: + submodules: recursive + fetch-depth: 0 + - uses: actions/setup-python@v4 + with: + python-version: ${{ env.PYTHON_VERSION }} + - uses: ./.github/actions + debug: needs: [smoke_test] runs-on: ubuntu-20.04 env: USE_DEBUG: 1 steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v3 with: submodules: recursive fetch-depth: 0 - - uses: actions/setup-python@v2 + - uses: actions/setup-python@v4 with: python-version: ${{ env.PYTHON_VERSION }} - uses: ./.github/actions @@ -88,29 +196,29 @@ jobs: env: NPY_USE_BLAS_ILP64: 1 steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v3 with: submodules: recursive fetch-depth: 0 - - uses: actions/setup-python@v2 + - uses: actions/setup-python@v4 with: python-version: ${{ env.PYTHON_VERSION }} - uses: ./.github/actions full: needs: [smoke_test] - runs-on: ubuntu-18.04 + runs-on: ubuntu-22.04 env: USE_WHEEL: 1 RUN_FULL_TESTS: 1 RUN_COVERAGE: 1 INSTALL_PICKLE5: 1 steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v3 with: submodules: recursive fetch-depth: 0 - - uses: actions/setup-python@v2 + - uses: actions/setup-python@v4 with: python-version: ${{ env.PYTHON_VERSION }} - uses: ./.github/actions @@ -127,28 +235,28 @@ jobs: NPY_LAPACK_ORDER: MKL,OPENBLAS,ATLAS,LAPACK USE_ASV: 1 steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v3 with: submodules: recursive fetch-depth: 0 - - uses: actions/setup-python@v2 + - uses: actions/setup-python@v4 with: python-version: ${{ env.PYTHON_VERSION }} - uses: ./.github/actions - no_relaxed_strides: + relaxed_strides_debug: needs: [smoke_test] runs-on: ubuntu-latest env: - NPY_RELAXED_STRIDES_CHECKING: 0 CHECK_BLAS: 1 NPY_USE_BLAS_ILP64: 1 + NPY_RELAXED_STRIDES_DEBUG: 1 steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v3 with: submodules: recursive fetch-depth: 0 - - uses: actions/setup-python@v2 + - uses: actions/setup-python@v4 with: python-version: ${{ env.PYTHON_VERSION }} - uses: ./.github/actions @@ -158,13 +266,12 @@ jobs: runs-on: ubuntu-latest env: USE_WHEEL: 1 - NPY_RELAXED_STRIDES_DEBUG: 1 steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v3 with: submodules: recursive fetch-depth: 0 - - uses: actions/setup-python@v2 + - uses: actions/setup-python@v4 with: python-version: ${{ env.PYTHON_VERSION }} - uses: ./.github/actions @@ -175,11 +282,11 @@ jobs: env: NUMPY_EXPERIMENTAL_ARRAY_FUNCTION: 0 steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v3 with: submodules: recursive fetch-depth: 0 - - uses: actions/setup-python@v2 + - uses: actions/setup-python@v4 with: python-version: ${{ env.PYTHON_VERSION }} - uses: ./.github/actions @@ -193,11 +300,11 @@ jobs: ATLAS: None DOWNLOAD_OPENBLAS: '' steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v3 with: submodules: recursive fetch-depth: 0 - - uses: actions/setup-python@v2 + - uses: actions/setup-python@v4 with: python-version: ${{ env.PYTHON_VERSION }} - uses: ./.github/actions @@ -206,13 +313,13 @@ jobs: needs: [smoke_test] runs-on: ubuntu-latest steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v3 with: submodules: recursive fetch-depth: 0 - - uses: actions/setup-python@v2 + - uses: actions/setup-python@v4 with: - python-version: pypy-3.8-v7.3.6rc1 + python-version: pypy-3.8-v7.3.9 - uses: ./.github/actions sdist: @@ -221,20 +328,21 @@ jobs: env: USE_SDIST: 1 steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v3 with: submodules: recursive fetch-depth: 0 - - uses: actions/setup-python@v2 + - uses: actions/setup-python@v4 with: python-version: ${{ env.PYTHON_VERSION }} - uses: ./.github/actions armv7_simd_test: needs: [smoke_test] - runs-on: ubuntu-latest + # make sure this (20.04) matches the base docker image (focal) below + runs-on: ubuntu-20.04 steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v3 with: submodules: recursive fetch-depth: 0 @@ -246,10 +354,12 @@ jobs: # use x86_64 cross-compiler to speed up the build sudo apt update sudo apt install -y gcc-arm-linux-gnueabihf g++-arm-linux-gnueabihf - docker run --name the_container --interactive -v /:/host arm32v7/ubuntu:latest /bin/bash -c " + + # Keep the `test_requirements.txt` dependency-subset synced + docker run --name the_container --interactive -v /:/host arm32v7/ubuntu:focal /bin/bash -c " apt update && apt install -y git python3 python3-dev python3-pip && - pip3 install cython==0.29.24 setuptools\<49.2.0 hypothesis==6.23.3 pytest==6.2.5 && + pip3 install cython==0.29.30 setuptools\<49.2.0 hypothesis==6.23.3 pytest==6.2.5 'typing_extensions>=4.2.0' && ln -s /host/lib64 /lib64 && ln -s /host/lib/x86_64-linux-gnu /lib/x86_64-linux-gnu && ln -s /host/usr/arm-linux-gnueabihf /usr/arm-linux-gnueabihf && @@ -269,7 +379,9 @@ jobs: gcc --version && g++ --version && python3 --version && - cd /numpy && python3 setup.py install + git config --global --add safe.directory /numpy + cd /numpy && + python3 setup.py install " docker commit the_build the_build - name: Run SIMD Tests @@ -285,17 +397,17 @@ jobs: needs: [smoke_test] runs-on: ubuntu-latest steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v3 with: submodules: recursive fetch-depth: 0 - - uses: actions/setup-python@v2 + - uses: actions/setup-python@v4 with: python-version: ${{ env.PYTHON_VERSION }} - name: Install Intel SDE run: | - curl -o /tmp/sde.tar.bz2 https://www.intel.com/content/dam/develop/external/us/en/documents/downloads/sde-external-8.69.1-2021-07-18-lin.tar.bz2 - mkdir /tmp/sde && tar -xvf /tmp/sde.tar.bz2 -C /tmp/sde/ + curl -o /tmp/sde.tar.xz https://downloadmirror.intel.com/732268/sde-external-9.7.0-2022-05-09-lin.tar.xz + mkdir /tmp/sde && tar -xvf /tmp/sde.tar.xz -C /tmp/sde/ sudo mv /tmp/sde/* /opt/sde && sudo ln -s /opt/sde/sde64 /usr/bin/sde - name: Install dependencies run: python -m pip install -r test_requirements.txt diff --git a/.github/workflows/circleci.yml b/.github/workflows/circleci.yml index de02ac6d330d..6da0eec0d37c 100644 --- a/.github/workflows/circleci.yml +++ b/.github/workflows/circleci.yml @@ -1,12 +1,24 @@ +# To enable this workflow on a fork, comment out: +# +# if: github.repository == 'numpy/numpy' + +name: CircleCI artifact redirector + +permissions: + contents: read # to fetch code (actions/checkout) + on: [status] jobs: - circleci_artifacts_redirector_job: - runs-on: ubuntu-latest - name: Run CircleCI artifacts redirector - steps: - - name: GitHub Action step - uses: larsoner/circleci-artifacts-redirector-action@master - with: - repo-token: ${{ secrets.GITHUB_TOKEN }} - artifact-path: 0/doc/build/html/index.html - circleci-jobs: build + circleci_artifacts_redirector_job: + runs-on: ubuntu-latest + name: Run CircleCI artifacts redirector + permissions: + pull-requests: write + # if: github.repository == 'numpy/numpy' + steps: + - name: GitHub Action step + uses: larsoner/circleci-artifacts-redirector-action@1e28a97d7b1e273a8f78ed4692bfd10f84706a45 # master + with: + repo-token: ${{ secrets.GITHUB_TOKEN }} + artifact-path: 0/doc/build/html/index.html + circleci-jobs: build diff --git a/.github/workflows/cygwin.yml b/.github/workflows/cygwin.yml index 78fa25995f3c..c028b2974181 100644 --- a/.github/workflows/cygwin.yml +++ b/.github/workflows/cygwin.yml @@ -1,29 +1,43 @@ +# To enable this workflow on a fork, comment out: +# +# if: github.repository == 'numpy/numpy' name: Test on Cygwin on: push: branches: - main + - maintenance/** pull_request: branches: - main + - maintenance/** + +concurrency: + group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }} + cancel-in-progress: true + +permissions: + contents: read # to fetch code (actions/checkout) + jobs: cygwin_build_test: runs-on: windows-latest + if: github.repository == 'numpy/numpy' steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v3 with: submodules: recursive fetch-depth: 0 - name: Install Cygwin - uses: egor-tensin/setup-cygwin@v3 + uses: cygwin/cygwin-install-action@v2 with: - platform: x64 + platform: x86_64 install-dir: 'C:\tools\cygwin' - packages: > + packages: >- python38-devel python38-zipp python38-importlib-metadata python38-cython python38-pip python38-wheel python38-cffi python38-pytz python38-setuptools python38-pytest - python38-hypothesis liblapack-devel libopenblas + python38-hypothesis liblapack-devel gcc-fortran gcc-g++ git dash - name: Set Windows PATH uses: egor-tensin/cleanup-path@v1 @@ -33,10 +47,9 @@ jobs: run: | command bash bash -c "uname -svrmo" - - name: Update with Cygwin git - # fetch-depth=0 above should make this short. + - name: Tell Cygwin's git about this repository. run: | - dash -c "which git; /usr/bin/git fetch --all -p" + dash -c "which git; /usr/bin/git config --system --add safe.directory /cygdrive/d/a/numpy/numpy" - name: Verify python version # Make sure it's the Cygwin one, not a Windows one run: | @@ -56,15 +69,19 @@ jobs: run: >- dash -c "/usr/bin/python3.8 runtests.py -n -vv" - name: Upload wheel if tests fail - uses: actions/upload-artifact@v2 + uses: actions/upload-artifact@v3 if: failure() with: name: numpy-cygwin-wheel path: dist/numpy-*cp38*.whl - - name: On failure check the extension modules + - name: Check the extension modules on failure if: failure() run: | dash -c "/usr/bin/python3.8 -m pip show numpy" dash -c "/usr/bin/python3.8 -m pip show -f numpy | grep .dll" dash -c "/bin/tr -d '\r' list_dlls_unix.sh" dash "list_dlls_unix.sh" 3.8 + - name: Print installed package versions on failure + if: failure() + run: | + cygcheck -c diff --git a/.github/workflows/docker.yml b/.github/workflows/docker.yml index cc4950590af0..694483ed7914 100644 --- a/.github/workflows/docker.yml +++ b/.github/workflows/docker.yml @@ -1,37 +1,40 @@ name: Build Base Docker Image on: - push: + push: branches: - main paths: - - 'environment.yml' + - "environment.yml" -jobs: - build: - name: Build base Docker image +permissions: + contents: read # to fetch code (actions/checkout) + +jobs: + build_docker: + name: Build base Docker image runs-on: ubuntu-latest environment: numpy-dev if: "github.repository_owner == 'numpy' && !contains(github.event.head_commit.message, '[ci skip]') && !contains(github.event.head_commit.message, '[skip ci]') && !contains(github.event.head_commit.message, '[skip github]')" steps: - name: Clone repository - uses: actions/checkout@v2 - - name: Lint Docker + uses: actions/checkout@v3 + - name: Lint Docker uses: brpaz/hadolint-action@v1.2.1 - with: + with: dockerfile: ./tools/gitpod/Dockerfile - name: Get refs shell: bash run: | export raw_branch=${GITHUB_REF#refs/heads/} - echo "::set-output name=branch::${raw_branch//\//-}" - echo "::set-output name=date::$(date +'%Y%m%d')" - echo "::set-output name=sha8::$(echo ${GITHUB_SHA} | cut -c1-8)" + echo "branch=${raw_branch//\//-}" >> $GITHUB_OUTPUT + echo "date=$(date +'%Y%m%d')" >> $GITHUB_OUTPUT + echo "sha8=$(echo ${GITHUB_SHA} | cut -c1-8)" >> $GITHUB_OUTPUT id: getrefs - name: Set up Docker Buildx uses: docker/setup-buildx-action@v1 - name: Cache Docker layers - uses: actions/cache@v2 + uses: actions/cache@v3 with: path: /tmp/.buildx-cache key: ${{ runner.os }}-buildx-${{ github.sha }} @@ -52,6 +55,6 @@ jobs: cache-to: type=local,dest=/tmp/.buildx-cache tags: | numpy/numpy-dev:${{ steps.getrefs.outputs.date }}-${{ steps.getrefs.outputs.branch}}-${{ steps.getrefs.outputs.sha8 }}, numpy/numpy-dev:latest - - name: Image digest + - name: Image digest # Return details of the image build: sha and shell run: echo ${{ steps.docker_build.outputs.digest }} diff --git a/.github/workflows/emscripten.yml b/.github/workflows/emscripten.yml new file mode 100644 index 000000000000..4fb48e6e6ea1 --- /dev/null +++ b/.github/workflows/emscripten.yml @@ -0,0 +1,75 @@ +# To enable this workflow on a fork, comment out: +# +# if: github.repository == 'numpy/numpy' +name: Test Emscripten/Pyodide build + +on: + pull_request: + branches: + - main + - maintenance/** + +concurrency: + group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }} + cancel-in-progress: true + +permissions: + contents: read # to fetch code (actions/checkout) + +jobs: + build-wasm-emscripten: + runs-on: ubuntu-22.04 + if: github.repository == 'numpy/numpy' + env: + PYODIDE_VERSION: 0.22.0a3 + # PYTHON_VERSION and EMSCRIPTEN_VERSION are determined by PYODIDE_VERSION. + # The appropriate versions can be found in the Pyodide repodata.json + # "info" field, or in Makefile.envs: + # https://github.com/pyodide/pyodide/blob/main/Makefile.envs#L2 + PYTHON_VERSION: 3.10.7 + EMSCRIPTEN_VERSION: 3.1.24 + NODE_VERSION: 18 + steps: + - name: Checkout numpy + uses: actions/checkout@v3 + with: + submodules: true + # versioneer.py requires the latest tag to be reachable. Here we + # fetch the complete history to get access to the tags. + # A shallow clone can work when the following issue is resolved: + # https://github.com/actions/checkout/issues/338 + fetch-depth: 0 + + - name: set up python + id: setup-python + uses: actions/setup-python@v4 + with: + python-version: ${{ env.PYTHON_VERSION }} + + - uses: mymindstorm/setup-emsdk@v11 + with: + version: ${{ env.EMSCRIPTEN_VERSION }} + actions-cache-folder: emsdk-cache + + - name: Install pyodide-build + run: pip install pyodide-build==$PYODIDE_VERSION + + - name: Build + run: CFLAGS=-g2 LDFLAGS=-g2 pyodide build + + - name: set up node + uses: actions/setup-node@v3 + with: + node-version: ${{ env.NODE_VERSION }} + + - name: Set up Pyodide virtual environment + run: | + pyodide venv .venv-pyodide + source .venv-pyodide/bin/activate + pip install dist/*.whl + pip install -r test_requirements.txt + - name: Test + run: | + source .venv-pyodide/bin/activate + cd .. + python numpy/runtests.py -n -vv diff --git a/.github/workflows/gitpod.yml b/.github/workflows/gitpod.yml index bbca928656df..1b521fc635ad 100644 --- a/.github/workflows/gitpod.yml +++ b/.github/workflows/gitpod.yml @@ -5,15 +5,18 @@ on: branches: - main +permissions: + contents: read # to fetch code (actions/checkout) + jobs: - build: + build_gitpod: name: Build Gitpod Docker image runs-on: ubuntu-latest environment: numpy-dev if: "github.repository_owner == 'numpy' && !contains(github.event.head_commit.message, '[ci skip]') && !contains(github.event.head_commit.message, '[skip ci]') && !contains(github.event.head_commit.message, '[skip github]')" steps: - name: Clone repository - uses: actions/checkout@v2 + uses: actions/checkout@v3 with: fetch-depth: 0 - name: Lint Docker @@ -24,14 +27,14 @@ jobs: shell: bash run: | export raw_branch=${GITHUB_REF#refs/heads/} - echo "::set-output name=branch::${raw_branch//\//-}" - echo "::set-output name=date::$(date +'%Y%m%d')" - echo "::set-output name=sha8::$(echo ${GITHUB_SHA} | cut -c1-8)" + echo "branch=${raw_branch//\//-}" >> $GITHUB_OUTPUT + echo "date=$(date +'%Y%m%d')" >> $GITHUB_OUTPUT + echo "sha8=$(echo ${GITHUB_SHA} | cut -c1-8)" >> $GITHUB_OUTPUT id: getrefs - name: Set up Docker Buildx uses: docker/setup-buildx-action@v1 - name: Cache Docker layers - uses: actions/cache@v2 + uses: actions/cache@v3 with: path: /tmp/.buildx-cache key: ${{ runner.os }}-buildx-${{ github.sha }} diff --git a/.github/workflows/labeler.yml b/.github/workflows/labeler.yml index 99db967b383b..d673b2faf09d 100644 --- a/.github/workflows/labeler.yml +++ b/.github/workflows/labeler.yml @@ -3,8 +3,14 @@ on: pull_request_target: types: [opened, synchronize, reopened, edited] +permissions: {} + jobs: pr-labeler: + permissions: + contents: read # to read a configuration file + pull-requests: write # to add labels to pull requests + runs-on: ubuntu-latest steps: - name: Label the PR diff --git a/.github/workflows/scorecards.yml b/.github/workflows/scorecards.yml new file mode 100644 index 000000000000..0cef4f7a9626 --- /dev/null +++ b/.github/workflows/scorecards.yml @@ -0,0 +1,55 @@ +name: Scorecards supply-chain security +on: + # For Branch-Protection check. Only the default branch is supported. See + # https://github.com/ossf/scorecard/blob/main/docs/checks.md#branch-protection + branch_protection_rule: + # To guarantee Maintained check is occasionally updated. See + # https://github.com/ossf/scorecard/blob/main/docs/checks.md#maintained + schedule: + - cron: "19 23 * * 5" + push: + branches: ["main"] + +# Declare default permissions as read only. +permissions: read-all + +jobs: + analysis: + name: Scorecards analysis + runs-on: ubuntu-latest + permissions: + # Needed to upload the results to code-scanning dashboard. + security-events: write + # Needed to publish results and get a badge (see publish_results below). + id-token: write + + steps: + - name: "Checkout code" + uses: actions/checkout@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8 # v3.1.0 + with: + persist-credentials: false + + - name: "Run analysis" + uses: ossf/scorecard-action@99c53751e09b9529366343771cc321ec74e9bd3d # v2.0.6 + with: + results_file: results.sarif + results_format: sarif + # Publish results to OpenSSF REST API for easy access by consumers. + # Allows the repository to include the Scorecard badge. + # See https://github.com/ossf/scorecard-action#publishing-results. + publish_results: true + + # Upload the results as artifacts (optional). Commenting out will disable + # uploads of run results in SARIF format to the repository Actions tab. + - name: "Upload artifact" + uses: actions/upload-artifact@3cea5372237819ed00197afe530f5a7ea3e805c8 # v3.1.0 + with: + name: SARIF file + path: results.sarif + retention-days: 5 + + # Upload the results to GitHub's code scanning dashboard. + - name: "Upload to code-scanning" + uses: github/codeql-action/upload-sarif@807578363a7869ca324a79039e6db9c843e0e100 # v2.1.27 + with: + sarif_file: results.sarif diff --git a/.github/workflows/wheels.yml b/.github/workflows/wheels.yml index 3c382f8b32db..a716139c4f48 100644 --- a/.github/workflows/wheels.yml +++ b/.github/workflows/wheels.yml @@ -3,19 +3,37 @@ # # if: github.repository == 'numpy/numpy' # -# in the get_commit_message job. Be sure to include [cd build] in your commit +# in the get_commit_message job. Be sure to include [wheel build] in your commit # message to trigger the build. All files related to wheel building are located # at tools/wheels/ +# Alternatively, you can add labels to the pull request in order to trigger wheel +# builds. +# The labels that trigger builds are: +# 36 - Build(for changes to the building process, +# 14 - Release(ensure wheels build before release) name: Wheel builder on: schedule: - # Nightly build at 1:42 UTC - - cron: "42 1 * * *" + # ┌───────────── minute (0 - 59) + # │ ┌───────────── hour (0 - 23) + # │ │ ┌───────────── day of the month (1 - 31) + # │ │ │ ┌───────────── month (1 - 12 or JAN-DEC) + # │ │ │ │ ┌───────────── day of the week (0 - 6 or SUN-SAT) + # │ │ │ │ │ + - cron: "42 1 * * 4" push: pull_request: + types: [labeled, opened, synchronize, reopened] workflow_dispatch: +concurrency: + group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }} + cancel-in-progress: true + +permissions: + contents: read # to fetch code (actions/checkout) + jobs: get_commit_message: name: Get commit message @@ -25,7 +43,7 @@ jobs: message: ${{ steps.commit_message.outputs.message }} steps: - name: Checkout numpy - uses: actions/checkout@v2 + uses: actions/checkout@v3 # Gets the correct commit message for pull request with: ref: ${{ github.event.pull_request.head.sha }} @@ -34,46 +52,49 @@ jobs: run: | set -xe COMMIT_MSG=$(git log --no-merges -1 --oneline) - echo "::set-output name=message::$COMMIT_MSG" + echo "message=$COMMIT_MSG" >> $GITHUB_OUTPUT + echo github.ref ${{ github.ref }} build_wheels: - name: Build wheel for cp${{ matrix.python }}-${{ matrix.platform }} + name: Build wheel for ${{ matrix.python }}-${{ matrix.buildplat[1] }} needs: get_commit_message if: >- contains(needs.get_commit_message.outputs.message, '[wheel build]') || github.event_name == 'schedule' || - github.event_name == 'workflow_dispatch' - runs-on: ${{ matrix.os }} + github.event_name == 'workflow_dispatch' || + (github.event_name == 'pull_request' && + (contains(github.event.pull_request.labels.*.name, '36 - Build') || + contains(github.event.pull_request.labels.*.name, '14 - Release'))) || + (github.event_name == 'push' && startsWith(github.ref, 'refs/tags/v') && ( ! endsWith(github.ref, 'dev0'))) + runs-on: ${{ matrix.buildplat[0] }} strategy: # Ensure that a wheel builder finishes even if another fails fail-fast: false matrix: - include: - # manylinux builds - - os: ubuntu-latest - python: "38" - platform: manylinux_x86_64 - - os: ubuntu-latest - python: "39" - platform: manylinux_x86_64 - - os: ubuntu-latest - python: "310" - platform: manylinux_x86_64 - - # macos builds - - os: macos-latest - python: "38" - platform: macosx_x86_64 - - os: macos-latest - python: "39" - platform: macosx_x86_64 - - os: macos-latest - python: "310" - platform: macosx_x86_64 - + # Github Actions doesn't support pairing matrix values together, let's improvise + # https://github.com/github/feedback/discussions/7835#discussioncomment-1769026 + buildplat: + - [ubuntu-20.04, manylinux_x86_64] + - [macos-12, macosx_*] + - [windows-2019, win_amd64] + - [windows-2019, win32] + # TODO: uncomment PyPy 3.9 builds once PyPy + # re-releases a new minor version + # NOTE: This needs a bump of cibuildwheel version, also, once that happens. + python: ["cp38", "cp39", "cp310", "cp311", "pp38"] #, "pp39"] + exclude: + # Don't build PyPy 32-bit windows + - buildplat: [windows-2019, win32] + python: "pp38" + - buildplat: [windows-2019, win32] + python: "pp39" + env: + IS_32_BIT: ${{ matrix.buildplat[1] == 'win32' }} + IS_PUSH: ${{ github.event_name == 'push' && startsWith(github.ref, 'refs/tags/v') }} + IS_SCHEDULE_DISPATCH: ${{ github.event_name == 'schedule' || github.event_name == 'workflow_dispatch' }} steps: - name: Checkout numpy - uses: actions/checkout@v2 + uses: actions/checkout@v3 with: submodules: true # versioneer.py requires the latest tag to be reachable. Here we @@ -82,23 +103,110 @@ jobs: # https://github.com/actions/checkout/issues/338 fetch-depth: 0 + # Used to push the built wheels + - uses: actions/setup-python@v4 + with: + python-version: "3.x" + + - name: setup rtools for 32-bit + run: | + echo "PLAT=i686" >> $env:GITHUB_ENV + echo "MSYSTEM=MINGW32" >> $env:GITHUB_ENV + echo "PATH=$env:RTOOLS40_HOME\mingw32\bin;$env:PATH" >> $env:GITHUB_ENV + gfortran --version + if: ${{ matrix.buildplat[1] == 'win32' }} + - name: Build wheels - uses: pypa/cibuildwheel@v2.1.3 + uses: pypa/cibuildwheel@v2.11.2 env: - NPY_USE_BLAS_ILP64: 1 - CIBW_BUILD: cp${{ matrix.python }}-${{ matrix.platform }} - CIBW_MANYLINUX_X86_64_IMAGE: manylinux2014 - CIBW_ENVIRONMENT_LINUX: CFLAGS='-std=c99 -fno-strict-aliasing' - LDFLAGS='-Wl,--strip-debug' - OPENBLAS64_=/usr/local - # MACOS linker doesn't support stripping symbols - CIBW_ENVIRONMENT_MACOS: CFLAGS='-std=c99 -fno-strict-aliasing' - OPENBLAS64_=/usr/local - CIBW_BUILD_VERBOSITY: 3 - CIBW_BEFORE_BUILD: bash {project}/tools/wheels/cibw_before_build.sh {project} - CIBW_BEFORE_TEST: pip install -r {project}/test_requirements.txt - CIBW_TEST_COMMAND: bash {project}/tools/wheels/cibw_test_command.sh {project} + CIBW_BUILD: ${{ matrix.python }}-${{ matrix.buildplat[1] }} - - uses: actions/upload-artifact@v2 + - uses: actions/upload-artifact@v3 with: + name: ${{ matrix.python }}-${{ startsWith(matrix.buildplat[1], 'macosx') && 'macosx' || matrix.buildplat[1] }} path: ./wheelhouse/*.whl + + - name: Upload wheels + if: success() + shell: bash + env: + NUMPY_STAGING_UPLOAD_TOKEN: ${{ secrets.NUMPY_STAGING_UPLOAD_TOKEN }} + NUMPY_NIGHTLY_UPLOAD_TOKEN: ${{ secrets.NUMPY_NIGHTLY_UPLOAD_TOKEN }} + run: | + source tools/wheels/upload_wheels.sh + set_upload_vars + # trigger an upload to + # https://anaconda.org/scipy-wheels-nightly/numpy + # for cron jobs or "Run workflow" (restricted to main branch). + # Tags will upload to + # https://anaconda.org/multibuild-wheels-staging/numpy + # The tokens were originally generated at anaconda.org + upload_wheels + build_sdist: + name: Build sdist + needs: get_commit_message + if: >- + contains(needs.get_commit_message.outputs.message, '[wheel build]') || + github.event_name == 'schedule' || + github.event_name == 'workflow_dispatch' || + (github.event_name == 'pull_request' && + (contains(github.event.pull_request.labels.*.name, '36 - Build') || + contains(github.event.pull_request.labels.*.name, '14 - Release'))) || + (github.event_name == 'push' && startsWith(github.ref, 'refs/tags/v') && ( ! endsWith(github.ref, 'dev0'))) + runs-on: ubuntu-latest + env: + IS_PUSH: ${{ github.event_name == 'push' && startsWith(github.ref, 'refs/tags/v') }} + IS_SCHEDULE_DISPATCH: ${{ github.event_name == 'schedule' || github.event_name == 'workflow_dispatch' }} + steps: + - name: Checkout numpy + uses: actions/checkout@v3 + with: + submodules: true + # versioneer.py requires the latest tag to be reachable. Here we + # fetch the complete history to get access to the tags. + # A shallow clone can work when the following issue is resolved: + # https://github.com/actions/checkout/issues/338 + fetch-depth: 0 + # Used to push the built wheels + - uses: actions/setup-python@v4 + with: + # Build sdist on lowest supported Python + python-version: "3.8" + - name: Build sdist + run: | + python setup.py sdist + - name: Test the sdist + run: | + # TODO: Don't run test suite, and instead build wheels from sdist + # Depends on pypa/cibuildwheel#1020 + python -m pip install dist/*.gz + pip install -r test_requirements.txt + cd .. # Can't import numpy within numpy src directory + python -c "import numpy; print(numpy.__version__); numpy.test();" + + - name: Check README rendering for PyPI + run: | + python -mpip install twine + twine check dist/* + + - uses: actions/upload-artifact@v3 + with: + name: sdist + path: ./dist/* + + - name: Upload sdist + if: success() + shell: bash + env: + NUMPY_STAGING_UPLOAD_TOKEN: ${{ secrets.NUMPY_STAGING_UPLOAD_TOKEN }} + NUMPY_NIGHTLY_UPLOAD_TOKEN: ${{ secrets.NUMPY_NIGHTLY_UPLOAD_TOKEN }} + run: | + source tools/wheels/upload_wheels.sh + set_upload_vars + # trigger an upload to + # https://anaconda.org/scipy-wheels-nightly/numpy + # for cron jobs or "Run workflow" (restricted to main branch). + # Tags will upload to + # https://anaconda.org/multibuild-wheels-staging/numpy + # The tokens were originally generated at anaconda.org + upload_wheels diff --git a/.gitignore b/.gitignore index 52997523cdea..e2ee6a013851 100644 --- a/.gitignore +++ b/.gitignore @@ -68,6 +68,7 @@ _build # setup.py dist directory dist doc/build +doc/docenv doc/cdoc/build # Egg metadata *.egg-info @@ -126,6 +127,7 @@ site.cfg numpy/core/include/numpy/__multiarray_api.c numpy/core/include/numpy/__ufunc_api.c numpy/core/include/numpy/__umath_generated.c +numpy/core/include/numpy/_umath_doc_generated.h numpy/core/include/numpy/config.h numpy/core/include/numpy/multiarray_api.txt numpy/core/include/numpy/ufunc_api.txt @@ -143,6 +145,7 @@ numpy/core/src/multiarray/lowlevel_strided_loops.c numpy/core/src/multiarray/multiarray_tests.c numpy/core/src/multiarray/nditer_templ.c numpy/core/src/multiarray/scalartypes.c +numpy/core/src/multiarray/textreading/tokenize.c numpy/core/src/npymath/ieee754.c numpy/core/src/npymath/npy_math_complex.c numpy/core/src/npymath/npy_math_internal.h @@ -157,7 +160,6 @@ numpy/core/src/npysort/sort.c numpy/core/src/private/npy_binsearch.h numpy/core/src/private/npy_partition.h numpy/core/src/private/templ_common.h -numpy/core/src/umath/_operand_flag_tests.c numpy/core/src/umath/_rational_tests.c numpy/core/src/umath/_struct_ufunc_tests.c numpy/core/src/umath/_umath_tests.c @@ -172,6 +174,7 @@ numpy/core/src/umath/struct_ufunc_test.c numpy/core/src/umath/test_rational.c numpy/core/src/umath/umath_tests.c numpy/core/src/umath/loops_utils.h +numpy/core/src/umath/loops_modulo.dispatch.c numpy/distutils/__config__.py numpy/linalg/umath_linalg.c doc/source/**/generated/ @@ -218,6 +221,16 @@ numpy/core/src/_simd/_simd_inc.h numpy/core/src/umath/loops_unary_fp.dispatch.c numpy/core/src/umath/loops_arithm_fp.dispatch.c numpy/core/src/umath/loops_arithmetic.dispatch.c +numpy/core/src/umath/loops_minmax.dispatch.c numpy/core/src/umath/loops_trigonometric.dispatch.c numpy/core/src/umath/loops_exponent_log.dispatch.c numpy/core/src/umath/loops_umath_fp.dispatch.c +numpy/core/src/umath/loops_hyperbolic.dispatch.c +numpy/core/src/umath/loops_modulo.dispatch.c +numpy/core/src/umath/loops_comparison.dispatch.c +# npysort module +numpy/core/src/npysort/x86-qsort.dispatch.c +numpy/core/src/npysort/x86-qsort.dispatch.*.cpp +# multiarray module +numpy/core/src/multiarray/argfunc.dispatch.c +numpy/core/src/multiarray/arraytypes.h diff --git a/.gitpod.yml b/.gitpod.yml index f9c35fd9bcf5..42513de8d331 100644 --- a/.gitpod.yml +++ b/.gitpod.yml @@ -6,18 +6,21 @@ image: numpy/numpy-gitpod:latest tasks: - - name: Prepare development + - name: Prepare development environment init: | mkdir -p .vscode cp tools/gitpod/settings.json .vscode/settings.json + rm -f /workspace/numpy/.git/shallow.lock conda activate numpy-dev + git pull --unshallow # need to force this else the prebuild fails + git fetch --tags + git submodule update --init python setup.py build_ext --inplace echo "🛠 Completed rebuilding NumPy!! 🛠 " echo "📖 Building docs 📖 " cd doc make html echo "✨ Pre-build complete! You can close this terminal ✨ " - # -------------------------------------------------------- # exposing ports for liveserve @@ -60,3 +63,4 @@ github: addBadge: false # add a label once the prebuild is ready to pull requests (defaults to false) addLabel: false + \ No newline at end of file diff --git a/.mailmap b/.mailmap index fd020c8186c6..fd89ecd65d8a 100644 --- a/.mailmap +++ b/.mailmap @@ -8,15 +8,20 @@ # This file is up-to-date if the command git log --format="%aN <%aE>" | sort -u # gives no duplicates. +@amagicmuffin <2014wcheng@gmail.com> @8bitmp3 <19637339+8bitmp3@users.noreply.github.com> +@dg3192 <113710955+dg3192@users.noreply.github.com> @DWesl <22566757+DWesl@users.noreply.github.com> @Endolith +@GalaxySnail @Illviljan <14371165+Illviljan@users.noreply.github.com> +@juztamau5 @LSchroefl <65246829+LSchroefl@users.noreply.github.com> @Lbogula @Lisa <34400837+lyzlisa@users.noreply.github.com> @Patrick <39380924+xamm@users.noreply.github.com> @Scian <65375075+hoony6134@users.noreply.github.com> +@code-review-doctor @h-vetinari @h6197627 <44726212+h6197627@users.noreply.github.com> @jbCodeHub @@ -26,13 +31,14 @@ @sfolje0 @spacescientist @tautaus -@vinith2 <85550536+vinith2@users.noreply.github.com> @xoviat <49173759+xoviat@users.noreply.github.com> @xoviat <49173759+xoviat@users.noreply.github.com> @yan-wyb @yetanothercheer Aaron Baecker Aarthi Agurusa +Adarsh Singh ADARSH SINGH +Andrei Batomunkuev Ajay DS Ajay DS Alan Fontenot @@ -44,13 +50,19 @@ Abhinav Reddy Abel Aoun Adam Ginsburg Aerik Pawson <45904740+aerikpawson@users.noreply.github.com> +Ahmet Can Solak +Amrit Krishnan +Amrit Krishnan +Alban Desmaison Albert Jornet Puig Alberto Rubiales +Ales Crocaro Alex Rockhill Alex Griffing Alex Griffing Alex Griffing Alex Henrie +Alex Low Alex Rogozhnikov Alex Thomas Alexander Belopolsky @@ -66,6 +78,8 @@ Allan Haldane Al-Baraa El-Hag <48454648+a-elhag@users.noreply.github.com> Alok Singhal Alok Singhal Alyssa Quek +Ankit Dwivedi +Ankit Dwivedi Amir Sarabadani Anas Khan Anatoly Techtonik @@ -93,6 +107,8 @@ Ashutosh Singh <55102089+Ashutosh619-sudo@users.nor Åsmund Hjulstad Auke Wiggers Badhri Narayanan Krishnakumar +Bhavuk Kalra +Bhavuk Kalra Bangcheng Yang Bhargav V <12525622+brpy@users.noreply.github.com> Bas van Beek <43369155+BvB93@users.noreply.github.com> @@ -106,18 +122,28 @@ Bertrand Lefebvre Bharat Raghunathan Bharat Raghunathan Bob Eldering +Bram Ton +Bram Ton +Bram Ton Brent Brewington Brett R Murphy -Brigitta Sipocz Brian Soto -Brian Soto Brian Soto +Brian Soto +Brigitta Sipőcz +Brigitta Sipőcz +Brock Mendel Bryan Van de Ven Bryan Van de Ven Bryan Van de Ven Bryan Van de Ven +Brénainn Woodsend Bui Duc Minh <41239569+Mibu287@users.noreply.github.com> +Caio Agiani Carl Kleffner Carl Leake Charles Stern <62192187+cisaacstern@users.noreply.github.com> +Chiara Marmo +Chiara Marmo +Chiara Marmo Chris Barker Chris Burns Chris Fu (傅立业) <17433201@qq.com> @@ -135,6 +161,7 @@ Chunlin Fang Chunlin Fang <834352945@qq.com> Colin Snyder <8csnyder@gmail.com> <47012605+colinsnyder@users.noreply.github.com> Constanza Fierro +Dahyun Kim Daniel B Allan Daniel da Silva Daniel da Silva @@ -147,6 +174,7 @@ Daniel Rasmussen Daniel G. A. Smith Daniel G. A. Smith Dario Mory +Dave Goel David Badnar David Cortes David Huard dhuard @@ -154,6 +182,7 @@ David M Cooke David Nicholson David Ochoa David Pitchford +David Prosin Davide Dal Bosco <62077652+davidedalbosco@users.noreply.github.com> Dawid Zych Dennis Zollo @@ -161,6 +190,13 @@ Derek Homeier Derek Homeier Derek Homeier Derrick Williams +Devin Shanahan +Digya Acharya +Dima Pasechnik +Dima Pasechnik +Dimitri Papadopoulos Orfanos <3234522+DimitriPapadopoulos@users.noreply.github.com> +Ding Liu +Ding Liu Dmitriy Shalyga Dustan Levenstein <43019642+dustanlevenstein@users.noreply.github.com> Dylan Cutler @@ -189,6 +225,7 @@ Frederic Bastien Frederic FX Coudert Gael Varoquaux Gagandeep Singh +Gavin Zhang Gerrit Holl Gerrit Holl Giuseppe Venturini @@ -203,18 +240,24 @@ Gregory R. Lee Guo Ci guoci Guo Shuai Hameer Abbasi +Hannah Aizenman Han Genuit Hanno Klemm hklemm +Harsh Mishra Helder Oliveira Hemil Desai +Himanshu Hiroyuki V. Yamazaki Hugo van Kemenade +Iantra Solari I-Shen Leong Imen Rajhi Inessa Pawson Irina Maria Mocan <28827042+IrinaMaria@users.noreply.github.com> Irvin Probst +Ivan Meleshko Isabela Presedo-Floyd +Ganesh Kathiresan Gerhard Hobler Giannis Zapantis Guillaume Peillex @@ -222,12 +265,14 @@ Jack J. Woehr Jaime Fernandez Jaime Fernandez Jaime Fernandez -Jamie Macey +Jake Close Jakob Jakobson Jakob Jakobson <43045863+jakobjakobson13@users.noreply.github.com> James Bourbeau James Webber +Jamie Macey Jan Schlüter +Janus Heide Jarrod Millman Jarrod Millman Jason Grout Jason King @@ -238,8 +283,14 @@ Jeffrey Yancey <3820914+jeffyancey@users.noreply.github.co Jeremy Lay Jérémie du Boisberranger jeremiedbb <34657725+jeremiedbb@users.noreply.github.com> Jérome Eertmans +Jérôme Richard Jerome Kelleher +Jessé Pires Jessi J Zhao <35235453+jessijzhao@users.noreply.github.com> +João Fontes Gonçalves +Johnathon Cusick +Jhong-Ken Chen (陳仲肯) +Jhong-Ken Chen (陳仲肯) <37182101+kennychenfs@users.noreply.github.com> Johannes Hampp <42553970+euronion@users.noreply.github.com> Johannes Schönberger Johann Faouzi @@ -247,6 +298,9 @@ John Darbyshire <24256554+attack68@users.noreply.github.com> <24256554+attack68@ John Hagen John Kirkham John Kirkham +Jonas I. Liechti +Jonas I. Liechti +Jonas I. Liechti Joseph Fox-Rabinovitz Joseph Fox-Rabinovitz Joseph Fox-Rabinovitz @@ -257,6 +311,7 @@ Julian Taylor Julian Taylor Julien Lhermitte Julien Lhermitte Julien Schueller +Junyan Ou Justus Magin Justus Magin Kai Striega @@ -283,8 +338,11 @@ Lars Buitinck Lars Buitinck Lars Buitinck Lars Buitinck Lars Grüter Lars Grüter +Leona Taric <92495067+LeonaTaric@users.noreply.github.com> Leonardus Chen Licht Takeuchi +Lorenzo Mammana +Lillian Zha Luis Pedro Coelho Luke Zoltan Kelley Madhulika Jain Chambers <53166646+madhulikajc@users.noreply.github.com> @@ -309,16 +367,19 @@ Martin Teichmann Mary Conley Masashi Kishimoto Matheus Vieira Portela +Matheus Santana Patriarca Mathieu Lamarre Matías Ríos Matt Ord Matt Ord <55235095+Matt-Ord@users.noreply.github.com> Matt Hancock Martino Sorbaro +Márton Gunyhó Mattheus Ueckermann Matthew Barber Matthew Harrigan Matthias Bussonnier +Matthieu Darbois Matti Picus Maximilian Konrad Melissa Weber Mendonça @@ -336,6 +397,7 @@ Michael Schnaitter Michel Fruchart Mike Toews +Miles Cranmer Mircea Akos Bruma Mircea Akos Bruma Mitchell Faas <35742861+Mitchell-Faas@users.noreply.github.com> @@ -352,14 +414,23 @@ Nicholas A. Del Grosso nickdg Nicholas McKibben Nick Minkyu Lee fivemok <9394929+fivemok@users.noreply.github.com> Oliver Eberle +Oleksiy Kononenko +Oleksiy Kononenko <35204136+oleksiyskononenko@users.noreply.github.com> +Omar Ali +Omid Rajaei +Omid Rajaei <89868505+rajaeinet@users.noreply.github.com> Ondřej Čertík Óscar Villellas Guillén Panos Mavrogiorgos +Pantelis Antonoudiou +Pantelis Antonoudiou Pat Miller patmiller Paul Ivanov Paul Ivanov Paul YS Lee Paul Paul Jacobson +Pey Lian Lim +Pey Lian Lim <2090236+pllim@users.noreply.github.com> Pearu Peterson Pete Peeradej Tanruangporn Peter Bell @@ -384,6 +455,9 @@ Riya Sharma Robert Kern Robert LU Robert T. McGibbon +Rohit Goswami +Rohit Goswami +Rohit Goswami Roland Kaufmann Roman Yurchak Ronan Lamy Ronan Lamy @@ -401,29 +475,38 @@ Samesh Lakhotia Samesh Lakhotia <43701530+sameshl@users.noreply.github.com> Sami Salonen Sanchez Gonzalez Alvaro +Sanya Sinha <83265366+ssanya942@users.noreply.github.com> +Saransh Chopra Saullo Giovani Saurabh Mehta Sayantika Banik +Schrijvers Luc Sebastian Berg Sebastian Schleehauf Serge Guelton Sergei Vorfolomeev <39548292+vorfol@users.noreply.github.com> +Shuangchi He Shubham Gupta Shubham Gupta <63910248+shubham11941140@users.noreply.github.com> Shekhar Prasad Rajak Shen Zhou +Shreya Singh Shota Kawabuchi Siavash Eliasi Simon Conseil Simon Gasse Simon Gasse +Sista Seetaram +Sista Seetaram <65669128+sistaseetaram@users.noreply.github.com> Søren Rasmussen <47032123+sorenrasmussenai@users.noreply.github.com> Spencer Hill +Srimukh Sripada Stefan Behnel Stefan van der Walt Stefan van der Walt Stephan Hoyer Stephan Hoyer +Stephen Worsley <49274989+stephenworsley@users.noreply.github.com> Steve Stagg Steven J Kern Stuart Archibald @@ -452,7 +535,11 @@ Travis Oliphant Travis Oliphant Valentin Haenel Valentin Haenel +Vardhaman Kalloli <83634399+cyai@users.noreply.github.com> Varun Nayyar +Vinith Kishore +Vinith Kishore <85550536+vinith2@users.noreply.github.com> +Vrinda Narayan Vrinda Narayan Vrinda Narayan <48102157+vrindaaa@users.noreply.github.com> Wansoo Kim @@ -466,6 +553,8 @@ Wojtek Ruszczewski Wojciech Rzadkowski <33913808+wrzadkow@users.noreply.github.com> Yang Hau Yang Hau +Yashasvi Misra +Yashasvi Misra <54177363+yashasvimisra2798@users.noreply.github.com> Yogesh Raisinghani <46864533+raisinghanii@users.noreply.github.com> Yu Feng Yuji Kanagawa diff --git a/.travis.yml b/.travis.yml index 5652e2dbde68..e67099f84d41 100644 --- a/.travis.yml +++ b/.travis.yml @@ -26,41 +26,29 @@ cache: jobs: include: - - python: 3.8 + - python: "3.8" os: linux arch: ppc64le env: # use OpenBLAS build, not system ATLAS - DOWNLOAD_OPENBLAS=1 - - NPY_USE_BLAS_ILP64=1 + # - NPY_USE_BLAS_ILP64=1 # the openblas build fails - ATLAS=None + # VSX4 still not supported by ubuntu/gcc-11 + - EXPECT_CPU_FEATURES="VSX VSX2 VSX3" - - python: 3.8 + - python: "3.8" os: linux arch: s390x + # fixes VX assembler ambiguous errors + # due to compiler incompatibility + install: sudo apt update && sudo apt -y --only-upgrade install binutils env: # use OpenBLAS build, not system ATLAS - DOWNLOAD_OPENBLAS=1 - NPY_USE_BLAS_ILP64=1 - ATLAS=None - - - python: 3.8 - os: linux - arch: arm64 - virt: vm - env: - # use OpenBLAS build, not system ATLAS - - DOWNLOAD_OPENBLAS=1 - - ATLAS=None - - - python: 3.10-dev - os: linux - arch: arm64 - virt: vm - env: - # use OpenBLAS build, not system ATLAS - - DOWNLOAD_OPENBLAS=1 - - ATLAS=None + - EXPECT_CPU_FEATURES="VX VXE VXE2" before_install: - ./tools/travis-before-install.sh diff --git a/INSTALL.rst.txt b/INSTALL.rst similarity index 96% rename from INSTALL.rst.txt rename to INSTALL.rst index 1bc97c4b5f86..f136b7cfcd32 100644 --- a/INSTALL.rst.txt +++ b/INSTALL.rst @@ -14,15 +14,15 @@ Prerequisites Building NumPy requires the following installed software: -1) Python__ 3.7.x or newer. +1) Python__ 3.8.x or newer. Please note that the Python development headers also need to be installed, e.g., on Debian/Ubuntu one needs to install both `python3` and `python3-dev`. On Windows and macOS this is normally not an issue. -2) Cython >= 0.29.21 +2) Cython >= 0.29.30 but < 3.0 -3) pytest__ (optional) 1.15 or later +3) pytest__ (optional) This is required for testing NumPy, but not for using it. @@ -75,7 +75,8 @@ skipped when running the test suite if no Fortran compiler is available. For building Scipy a Fortran compiler is needed though, so we include some details on Fortran compilers in the rest of this section. -On OS X and Linux, all common compilers will work. +On OS X and Linux, all common compilers will work. The minimum supported GCC +version is 6.5. For Fortran, ``gfortran`` works, ``g77`` does not. In case ``g77`` is installed then ``g77`` will be detected and used first. To explicitly select diff --git a/LICENSE.txt b/LICENSE.txt index 4723d4ea009e..e1fb614d6652 100644 --- a/LICENSE.txt +++ b/LICENSE.txt @@ -1,4 +1,4 @@ -Copyright (c) 2005-2021, NumPy Developers. +Copyright (c) 2005-2022, NumPy Developers. All rights reserved. Redistribution and use in source and binary forms, with or without diff --git a/README.md b/README.md index 04825dc5d941..02f8f17fb95a 100644 --- a/README.md +++ b/README.md @@ -1,19 +1,11 @@ -# NumPy - - - - - - - - - - - +

+ +


+ [![Powered by NumFOCUS](https://img.shields.io/badge/powered%20by-NumFOCUS-orange.svg?style=flat&colorA=E1523D&colorB=007D8A)]( https://numfocus.org) -[![Pypi Downloads](https://img.shields.io/pypi/dm/numpy.svg?label=Pypi%20downloads)]( +[![PyPI Downloads](https://img.shields.io/pypi/dm/numpy.svg?label=PyPI%20downloads)]( https://pypi.org/project/numpy/) [![Conda Downloads](https://img.shields.io/conda/dn/conda-forge/numpy.svg?label=Conda%20downloads)]( https://anaconda.org/conda-forge/numpy) @@ -21,8 +13,10 @@ https://anaconda.org/conda-forge/numpy) https://stackoverflow.com/questions/tagged/numpy) [![Nature Paper](https://img.shields.io/badge/DOI-10.1038%2Fs41592--019--0686--2-blue)]( https://doi.org/10.1038/s41586-020-2649-2) +[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/numpy/numpy/badge)](https://api.securityscorecards.dev/projects/github.com/numpy/numpy) + -NumPy is the fundamental package needed for scientific computing with Python. +NumPy is the fundamental package for scientific computing with Python. - **Website:** https://www.numpy.org - **Documentation:** https://numpy.org/doc @@ -41,25 +35,31 @@ It provides: Testing: -NumPy requires `pytest`. Tests can then be run after installation with: +NumPy requires `pytest` and `hypothesis`. Tests can then be run after installation with: python -c 'import numpy; numpy.test()' +Code of Conduct +---------------------- + +NumPy is a community-driven open source project developed by a diverse group of +[contributors](https://numpy.org/teams/). The NumPy leadership has made a strong +commitment to creating an open, inclusive, and positive community. Please read the +[NumPy Code of Conduct](https://numpy.org/code-of-conduct/) for guidance on how to interact +with others in a way that makes our community thrive. Call for Contributions ---------------------- The NumPy project welcomes your expertise and enthusiasm! -Small improvements or fixes are always appreciated; issues labeled as ["good -first issue"](https://github.com/numpy/numpy/labels/good%20first%20issue) -may be a good starting point. If you are considering larger contributions +Small improvements or fixes are always appreciated. If you are considering larger contributions to the source code, please contact us through the [mailing list](https://mail.python.org/mailman/listinfo/numpy-discussion) first. -Writing code isn’t the only way to contribute to NumPy. You can also: +Writing code isn’t the only way to contribute to NumPy. You can also: - review pull requests -- triage issues +- help us stay on top of new and old issues - develop tutorials, presentations, and other educational materials - maintain and improve [our website](https://github.com/numpy/numpy.org) - develop graphic design for our brand assets and promotional materials @@ -67,6 +67,7 @@ Writing code isn’t the only way to contribute to NumPy. You can also: - help with outreach and onboard new contributors - write grant proposals and help with other fundraising efforts +For more information about the ways you can contribute to NumPy, visit [our website](https://numpy.org/contribute/). If you’re unsure where to start or how your skills fit in, reach out! You can ask on the mailing list or here, on GitHub, by opening a new issue or leaving a comment on a relevant issue that is already open. @@ -77,7 +78,7 @@ numpy-team@googlegroups.com or on Slack (write numpy-team@googlegroups.com for an invitation). We also have a biweekly community call, details of which are announced on the -mailing list. You are very welcome to join. +mailing list. You are very welcome to join. If you are new to contributing to open source, [this guide](https://opensource.guide/how-to-contribute/) helps explain why, what, diff --git a/azure-pipelines.yml b/azure-pipelines.yml index 9d2973b59fa7..1ceaf9a7a200 100644 --- a/azure-pipelines.yml +++ b/azure-pipelines.yml @@ -15,7 +15,26 @@ pr: stages: +- stage: Check + jobs: + - job: Skip + pool: + vmImage: 'ubuntu-20.04' + variables: + DECODE_PERCENTS: 'false' + RET: 'true' + steps: + - bash: | + git_log=`git log --max-count=1 --skip=1 --pretty=format:"%B" | tr "\n" " "` + echo "##vso[task.setvariable variable=log]$git_log" + - bash: echo "##vso[task.setvariable variable=RET]false" + condition: or(contains(variables.log, '[skip azp]'), contains(variables.log, '[azp skip]'), contains(variables.log, '[skip ci]'), contains(variables.log, '[ci skip]')) + - bash: echo "##vso[task.setvariable variable=start_main;isOutput=true]$RET" + name: result + - stage: InitialTests + condition: and(succeeded(), eq(dependencies.Check.outputs['Skip.result.start_main'], 'true')) + dependsOn: Check jobs: # Native build is based on gcc flag `-march=native` @@ -48,12 +67,14 @@ stages: testRunTitle: 'Publish test results for baseline/native' - stage: ComprehensiveTests + condition: and(succeeded(), eq(dependencies.Check.outputs['Skip.result.start_main'], 'true')) + dependsOn: Check jobs: - job: Lint condition: and(succeeded(), eq(variables['Build.Reason'], 'PullRequest')) pool: - vmImage: 'ubuntu-18.04' + vmImage: 'ubuntu-20.04' steps: - task: UsePythonVersion@0 inputs: @@ -80,8 +101,10 @@ stages: - script: | docker run -v $(pwd):/numpy -e CFLAGS="-msse2 -std=c99 -UNDEBUG" \ -e F77=gfortran-5 -e F90=gfortran-5 quay.io/pypa/manylinux2014_i686 \ - /bin/bash -xc "cd numpy && \ - /opt/python/cp38-cp38/bin/python -mvenv venv &&\ + /bin/bash -xc " \ + git config --global --add safe.directory /numpy && \ + cd /numpy && \ + /opt/python/cp38-cp38/bin/python -mvenv venv && \ source venv/bin/activate && \ target=\$(python3 tools/openblas_support.py) && \ cp -r \$target/lib/* /usr/lib && \ @@ -90,8 +113,9 @@ stages: echo CFLAGS \$CFLAGS && \ python3 -m pip install -v . && \ python3 runtests.py -n --debug-info --mode=full -- -rsx --junitxml=junit/test-results.xml && \ + python3 -m pip install threadpoolctl && \ python3 tools/openblas_support.py --check_version" - displayName: 'Run 32-bit manylinux2010 Docker Build / Tests' + displayName: 'Run 32-bit manylinux2014 Docker Build / Tests' - task: PublishTestResults@2 condition: succeededOrFailed() inputs: @@ -102,14 +126,7 @@ stages: - job: macOS pool: - # NOTE: at time of writing, there is a danger - # that using an invalid vmIMage string for macOS - # image silently redirects to a Windows build on Azure; - # for now, use the only image name officially present in - # the docs even though i.e., numba uses another in their - # azure config for mac os -- Microsoft has indicated - # they will patch this issue - vmImage: 'macOS-1015' + vmImage: 'macOS-11' strategy: maxParallel: 3 matrix: @@ -134,28 +151,14 @@ stages: [ -n "$USE_XCODE_10" ] && /bin/bash -c "sudo xcode-select -s /Applications/Xcode_10.app/Contents/Developer" clang --version displayName: 'report clang version' - # NOTE: might be better if we could avoid installing - # two C compilers, but with homebrew looks like we're - # now stuck getting the full gcc toolchain instead of - # just pulling in gfortran + - script: | - set -xe - # same version of gfortran as the open-libs and numpy-wheel builds - curl -L https://github.com/MacPython/gfortran-install/raw/master/archives/gfortran-4.9.0-Mavericks.dmg -o gfortran.dmg - GFORTRAN_SHA256=$(shasum -a 256 gfortran.dmg) - KNOWN_SHA256="d2d5ca5ba8332d63bbe23a07201c4a0a5d7e09ee56f0298a96775f928c3c4b30 gfortran.dmg" - if [ "$GFORTRAN_SHA256" != "$KNOWN_SHA256" ]; then - echo sha256 mismatch - exit 1 + if [[ $PLATFORM == "macosx-arm64" ]]; then + PLAT="arm64" fi - hdiutil attach -mountpoint /Volumes/gfortran gfortran.dmg - sudo installer -pkg /Volumes/gfortran/gfortran.pkg -target / - otool -L /usr/local/gfortran/lib/libgfortran.3.dylib - # Manually symlink gfortran-4.9 to plain gfortran for f2py. - # No longer needed after Feb 13 2020 as gfortran is already present - # and the attempted link errors. Keep this for future reference. - # ln -s /usr/local/bin/gfortran-4.9 /usr/local/bin/gfortran - displayName: 'make libgfortran available on mac os for openblas' + source tools/wheels/gfortran_utils.sh + install_gfortran + displayName: 'install gfortran' # use the pre-built openblas binary that most closely # matches our MacOS wheel builds -- currently based # primarily on file size / name details @@ -173,10 +176,12 @@ stages: displayName: 'Install tools' - script: | python -m pip install -r test_requirements.txt - python -m pip install vulture docutils sphinx==2.2.0 numpydoc + # Don't use doc_requirements.txt since that messes up tests + python -m pip install vulture sphinx==4.3.0 numpydoc==1.4.0 displayName: 'Install dependencies; some are optional to avoid test skips' - script: /bin/bash -c "! vulture . --min-confidence 100 --exclude doc/,numpy/distutils/ | grep 'unreachable'" displayName: 'Check for unreachable code paths in Python modules' + # prefer usage of clang over gcc proper # to match likely scenario on many user mac machines - script: python setup.py build -j 4 build_src --verbose-cfg install @@ -186,28 +191,31 @@ stages: LAPACK: None ATLAS: None CC: /usr/bin/clang - condition: eq(variables['USE_OPENBLAS'], '1') - - script: python setup.py build -j 4 build_ext --inplace install - displayName: 'Build NumPy without OpenBLAS and new casting' - env: - BLAS: None - LAPACK: None - ATLAS: None - CC: /usr/bin/clang - condition: eq(variables['USE_OPENBLAS'], '0') + # wait until after dev build of NumPy to pip # install matplotlib to avoid pip install of older numpy - script: python -m pip install matplotlib displayName: 'Install matplotlib before refguide run' + - script: python runtests.py -g --refguide-check displayName: 'Run Refguide Check' condition: eq(variables['USE_OPENBLAS'], '1') - - script: python runtests.py -n --mode=full -- -rsx --junitxml=junit/test-results.xml + + - script: | + echo LIBRARY_PATH ${LIBRARY_PATH} + python runtests.py -n --mode=full -- -rsx --junitxml=junit/test-results.xml displayName: 'Run Full NumPy Test Suite' condition: eq(variables['USE_OPENBLAS'], '1') - - bash: python tools/openblas_support.py --check_version + env: + # gfortran installed above adds -lSystem, so this is needed to find it (gh-22043) + LIBRARY_PATH: /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/lib + + - bash: | + python -m pip install threadpoolctl + python tools/openblas_support.py --check_version displayName: 'Verify OpenBLAS version' condition: eq(variables['USE_OPENBLAS'], '1') + # import doesn't work when in numpy src directory , so do a pip dev install of build lib to test - script: | #!/bin/bash -v @@ -220,6 +228,7 @@ stages: if [ $check_output_code == 1 ] && [ $check_message == 0 ]; then exit 0; else exit 1;fi displayName: "Check if numpy import fails with accelerate" condition: eq(variables['USE_OPENBLAS'], '0') + - task: PublishTestResults@2 condition: succeededOrFailed() inputs: @@ -230,7 +239,7 @@ stages: - job: Windows pool: - vmImage: 'windows-latest' + vmImage: 'windows-2019' strategy: maxParallel: 6 matrix: @@ -296,31 +305,3 @@ stages: testResultsFiles: '**/test-*.xml' failTaskOnFailedTests: true testRunTitle: 'Publish test results for conda installation' - - - #- job: Linux_gcc48 - #pool: - ## ubuntu-20.04 does not provide a gcc-4.8 package - #vmImage: 'ubuntu-18.04' - #steps: - #- script: | - #sudo apt update - #sudo apt install python3.7 - #sudo apt install python3.7-dev - #if ! `gcc-4.8 2>/dev/null`; then - #sudo apt install gcc-4.8 - #fi - #displayName: 'add gcc 4.8' - #- script: | - ## python3 has no setuptools, so install one to get us going - #python3.7 -m pip install --user --upgrade pip 'setuptools<49.2.0' - #python3.7 -m pip install --user -r test_requirements.txt - #CPPFLAGS='' CC=gcc-4.8 F77=gfortran-5 F90=gfortran-5 \ - #python3.7 runtests.py --debug-info --mode=full -- -rsx --junitxml=junit/test-results.xml - #displayName: 'Run gcc4.8 Build / Tests' - #- task: PublishTestResults@2 - #condition: succeededOrFailed() - #inputs: - #testResultsFiles: '**/test-*.xml' - #failTaskOnFailedTests: true - #testRunTitle: 'Publish test results for gcc 4.8' diff --git a/azure-steps-windows.yml b/azure-steps-windows.yml index 34f9797de23f..8fe677eab1eb 100644 --- a/azure-steps-windows.yml +++ b/azure-steps-windows.yml @@ -6,22 +6,24 @@ steps: architecture: $(PYTHON_ARCH) condition: not(contains(variables['PYTHON_VERSION'], 'PyPy')) - powershell: | - $url = "http://buildbot.pypy.org/nightly/py3.8/pypy-c-jit-latest-win64.zip" + # UsePythonVersion only supports pypy3.6, we need 3.8 + # https://github.com/microsoft/azure-pipelines-tasks/pull/15553 + $url = "https://downloads.python.org/pypy/pypy3.8-v7.3.9-win64.zip" $output = "pypy.zip" $wc = New-Object System.Net.WebClient $wc.DownloadFile($url, $output) echo "downloaded $url to $output" mkdir pypy3 Expand-Archive $output -DestinationPath pypy3 - move pypy3/pypy-c-*/* pypy3 - cp pypy3/pypy3.exe pypy3/python.exe + # move pypy3/pypy-c-*/* pypy3 + move pypy3/pypy*/* pypy3 $pypypath = Join-Path (Get-Item .).FullName pypy3 $env:Path = $pypypath + ";" + $env:Path setx PATH $env:Path python -mensurepip echo "##vso[task.prependpath]$pypypath" condition: contains(variables['PYTHON_VERSION'], 'PyPy') - displayName: "Install PyPy pre-release" + displayName: "Install PyPy3.8 " - script: python -m pip install --upgrade pip wheel displayName: 'Install tools' @@ -30,21 +32,21 @@ steps: displayName: 'Install dependencies; some are optional to avoid test skips' - powershell: | - choco install -y mingw --forcex86 --force --version=7.3.0 + choco install -y rtools refreshenv - displayName: 'Install 32-bit mingw for 32-bit builds' - condition: eq(variables['BITS'], 32) + displayName: 'Install rtools' - powershell: | $ErrorActionPreference = "Stop" - # Download and get the path to "openblas.a". We cannot copy it + # Download and get the path to "openblas". We cannot copy it # to $PYTHON_EXE's directory since that is on a different drive which # mingw does not like. Instead copy it to a directory and set OPENBLAS, # since OPENBLAS will be picked up by the openblas discovery $target = $(python tools/openblas_support.py) mkdir openblas echo "Copying $target to openblas/" - cp $target openblas/ + cp -r $target/* openblas/ + $env:OPENBLAS = $target displayName: 'Download / Install OpenBLAS' # NOTE: for Windows builds it seems much more tractable to use runtests.py @@ -55,7 +57,11 @@ steps: If ($(BITS) -eq 32) { $env:CFLAGS = "-m32" $env:LDFLAGS = "-m32" - $env:PATH = "C:\\ProgramData\\chocolatey\\lib\\mingw\\tools\\install\\mingw$(BITS)\\bin;" + $env:PATH + $env:PATH = "$env:RTOOLS40_HOME\\mingw32\\bin;$env:PATH" + } + Else + { + $env:PATH = "$env:RTOOLS40_HOME\\mingw64\\bin;$env:PATH" } If ( Test-Path env:NPY_USE_BLAS_ILP64 ) { $env:OPENBLAS64_ = "openblas" @@ -70,18 +76,22 @@ steps: } displayName: 'Build NumPy' -- bash: | - pushd . && cd .. && target=$(python -c "import numpy, os; print(os.path.abspath(os.path.join(os.path.dirname(numpy.__file__), '.libs')))") && popd - python -m pip download -d destination --only-binary :all: --no-deps numpy==1.14 - cd destination && unzip numpy*.whl && cp numpy/.libs/*.dll $target - ls $target - displayName: 'Add extraneous & older DLL to numpy/.libs to probe DLL handling robustness' - condition: eq(variables['PYTHON_VERSION'], '3.6') -- script: pushd . && cd .. && python -c "from ctypes import windll; windll.kernel32.SetDefaultDllDirectories(0x00000800); import numpy" && popd - displayName: 'For gh-12667; Windows DLL resolution' - condition: eq(variables['PYTHON_VERSION'], '3.6') +- script: | + python -m pip install threadpoolctl + python tools/openblas_support.py --check_version + displayName: 'Check OpenBLAS version' -- script: python runtests.py -n --show-build-log --mode=$(TEST_MODE) -- -rsx --junitxml=junit/test-results.xml +- powershell: | + If ($(BITS) -eq 32) { + $env:CFLAGS = "-m32" + $env:LDFLAGS = "-m32" + $env:PATH = "$env:RTOOLS40_HOME\\mingw32\\bin;$env:PATH" + } + Else + { + $env:PATH = "$env:RTOOLS40_HOME\\mingw64\\bin;$env:PATH" + } + python runtests.py -n --show-build-log --mode=$(TEST_MODE) -- -rsx --junitxml=junit/test-results.xml displayName: 'Run NumPy Test Suite' - task: PublishTestResults@2 diff --git a/benchmarks/asv.conf.json b/benchmarks/asv.conf.json index 029adb5898db..b60135524c10 100644 --- a/benchmarks/asv.conf.json +++ b/benchmarks/asv.conf.json @@ -43,6 +43,7 @@ // version. "matrix": { "Cython": [], + "setuptools": ["59.2.0"] }, // The directory (relative to the current directory) that benchmarks are diff --git a/benchmarks/asv_compare.conf.json.tpl b/benchmarks/asv_compare.conf.json.tpl index 93d12d4a0b77..01f4e41de708 100644 --- a/benchmarks/asv_compare.conf.json.tpl +++ b/benchmarks/asv_compare.conf.json.tpl @@ -47,6 +47,7 @@ // version. "matrix": { "Cython": [], + "setuptools": ["59.2.0"] }, // The directory (relative to the current directory) that benchmarks are diff --git a/benchmarks/asv_pip_nopep517.py b/benchmarks/asv_pip_nopep517.py index 9ba165493085..085cbff1f4ee 100644 --- a/benchmarks/asv_pip_nopep517.py +++ b/benchmarks/asv_pip_nopep517.py @@ -5,7 +5,7 @@ # pip ignores '--global-option' when pep517 is enabled therefore we disable it. cmd = [sys.executable, '-mpip', 'wheel', '--no-use-pep517'] try: - output = subprocess.check_output(cmd, stderr=subprocess.STDOUT, universal_newlines=True) + output = subprocess.check_output(cmd, stderr=subprocess.STDOUT, text=True) except Exception as e: output = str(e.output) if "no such option" in output: diff --git a/benchmarks/benchmarks/bench_array_coercion.py b/benchmarks/benchmarks/bench_array_coercion.py index 2bae4c0024a2..17629fe7f92f 100644 --- a/benchmarks/benchmarks/bench_array_coercion.py +++ b/benchmarks/benchmarks/bench_array_coercion.py @@ -1,5 +1,3 @@ -from __future__ import absolute_import, division, print_function - from .common import Benchmark import numpy as np diff --git a/benchmarks/benchmarks/bench_core.py b/benchmarks/benchmarks/bench_core.py index 30647f4b850f..4fcd7ace509a 100644 --- a/benchmarks/benchmarks/bench_core.py +++ b/benchmarks/benchmarks/bench_core.py @@ -207,7 +207,7 @@ def time_indices(self): np.indices((1000, 500)) class VarComplex(Benchmark): - params = [10**n for n in range(1, 9)] + params = [10**n for n in range(0, 9)] def setup(self, n): self.arr = np.random.randn(n) + 1j * np.random.randn(n) diff --git a/benchmarks/benchmarks/bench_function_base.py b/benchmarks/benchmarks/bench_function_base.py index 062843d10cc0..2e44ff76b6b2 100644 --- a/benchmarks/benchmarks/bench_function_base.py +++ b/benchmarks/benchmarks/bench_function_base.py @@ -2,6 +2,15 @@ import numpy as np +class Linspace(Benchmark): + def setup(self): + self.d = np.array([1, 2, 3]) + + def time_linspace_scalar(self): + np.linspace(0, 10, 2) + + def time_linspace_array(self): + np.linspace(self.d, 10, 10) class Histogram1D(Benchmark): def setup(self): @@ -43,6 +52,20 @@ def time_weights(self): np.bincount(self.d, weights=self.e) +class Mean(Benchmark): + param_names = ['size'] + params = [[1, 10, 100_000]] + + def setup(self, size): + self.array = np.arange(2*size).reshape(2, size) + + def time_mean(self, size): + np.mean(self.array) + + def time_mean_axis(self, size): + np.mean(self.array, axis=1) + + class Median(Benchmark): def setup(self): self.e = np.arange(10000, dtype=np.float32) @@ -78,7 +101,7 @@ def time_wide(self): class Percentile(Benchmark): def setup(self): self.e = np.arange(10000, dtype=np.float32) - self.o = np.arange(10001, dtype=np.float32) + self.o = np.arange(21, dtype=np.float32) def time_quartile(self): np.percentile(self.e, [25, 75]) @@ -86,6 +109,9 @@ def time_quartile(self): def time_percentile(self): np.percentile(self.e, [25, 35, 55, 65, 75]) + def time_percentile_small(self): + np.percentile(self.o, [25, 75]) + class Select(Benchmark): def setup(self): @@ -222,7 +248,7 @@ class Sort(Benchmark): # In NumPy 1.17 and newer, 'merge' can be one of several # stable sorts, it isn't necessarily merge sort. ['quick', 'merge', 'heap'], - ['float64', 'int64', 'int16'], + ['float64', 'int64', 'float32', 'uint32', 'int32', 'int16'], [ ('random',), ('ordered',), @@ -284,6 +310,21 @@ def setup(self): self.d = np.arange(20000) self.e = self.d.copy() self.cond = (self.d > 5000) + size = 1024 * 1024 // 8 + rnd_array = np.random.rand(size) + self.rand_cond_01 = rnd_array > 0.01 + self.rand_cond_20 = rnd_array > 0.20 + self.rand_cond_30 = rnd_array > 0.30 + self.rand_cond_40 = rnd_array > 0.40 + self.rand_cond_50 = rnd_array > 0.50 + self.all_zeros = np.zeros(size, dtype=bool) + self.all_ones = np.ones(size, dtype=bool) + self.rep_zeros_2 = np.arange(size) % 2 == 0 + self.rep_zeros_4 = np.arange(size) % 4 == 0 + self.rep_zeros_8 = np.arange(size) % 8 == 0 + self.rep_ones_2 = np.arange(size) % 2 > 0 + self.rep_ones_4 = np.arange(size) % 4 > 0 + self.rep_ones_8 = np.arange(size) % 8 > 0 def time_1(self): np.where(self.cond) @@ -293,3 +334,43 @@ def time_2(self): def time_2_broadcast(self): np.where(self.cond, self.d, 0) + + def time_all_zeros(self): + np.where(self.all_zeros) + + def time_random_01_percent(self): + np.where(self.rand_cond_01) + + def time_random_20_percent(self): + np.where(self.rand_cond_20) + + def time_random_30_percent(self): + np.where(self.rand_cond_30) + + def time_random_40_percent(self): + np.where(self.rand_cond_40) + + def time_random_50_percent(self): + np.where(self.rand_cond_50) + + def time_all_ones(self): + np.where(self.all_ones) + + def time_interleaved_zeros_x2(self): + np.where(self.rep_zeros_2) + + def time_interleaved_zeros_x4(self): + np.where(self.rep_zeros_4) + + def time_interleaved_zeros_x8(self): + np.where(self.rep_zeros_8) + + def time_interleaved_ones_x2(self): + np.where(self.rep_ones_2) + + def time_interleaved_ones_x4(self): + np.where(self.rep_ones_4) + + def time_interleaved_ones_x8(self): + np.where(self.rep_ones_8) + diff --git a/benchmarks/benchmarks/bench_io.py b/benchmarks/benchmarks/bench_io.py index d5ce9a271cba..357adbb87fe8 100644 --- a/benchmarks/benchmarks/bench_io.py +++ b/benchmarks/benchmarks/bench_io.py @@ -75,12 +75,12 @@ class LoadtxtCSVComments(Benchmark): param_names = ['num_lines'] def setup(self, num_lines): - data = [u'1,2,3 # comment'] * num_lines + data = ['1,2,3 # comment'] * num_lines # unfortunately, timeit will only run setup() # between repeat events, but not for iterations # within repeats, so the StringIO object # will have to be rewinded in the benchmark proper - self.data_comments = StringIO(u'\n'.join(data)) + self.data_comments = StringIO('\n'.join(data)) def time_comment_loadtxt_csv(self, num_lines): # benchmark handling of lines with comments @@ -93,7 +93,7 @@ def time_comment_loadtxt_csv(self, num_lines): # confounding timing result somewhat) for every # call to timing test proper np.loadtxt(self.data_comments, - delimiter=u',') + delimiter=',') self.data_comments.seek(0) class LoadtxtCSVdtypes(Benchmark): @@ -106,8 +106,8 @@ class LoadtxtCSVdtypes(Benchmark): param_names = ['dtype', 'num_lines'] def setup(self, dtype, num_lines): - data = [u'5, 7, 888'] * num_lines - self.csv_data = StringIO(u'\n'.join(data)) + data = ['5, 7, 888'] * num_lines + self.csv_data = StringIO('\n'.join(data)) def time_loadtxt_dtypes_csv(self, dtype, num_lines): # benchmark loading arrays of various dtypes @@ -117,7 +117,7 @@ def time_loadtxt_dtypes_csv(self, dtype, num_lines): # rewind of StringIO object np.loadtxt(self.csv_data, - delimiter=u',', + delimiter=',', dtype=dtype) self.csv_data.seek(0) @@ -127,15 +127,15 @@ class LoadtxtCSVStructured(Benchmark): def setup(self): num_lines = 50000 - data = [u"M, 21, 72, X, 155"] * num_lines - self.csv_data = StringIO(u'\n'.join(data)) + data = ["M, 21, 72, X, 155"] * num_lines + self.csv_data = StringIO('\n'.join(data)) def time_loadtxt_csv_struct_dtype(self): # obligate rewind of StringIO object # between iterations of a repeat: np.loadtxt(self.csv_data, - delimiter=u',', + delimiter=',', dtype=[('category_1', 'S1'), ('category_2', 'i4'), ('category_3', 'f8'), @@ -174,10 +174,10 @@ class LoadtxtReadUint64Integers(Benchmark): def setup(self, size): arr = np.arange(size).astype('uint64') + 2**63 - self.data1 = StringIO(u'\n'.join(arr.astype(str).tolist())) + self.data1 = StringIO('\n'.join(arr.astype(str).tolist())) arr = arr.astype(object) arr[500] = -1 - self.data2 = StringIO(u'\n'.join(arr.astype(str).tolist())) + self.data2 = StringIO('\n'.join(arr.astype(str).tolist())) def time_read_uint64(self, size): # mandatory rewind of StringIO object @@ -200,14 +200,14 @@ class LoadtxtUseColsCSV(Benchmark): def setup(self, usecols): num_lines = 5000 - data = [u'0, 1, 2, 3, 4, 5, 6, 7, 8, 9'] * num_lines - self.csv_data = StringIO(u'\n'.join(data)) + data = ['0, 1, 2, 3, 4, 5, 6, 7, 8, 9'] * num_lines + self.csv_data = StringIO('\n'.join(data)) def time_loadtxt_usecols_csv(self, usecols): # must rewind StringIO because of state # dependence of file reading np.loadtxt(self.csv_data, - delimiter=u',', + delimiter=',', usecols=usecols) self.csv_data.seek(0) @@ -225,7 +225,7 @@ def setup(self, num_lines): dates = np.arange('today', 20, dtype=np.datetime64) np.random.seed(123) values = np.random.rand(20) - date_line = u'' + date_line = '' for date, value in zip(dates, values): date_line += (str(date) + ',' + str(value) + '\n') @@ -238,7 +238,7 @@ def time_loadtxt_csv_datetime(self, num_lines): # rewind StringIO object -- the timing iterations # are state-dependent X = np.loadtxt(self.csv_data, - delimiter=u',', + delimiter=',', dtype=([('dates', 'M8[us]'), ('values', 'float64')])) self.csv_data.seek(0) diff --git a/benchmarks/benchmarks/bench_itemselection.py b/benchmarks/benchmarks/bench_itemselection.py index 27fc49e305b8..518258a8f564 100644 --- a/benchmarks/benchmarks/bench_itemselection.py +++ b/benchmarks/benchmarks/bench_itemselection.py @@ -1,5 +1,3 @@ -from __future__ import absolute_import, division, print_function - from .common import Benchmark, TYPES1 import numpy as np diff --git a/benchmarks/benchmarks/bench_lib.py b/benchmarks/benchmarks/bench_lib.py index f7884cd6c309..b64f8ab173cb 100644 --- a/benchmarks/benchmarks/bench_lib.py +++ b/benchmarks/benchmarks/bench_lib.py @@ -137,3 +137,22 @@ def setup(self, array_size, percent_nans): def time_unique(self, array_size, percent_nans): np.unique(self.arr) + + +class Isin(Benchmark): + """Benchmarks for `numpy.isin`.""" + + param_names = ["size", "highest_element"] + params = [ + [10, 100000, 3000000], + [10, 10000, int(1e8)] + ] + + def setup(self, size, highest_element): + self.array = np.random.randint( + low=0, high=highest_element, size=size) + self.in_array = np.random.randint( + low=0, high=highest_element, size=size) + + def time_isin(self, size, highest_element): + np.isin(self.array, self.in_array) diff --git a/benchmarks/benchmarks/bench_linalg.py b/benchmarks/benchmarks/bench_linalg.py index 5ed5b6eecd6d..a94ba1139168 100644 --- a/benchmarks/benchmarks/bench_linalg.py +++ b/benchmarks/benchmarks/bench_linalg.py @@ -98,6 +98,18 @@ def time_op(self, op, typename): self.func(self.a) +class LinalgSmallArrays(Benchmark): + """ Test overhead of linalg methods for small arrays """ + def setup(self): + self.array_5 = np.arange(5.) + self.array_5_5 = np.arange(5.) + + def time_norm_small_array(self): + np.linalg.norm(self.array_5) + + def time_det_small_array(self): + np.linalg.det(self.array_5_5) + class Lstsq(Benchmark): def setup(self): self.a = get_squares_()['float64'] @@ -117,11 +129,11 @@ def setup(self, dtype): self.two_dim = np.arange(240000, dtype=dtype).reshape(400, 600) self.three_dim_small = np.arange(10000, dtype=dtype).reshape(10,100,10) self.three_dim = np.arange(24000, dtype=dtype).reshape(20, 30, 40) - # non_contigous arrays - self.non_contigous_dim1_small = np.arange(1, 80, 2, dtype=dtype) - self.non_contigous_dim1 = np.arange(1, 4000, 2, dtype=dtype) - self.non_contigous_dim2 = np.arange(1, 2400, 2, dtype=dtype).reshape(30, 40) - self.non_contigous_dim3 = np.arange(1, 48000, 2, dtype=dtype).reshape(20, 30, 40) + # non_contiguous arrays + self.non_contiguous_dim1_small = np.arange(1, 80, 2, dtype=dtype) + self.non_contiguous_dim1 = np.arange(1, 4000, 2, dtype=dtype) + self.non_contiguous_dim2 = np.arange(1, 2400, 2, dtype=dtype).reshape(30, 40) + self.non_contiguous_dim3 = np.arange(1, 48000, 2, dtype=dtype).reshape(20, 30, 40) # outer(a,b): trigger sum_of_products_contig_stride0_outcontig_two def time_einsum_outer(self, dtype): @@ -130,7 +142,7 @@ def time_einsum_outer(self, dtype): # multiply(a, b):trigger sum_of_products_contig_two def time_einsum_multiply(self, dtype): np.einsum("..., ...", self.two_dim_small, self.three_dim , optimize=True) - + # sum and multiply:trigger sum_of_products_contig_stride0_outstride0_two def time_einsum_sum_mul(self, dtype): np.einsum(",i...->", 300, self.three_dim_small, optimize=True) @@ -138,11 +150,11 @@ def time_einsum_sum_mul(self, dtype): # sum and multiply:trigger sum_of_products_stride0_contig_outstride0_two def time_einsum_sum_mul2(self, dtype): np.einsum("i...,->", self.three_dim_small, 300, optimize=True) - + # scalar mul: trigger sum_of_products_stride0_contig_outcontig_two def time_einsum_mul(self, dtype): np.einsum("i,->i", self.one_dim_big, 300, optimize=True) - + # trigger contig_contig_outstride0_two def time_einsum_contig_contig(self, dtype): np.einsum("ji,i->", self.two_dim, self.one_dim_small, optimize=True) @@ -151,30 +163,30 @@ def time_einsum_contig_contig(self, dtype): def time_einsum_contig_outstride0(self, dtype): np.einsum("i->", self.one_dim_big, optimize=True) - # outer(a,b): non_contigous arrays + # outer(a,b): non_contiguous arrays def time_einsum_noncon_outer(self, dtype): - np.einsum("i,j", self.non_contigous_dim1, self.non_contigous_dim1, optimize=True) + np.einsum("i,j", self.non_contiguous_dim1, self.non_contiguous_dim1, optimize=True) - # multiply(a, b):non_contigous arrays + # multiply(a, b):non_contiguous arrays def time_einsum_noncon_multiply(self, dtype): - np.einsum("..., ...", self.non_contigous_dim2, self.non_contigous_dim3 , optimize=True) - - # sum and multiply:non_contigous arrays + np.einsum("..., ...", self.non_contiguous_dim2, self.non_contiguous_dim3, optimize=True) + + # sum and multiply:non_contiguous arrays def time_einsum_noncon_sum_mul(self, dtype): - np.einsum(",i...->", 300, self.non_contigous_dim3, optimize=True) + np.einsum(",i...->", 300, self.non_contiguous_dim3, optimize=True) - # sum and multiply:non_contigous arrays + # sum and multiply:non_contiguous arrays def time_einsum_noncon_sum_mul2(self, dtype): - np.einsum("i...,->", self.non_contigous_dim3, 300, optimize=True) - - # scalar mul: non_contigous arrays + np.einsum("i...,->", self.non_contiguous_dim3, 300, optimize=True) + + # scalar mul: non_contiguous arrays def time_einsum_noncon_mul(self, dtype): - np.einsum("i,->i", self.non_contigous_dim1, 300, optimize=True) - - # contig_contig_outstride0_two: non_contigous arrays + np.einsum("i,->i", self.non_contiguous_dim1, 300, optimize=True) + + # contig_contig_outstride0_two: non_contiguous arrays def time_einsum_noncon_contig_contig(self, dtype): - np.einsum("ji,i->", self.non_contigous_dim2, self.non_contigous_dim1_small, optimize=True) + np.einsum("ji,i->", self.non_contiguous_dim2, self.non_contiguous_dim1_small, optimize=True) - # sum_of_products_contig_outstride0_one：non_contigous arrays + # sum_of_products_contig_outstride0_one：non_contiguous arrays def time_einsum_noncon_contig_outstride0(self, dtype): - np.einsum("i->", self.non_contigous_dim1, optimize=True) + np.einsum("i->", self.non_contiguous_dim1, optimize=True) diff --git a/benchmarks/benchmarks/bench_reduce.py b/benchmarks/benchmarks/bench_reduce.py index 7b05f4fcce31..ca07bd180c0e 100644 --- a/benchmarks/benchmarks/bench_reduce.py +++ b/benchmarks/benchmarks/bench_reduce.py @@ -46,7 +46,8 @@ def time_any_slow(self): class MinMax(Benchmark): - params = [np.float32, np.float64, np.intp] + params = [np.int8, np.uint8, np.int16, np.uint16, np.int32, np.uint32, + np.int64, np.uint64, np.float32, np.float64, np.intp] param_names = ['dtype'] def setup(self, dtype): @@ -58,8 +59,22 @@ def time_min(self, dtype): def time_max(self, dtype): np.max(self.d) +class FMinMax(Benchmark): + params = [np.float32, np.float64] + param_names = ['dtype'] + + def setup(self, dtype): + self.d = np.ones(20000, dtype=dtype) + + def time_min(self, dtype): + np.fmin.reduce(self.d) + + def time_max(self, dtype): + np.fmax.reduce(self.d) + class ArgMax(Benchmark): - params = [np.float32, bool] + params = [np.int8, np.uint8, np.int16, np.uint16, np.int32, np.uint32, + np.int64, np.uint64, np.float32, np.float64, bool] param_names = ['dtype'] def setup(self, dtype): @@ -68,6 +83,17 @@ def setup(self, dtype): def time_argmax(self, dtype): np.argmax(self.d) +class ArgMin(Benchmark): + params = [np.int8, np.uint8, np.int16, np.uint16, np.int32, np.uint32, + np.int64, np.uint64, np.float32, np.float64, bool] + param_names = ['dtype'] + + def setup(self, dtype): + self.d = np.ones(200000, dtype=dtype) + + def time_argmin(self, dtype): + np.argmin(self.d) + class SmallReduction(Benchmark): def setup(self): self.d = np.ones(100, dtype=np.float32) diff --git a/benchmarks/benchmarks/bench_scalar.py b/benchmarks/benchmarks/bench_scalar.py index 219e48bede94..650daa89de42 100644 --- a/benchmarks/benchmarks/bench_scalar.py +++ b/benchmarks/benchmarks/bench_scalar.py @@ -10,6 +10,8 @@ class ScalarMath(Benchmark): param_names = ["type"] def setup(self, typename): self.num = np.dtype(typename).type(2) + self.int32 = np.int32(2) + self.int32arr = np.array(2, dtype=np.int32) def time_addition(self, typename): n = self.num @@ -31,3 +33,35 @@ def time_abs(self, typename): n = self.num res = abs(abs(abs(abs(abs(abs(abs(abs(abs(abs(n)))))))))) + def time_add_int32_other(self, typename): + # Some mixed cases are fast, some are slow, this documents these + # differences. (When writing, it was fast if the type of the result + # is one of the inputs.) + int32 = self.int32 + other = self.num + int32 + other + int32 + other + int32 + other + int32 + other + int32 + other + + def time_add_int32arr_and_other(self, typename): + # `arr + scalar` hits the normal ufunc (array) paths. + int32 = self.int32arr + other = self.num + int32 + other + int32 + other + int32 + other + int32 + other + int32 + other + + def time_add_other_and_int32arr(self, typename): + # `scalar + arr` at some point hit scalar paths in some cases, and + # these paths could be optimized more easily + int32 = self.int32arr + other = self.num + other + int32 + other + int32 + other + int32 + other + int32 + other + int32 diff --git a/benchmarks/benchmarks/bench_shape_base.py b/benchmarks/benchmarks/bench_shape_base.py index 0c7dc4e728ec..375c43dcfe56 100644 --- a/benchmarks/benchmarks/bench_shape_base.py +++ b/benchmarks/benchmarks/bench_shape_base.py @@ -134,3 +134,21 @@ def time_3d(self, n, mode): # Retain old benchmark name for backward compat time_3d.benchmark_name = "bench_shape_base.Block.time_3d" + + +class Kron(Benchmark): + """Benchmarks for Kronecker product of two arrays""" + + def setup(self): + self.large_arr = np.random.random((10,) * 4) + self.large_mat = np.mat(np.random.random((100, 100))) + self.scalar = 7 + + def time_arr_kron(self): + np.kron(self.large_arr, self.large_arr) + + def time_scalar_kron(self): + np.kron(self.large_arr, self.scalar) + + def time_mat_kron(self): + np.kron(self.large_mat, self.large_mat) diff --git a/benchmarks/benchmarks/bench_strings.py b/benchmarks/benchmarks/bench_strings.py new file mode 100644 index 000000000000..88d20069e75b --- /dev/null +++ b/benchmarks/benchmarks/bench_strings.py @@ -0,0 +1,43 @@ +from .common import Benchmark + +import numpy as np +import operator + + +_OPERATORS = { + '==': operator.eq, + '!=': operator.ne, + '<': operator.lt, + '<=': operator.le, + '>': operator.gt, + '>=': operator.ge, +} + + +class StringComparisons(Benchmark): + # Basic string comparison speed tests + params = [ + [100, 10000, (1000, 20)], + ['U', 'S'], + [True, False], + ['==', '!=', '<', '<=', '>', '>=']] + param_names = ['shape', 'dtype', 'contig', 'operator'] + int64 = np.dtype(np.int64) + + def setup(self, shape, dtype, contig, operator): + self.arr = np.arange(np.prod(shape)).astype(dtype).reshape(shape) + self.arr_identical = self.arr.copy() + self.arr_different = self.arr[::-1].copy() + + if not contig: + self.arr = self.arr[..., ::2] + self.arr_identical = self.arr_identical[..., ::2] + self.arr_different = self.arr_different[..., ::2] + + self.operator = _OPERATORS[operator] + + def time_compare_identical(self, shape, dtype, contig, operator): + self.operator(self.arr, self.arr_identical) + + def time_compare_different(self, shape, dtype, contig, operator): + self.operator(self.arr, self.arr_different) diff --git a/benchmarks/benchmarks/bench_ufunc.py b/benchmarks/benchmarks/bench_ufunc.py index b036581e1aae..36d8621e81d9 100644 --- a/benchmarks/benchmarks/bench_ufunc.py +++ b/benchmarks/benchmarks/bench_ufunc.py @@ -57,10 +57,47 @@ def setup(self, ufuncname): def time_ufunc_types(self, ufuncname): [self.f(*arg) for arg in self.args] +class UFuncSmall(Benchmark): + """ Benchmark for a selection of ufuncs on a small arrays and scalars + + Since the arrays and scalars are small, we are benchmarking the overhead + of the numpy ufunc functionality + """ + params = ['abs', 'sqrt', 'cos'] + param_names = ['ufunc'] + timeout = 10 + + def setup(self, ufuncname): + np.seterr(all='ignore') + try: + self.f = getattr(np, ufuncname) + except AttributeError: + raise NotImplementedError() + self.array_5 = np.array([1., 2., 10., 3., 4.]) + self.array_int_3 = np.array([1, 2, 3]) + self.float64 = np.float64(1.1) + self.python_float = 1.1 + + def time_ufunc_small_array(self, ufuncname): + self.f(self.array_5) + + def time_ufunc_small_array_inplace(self, ufuncname): + self.f(self.array_5, out = self.array_5) + + def time_ufunc_small_int_array(self, ufuncname): + self.f(self.array_int_3) + + def time_ufunc_numpy_scalar(self, ufuncname): + self.f(self.float64) + + def time_ufunc_python_float(self, ufuncname): + self.f(self.python_float) + class Custom(Benchmark): def setup(self): self.b = np.ones(20000, dtype=bool) + self.b_small = np.ones(3, dtype=bool) def time_nonzero(self): np.nonzero(self.b) @@ -74,6 +111,9 @@ def time_and_bool(self): def time_or_bool(self): (self.b | self.b) + def time_and_bool_small(self): + (self.b_small & self.b_small) + class CustomInplace(Benchmark): def setup(self): @@ -130,8 +170,25 @@ def time_divide_scalar2(self, dtype): def time_divide_scalar2_inplace(self, dtype): np.divide(self.d, 1, out=self.d) + +class CustomComparison(Benchmark): + params = (np.int8, np.int16, np.int32, np.int64, np.uint8, np.uint16, + np.uint32, np.uint64, np.float32, np.float64, np.bool_) + param_names = ['dtype'] + + def setup(self, dtype): + self.x = np.ones(50000, dtype=dtype) + self.y = np.ones(50000, dtype=dtype) + self.s = np.ones(1, dtype=dtype) + + def time_less_than_binary(self, dtype): + (self.x < self.y) + + def time_less_than_scalar1(self, dtype): + (self.s < self.x) + def time_less_than_scalar2(self, dtype): - (self.d < 1) + (self.x < self.s) class CustomScalarFloorDivideInt(Benchmark): @@ -150,6 +207,19 @@ def setup(self, dtype, divisor): def time_floor_divide_int(self, dtype, divisor): self.x // divisor +class CustomArrayFloorDivideInt(Benchmark): + params = (np.sctypes['int'] + np.sctypes['uint'], [100, 10000, 1000000]) + param_names = ['dtype', 'size'] + + def setup(self, dtype, size): + iinfo = np.iinfo(dtype) + self.x = np.random.randint( + iinfo.min, iinfo.max, size=size, dtype=dtype) + self.y = np.random.randint(2, 32, size=size, dtype=dtype) + + def time_floor_divide_int(self, dtype, size): + self.x // self.y + class Scalar(Benchmark): def setup(self): @@ -224,3 +294,23 @@ class ArgParsingReduce(Benchmark): def time_add_reduce_arg_parsing(self, arg_pack): np.add.reduce(*arg_pack.args, **arg_pack.kwargs) + +class BinaryBench(Benchmark): + def setup(self): + N = 1000000 + self.a32 = np.random.rand(N).astype(np.float32) + self.b32 = np.random.rand(N).astype(np.float32) + self.a64 = np.random.rand(N).astype(np.float64) + self.b64 = np.random.rand(N).astype(np.float64) + + def time_pow_32(self): + np.power(self.a32, self.b32) + + def time_pow_64(self): + np.power(self.a64, self.b64) + + def time_atan2_32(self): + np.arctan2(self.a32, self.b32) + + def time_atan2_64(self): + np.arctan2(self.a64, self.b64) diff --git a/benchmarks/benchmarks/bench_ufunc_strides.py b/benchmarks/benchmarks/bench_ufunc_strides.py index 75aa510a6b81..f80bf90f9fbe 100644 --- a/benchmarks/benchmarks/bench_ufunc_strides.py +++ b/benchmarks/benchmarks/bench_ufunc_strides.py @@ -9,7 +9,7 @@ stride = [1, 2, 4] stride_out = [1, 2, 4] -dtype = ['f', 'd'] +dtype = ['e', 'f', 'd'] class Unary(Benchmark): params = [UNARY_OBJECT_UFUNCS, stride, stride_out, dtype] @@ -44,27 +44,40 @@ def setup(self, stride, dtype): def time_log(self, stride, dtype): np.log(self.arr[::stride]) -avx_bfuncs = ['maximum', - 'minimum'] -class AVX_BFunc(Benchmark): +binary_ufuncs = [ + 'maximum', 'minimum', 'fmax', 'fmin' +] +binary_dtype = ['f', 'd'] - params = [avx_bfuncs, dtype, stride] - param_names = ['avx_based_bfunc', 'dtype', 'stride'] +class Binary(Benchmark): + param_names = ['ufunc', 'stride_in0', 'stride_in1', 'stride_out', 'dtype'] + params = [binary_ufuncs, stride, stride, stride_out, binary_dtype] timeout = 10 - def setup(self, ufuncname, dtype, stride): + def setup(self, ufuncname, stride_in0, stride_in1, stride_out, dtype): np.seterr(all='ignore') try: self.f = getattr(np, ufuncname) except AttributeError: raise NotImplementedError(f"No ufunc {ufuncname} found") from None - N = 10000 - self.arr1 = np.array(np.random.rand(stride*N), dtype=dtype) - self.arr2 = np.array(np.random.rand(stride*N), dtype=dtype) + N = 100000 + self.arr1 = np.array(np.random.rand(stride_in0*N), dtype=dtype) + self.arr2 = np.array(np.random.rand(stride_in1*N), dtype=dtype) + self.arr_out = np.empty(stride_out*N, dtype) - def time_ufunc(self, ufuncname, dtype, stride): - self.f(self.arr1[::stride], self.arr2[::stride]) + def time_ufunc(self, ufuncname, stride_in0, stride_in1, stride_out, dtype): + self.f(self.arr1[::stride_in0], self.arr2[::stride_in1], + self.arr_out[::stride_out]) + + +binary_int_ufuncs = ['maximum', 'minimum'] +binary_int_dtype = ['b', 'B', 'h', 'H', 'i', 'I', 'l', 'L', 'q', 'Q'] + +class BinaryInt(Binary): + + param_names = ['ufunc', 'stride_in0', 'stride_in1', 'stride_out', 'dtype'] + params = [binary_int_ufuncs, stride, stride, stride_out, binary_int_dtype] class AVX_ldexp(Benchmark): diff --git a/doc/BRANCH_WALKTHROUGH.rst b/doc/BRANCH_WALKTHROUGH.rst index 95de5464b376..2d26eebc242a 100644 --- a/doc/BRANCH_WALKTHROUGH.rst +++ b/doc/BRANCH_WALKTHROUGH.rst @@ -1,9 +1,10 @@ -This file contains a walkthrough of branching NumPy 1.21.x on Linux. The +This guide contains a walkthrough of branching NumPy 1.21.x on Linux. The commands can be copied into the command line, but be sure to replace 1.21 and 1.22 by the correct versions. It is good practice to make ``.mailmap`` as current as possible before making the branch, that may take several weeks. -This should be read together with the general directions in `releasing`. +This should be read together with the +:ref:`general release guide `. Branching ========= diff --git a/doc/C_STYLE_GUIDE.rst.txt b/doc/C_STYLE_GUIDE.rst similarity index 56% rename from doc/C_STYLE_GUIDE.rst.txt rename to doc/C_STYLE_GUIDE.rst index 4e2f27fbb1b1..60d2d7383510 100644 --- a/doc/C_STYLE_GUIDE.rst.txt +++ b/doc/C_STYLE_GUIDE.rst @@ -1,3 +1,3 @@ -The "NumPy C Style Guide" at this page has been supserseded by +The "NumPy C Style Guide" at this page has been superseded by "NEP 45 — C Style Guide" at https://numpy.org/neps/nep-0045-c_style_guide.html diff --git a/doc/DISTUTILS.rst.txt b/doc/DISTUTILS.rst similarity index 100% rename from doc/DISTUTILS.rst.txt rename to doc/DISTUTILS.rst diff --git a/doc/EXAMPLE_DOCSTRING.rst.txt b/doc/EXAMPLE_DOCSTRING.rst similarity index 76% rename from doc/EXAMPLE_DOCSTRING.rst.txt rename to doc/EXAMPLE_DOCSTRING.rst index 55294f6568c4..d7ddf5260abf 100644 --- a/doc/EXAMPLE_DOCSTRING.rst.txt +++ b/doc/EXAMPLE_DOCSTRING.rst @@ -9,7 +9,7 @@ multivariate_normal(mean, cov[, shape]) Draw samples from a multivariate normal distribution. The multivariate normal, multinormal or Gaussian distribution is a -generalisation of the one-dimensional normal distribution to higher +generalization of the one-dimensional normal distribution to higher dimensions. Such a distribution is specified by its mean and covariance matrix, @@ -21,22 +21,22 @@ Parameters ---------- mean : (N,) ndarray Mean of the N-dimensional distribution. -cov : (N,N) ndarray +cov : (N, N) ndarray Covariance matrix of the distribution. shape : tuple of ints, optional - Given a shape of, for example, (m,n,k), m*n*k samples are + Given a shape of, for example, (m, n, k), m*n*k samples are generated, and packed in an m-by-n-by-k arrangement. Because each - sample is N-dimensional, the output shape is (m,n,k,N). If no + sample is N-dimensional, the output shape is (m, n, k, N). If no shape is specified, a single sample is returned. Returns ------- out : ndarray The drawn samples, arranged according to `shape`. If the - shape given is (m,n,...), then the shape of `out` is - (m,n,...,N). + shape given is (m, n, ...), then the shape of `out` is + (m, n, ... , N). - In other words, each entry ``out[i,j,...,:]`` is an N-dimensional + In other words, each entry ``out[i, j, ... , :]`` is an N-dimensional value drawn from the distribution. See Also @@ -54,7 +54,7 @@ univariate normal distribution. Covariance indicates the level to which two variables vary together. From the multivariate normal distribution, we draw N-dimensional -samples, :math:`X = [x_1, x_2, ... x_N]`. The covariance matrix +samples, :math:`X = [x_1, x_2, ... , x_N]`. The covariance matrix element :math:`C_ij` is the covariance of :math:`x_i` and :math:`x_j`. The element :math:`C_ii` is the variance of :math:`x_i` (i.e. its "spread"). @@ -69,12 +69,12 @@ approximations include: This geometrical property can be seen in two dimensions by plotting generated data-points: ->>> mean = [0,0] ->>> cov = [[1,0],[0,100]] # diagonal covariance, points lie on x or y-axis ->>> x,y = np.random.multivariate_normal(mean,cov,5000).T +>>> mean = [0, 0] +>>> cov = [[1, 0], [0, 100]] # diagonal covariance, points lie on x or y-axis +>>> x, y = np.random.multivariate_normal(mean, cov, 5000).T >>> import matplotlib.pyplot as plt ->>> plt.plot(x,y,'x'); plt.axis('equal'); pyplot.show() +>>> plt.plot(x, y, 'x'); plt.axis('equal'); plt.show() Note that the covariance matrix must be non-negative definite. @@ -87,17 +87,17 @@ References Examples -------- ->>> mean = (1,2) ->>> cov = [[1,0],[1,0]] ->>> x = np.random.multivariate_normal(mean,cov,(3,3)) +>>> mean = (1, 2) +>>> cov = [[1, 0], [0, 1]] +>>> x = np.random.multivariate_normal(mean, cov, (3, 3)) >>> x.shape (3, 3, 2) The following is probably true, given that 0.6 is roughly twice the standard deviation: ->>> print list( (x[0,0,:] - mean) < 0.6 ) -[True, True] +>>> print(list( (x[0, 0, :] - mean) < 0.6 )) +[True, True] # may vary .. index: :refguide: random:distributions diff --git a/doc/HOWTO_DOCUMENT.rst.txt b/doc/HOWTO_DOCUMENT.rst similarity index 100% rename from doc/HOWTO_DOCUMENT.rst.txt rename to doc/HOWTO_DOCUMENT.rst diff --git a/doc/HOWTO_RELEASE.rst b/doc/HOWTO_RELEASE.rst new file mode 100644 index 000000000000..032d51780e9d --- /dev/null +++ b/doc/HOWTO_RELEASE.rst @@ -0,0 +1,248 @@ +These instructions give an overview of what is necessary to build binary +releases for NumPy. + +Current build and release info +============================== + +Useful info can be found in the following locations: + +* **Source tree** + + - `INSTALL.rst `_ + - `pavement.py `_ + +* **NumPy docs** + + - https://github.com/numpy/numpy/blob/main/doc/HOWTO_RELEASE.rst + - https://github.com/numpy/numpy/blob/main/doc/RELEASE_WALKTHROUGH.rst + - https://github.com/numpy/numpy/blob/main/doc/BRANCH_WALKTHROUGH.rst + +* **Release scripts** + + - https://github.com/numpy/numpy-vendor + + +Supported platforms and versions +================================ +:ref:`NEP 29 ` outlines which Python versions +are supported; For the first half of 2020, this will be Python >= 3.6. We test +NumPy against all these versions every time we merge code to main. Binary +installers may be available for a subset of these versions (see below). + +* **OS X** + + OS X versions >= 10.9 are supported, for Python version support see + :ref:`NEP 29 `. We build binary wheels for OSX that are compatible with + Python.org Python, system Python, homebrew and macports - see this + `OSX wheel building summary `_ + for details. + +* **Windows** + + We build 32- and 64-bit wheels on Windows. Windows 7, 8 and 10 are supported. + We build NumPy using the `mingw-w64 toolchain`_, `cibuildwheels`_ and GitHub + actions. + +.. _cibuildwheels: https://cibuildwheel.readthedocs.io/en/stable/ + +* **Linux** + + We build and ship `manylinux2014 `_ + wheels for NumPy. Many Linux distributions include their own binary builds + of NumPy. + +* **BSD / Solaris** + + No binaries are provided, but successful builds on Solaris and BSD have been + reported. + +Tool chain +========== +We build all our wheels on cloud infrastructure - so this list of compilers is +for information and debugging builds locally. See the ``.travis.yml`` script +in the `numpy wheels`_ repo for an outdated source of the build recipes using +multibuild. + +.. _numpy wheels : https://github.com/MacPython/numpy-wheels + +Compilers +--------- +The same gcc version is used as the one with which Python itself is built on +each platform. At the moment this means: + +- OS X builds on travis currently use `clang`. It appears that binary wheels + for OSX >= 10.6 can be safely built from the travis-ci OSX 10.9 VMs + when building against the Python from the Python.org installers; +- Windows builds use the `mingw-w64 toolchain`_; +- Manylinux2014 wheels use the gcc provided on the Manylinux docker images. + +You will need Cython for building the binaries. Cython compiles the ``.pyx`` +files in the NumPy distribution to ``.c`` files. + +.. _mingw-w64 toolchain : https://mingwpy.github.io + +OpenBLAS +-------- + +All the wheels link to a version of OpenBLAS_ supplied via the openblas-libs_ repo. +The shared object (or DLL) is shipped with in the wheel, renamed to prevent name +collisions with other OpenBLAS shared objects that may exist in the filesystem. + +.. _OpenBLAS: https://github.com/xianyi/OpenBLAS +.. _openblas-libs: https://github.com/MacPython/openblas-libs + + +Building source archives and wheels +----------------------------------- +The NumPy wheels and sdist are now built using cibuildwheel with +github actions. + + +Building docs +------------- +We are no longer building ``PDF`` files. All that will be needed is + +- virtualenv (pip). + +The other requirements will be filled automatically during the documentation +build process. + + +Uploading to PyPI +----------------- +The only application needed for uploading is + +- twine (pip). + +You will also need a PyPI token, which is best kept on a keyring. See the +twine keyring_ documentation for how to do that. + +.. _keyring: https://twine.readthedocs.io/en/stable/#keyring-support + + +Generating author/PR lists +-------------------------- +You will need a personal access token +``_ +so that scripts can access the github NumPy repository. + +- gitpython (pip) +- pygithub (pip) + + +What is released +================ + +* **Wheels** + We currently support Python 3.8-3.10 on Windows, OSX, and Linux. + + * Windows: 32-bit and 64-bit wheels built using Github actions; + * OSX: x64_86 and arm64 OSX wheels built using Github actions; + * Linux: x64_86 and aarch64 Manylinux2014 wheels built using Github actions. + +* **Other** + Release notes and changelog + +* **Source distribution** + We build source releases in the .tar.gz format. + + +Release process +=============== + +Agree on a release schedule +--------------------------- +A typical release schedule is one beta, two release candidates and a final +release. It's best to discuss the timing on the mailing list first, in order +for people to get their commits in on time, get doc wiki edits merged, etc. +After a date is set, create a new maintenance/x.y.z branch, add new empty +release notes for the next version in the main branch and update the Trac +Milestones. + + +Make sure current branch builds a package correctly +--------------------------------------------------- +The CI builds wheels when a PR header begins with ``REL``. Your last +PR before releasing should be so marked and all the tests should pass. +You can also do:: + + git clean -fxdq + python setup.py bdist_wheel + python setup.py sdist + +For details of the build process itself, it is best to read the +Step-by-Step Directions below. + +.. note:: The following steps are repeated for the beta(s), release + candidates(s) and the final release. + + +Check deprecations +------------------ +Before :ref:`the release branch is made `, it should be checked that +all deprecated code that should be removed is actually removed, and all new +deprecations say in the docstring or deprecation warning what version the code +will be removed. + +Check the C API version number +------------------------------ +The C API version needs to be tracked in three places + +- numpy/core/setup_common.py +- numpy/core/code_generators/cversions.txt +- numpy/core/include/numpy/numpyconfig.h + +There are three steps to the process. + +1. If the API has changed, increment the C_API_VERSION in setup_common.py. The + API is unchanged only if any code compiled against the current API will be + backward compatible with the last released NumPy version. Any changes to + C structures or additions to the public interface will make the new API + not backward compatible. + +2. If the C_API_VERSION in the first step has changed, or if the hash of + the API has changed, the cversions.txt file needs to be updated. To check + the hash, run the script numpy/core/cversions.py and note the API hash that + is printed. If that hash does not match the last hash in + numpy/core/code_generators/cversions.txt the hash has changed. Using both + the appropriate C_API_VERSION and hash, add a new entry to cversions.txt. + If the API version was not changed, but the hash differs, you will need to + comment out the previous entry for that API version. For instance, in NumPy + 1.9 annotations were added, which changed the hash, but the API was the + same as in 1.8. The hash serves as a check for API changes, but it is not + definitive. + + If steps 1 and 2 are done correctly, compiling the release should not give + a warning "API mismatch detect at the beginning of the build". + +3. The numpy/core/include/numpy/numpyconfig.h will need a new + NPY_X_Y_API_VERSION macro, where X and Y are the major and minor version + numbers of the release. The value given to that macro only needs to be + increased from the previous version if some of the functions or macros in + the include files were deprecated. + +The C ABI version number in numpy/core/setup_common.py should only be +updated for a major release. + + +Check the release notes +----------------------- +Use `towncrier`_ to build the release note and +commit the changes. This will remove all the fragments from +``doc/release/upcoming_changes`` and add ``doc/release/-note.rst``. + + towncrier build --version "" + git commit -m"Create release note" + +Check that the release notes are up-to-date. + +Update the release notes with a Highlights section. Mention some of the +following: + +- major new features +- deprecated and removed features +- supported Python versions +- for SciPy, supported NumPy version(s) +- outlook for the near future + +.. _towncrier: https://pypi.org/project/towncrier/ diff --git a/doc/HOWTO_RELEASE.rst.txt b/doc/HOWTO_RELEASE.rst.txt deleted file mode 100644 index 37e047f9fbf0..000000000000 --- a/doc/HOWTO_RELEASE.rst.txt +++ /dev/null @@ -1,491 +0,0 @@ -This file gives an overview of what is necessary to build binary releases for -NumPy. - -Current build and release info -============================== -The current info on building and releasing NumPy and SciPy is scattered in -several places. It should be summarized in one place, updated, and where -necessary described in more detail. The sections below list all places where -useful info can be found. - - -Source tree ------------ -- INSTALL.rst.txt -- pavement.py - - -NumPy Docs ----------- -- https://github.com/numpy/numpy/blob/main/doc/HOWTO_RELEASE.rst.txt - - -SciPy.org wiki --------------- -- https://www.scipy.org/Installing_SciPy and links on that page. - - -Release Scripts ---------------- -- https://github.com/numpy/numpy-vendor - - -Supported platforms and versions -================================ -:ref:`NEP 29 ` outlines which Python versions -are supported; For the first half of 2020, this will be Python >= 3.6. We test -NumPy against all these versions every time we merge code to main. Binary -installers may be available for a subset of these versions (see below). - -OS X ----- -OS X versions >= 10.9 are supported, for Python version support see -:ref:`NEP 29 `. We build binary wheels for -OSX that are compatible with Python.org Python, system Python, homebrew and -macports - see this `OSX wheel building summary -`_ for details. - - -Windows -------- -We build 32- and 64-bit wheels on Windows. Windows 7, 8 and 10 are supported. -We build NumPy using the `mingw-w64 toolchain`_ on Appveyor. - - -Linux ------ -We build and ship `manylinux1 `_ -wheels for NumPy. Many Linux distributions include their own binary builds -of NumPy. - - -BSD / Solaris -------------- -No binaries are provided, but successful builds on Solaris and BSD have been -reported. - - -Tool chain -========== -We build all our wheels on cloud infrastructure - so this list of compilers is -for information and debugging builds locally. See the ``.travis.yml`` script -in the `numpy wheels`_ repo for the definitive source -of the build recipes. Packages that are available using pip are noted. - - -Compilers ---------- -The same gcc version is used as the one with which Python itself is built on -each platform. At the moment this means: - -- OS X builds on travis currently use `clang`. It appears that binary wheels - for OSX >= 10.6 can be safely built from the travis-ci OSX 10.9 VMs - when building against the Python from the Python.org installers; -- Windows builds use the `mingw-w64 toolchain`_; -- Manylinux1 wheels use the gcc provided on the Manylinux docker images. - -You will need Cython for building the binaries. Cython compiles the ``.pyx`` -files in the NumPy distribution to ``.c`` files. - -.. _mingw-w64 toolchain : https://mingwpy.github.io - -OpenBLAS ------------- -All the wheels link to a version of OpenBLAS_ supplied via the openblas-libs_ repo. -The shared object (or DLL) is shipped with in the wheel, renamed to prevent name -collisions with other OpenBLAS shared objects that may exist in the filesystem. - -.. _OpenBLAS: https://github.com/xianyi/OpenBLAS -.. _openblas-libs: https://github.com/MacPython/openblas-libs - - -Building source archives and wheels ------------------------------------ -You will need write permission for numpy-wheels in order to trigger wheel -builds. - -- Python(s) from `python.org `_ or linux distro. -- cython (pip) -- virtualenv (pip) -- Paver (pip) -- pandoc `pandoc.org `_ or linux distro. -- numpy-wheels ``_ (clone) - - -Building docs -------------- -Building the documents requires a number of latex ``.sty`` files. Install them -all to avoid aggravation. - -- Sphinx (pip) -- numpydoc (pip) -- Matplotlib -- Texlive (or MikTeX on Windows) - - -Uploading to PyPI ------------------ -- terryfy ``_ (clone). -- beautifulsoup4 (pip) -- delocate (pip) -- auditwheel (pip) -- twine (pip) - - -Generating author/pr lists --------------------------- -You will need a personal access token -``_ -so that scripts can access the github NumPy repository. - -- gitpython (pip) -- pygithub (pip) - - -Virtualenv ----------- -Virtualenv is a very useful tool to keep several versions of packages around. -It is also used in the Paver script to build the docs. - - -What is released -================ - -Wheels ------- -We currently support Python 3.6-3.8 on Windows, OSX, and Linux - -* Windows: 32-bit and 64-bit wheels built using Appveyor; -* OSX: x64_86 OSX wheels built using travis-ci; -* Linux: 32-bit and 64-bit Manylinux1 wheels built using travis-ci. - -See the `numpy wheels`_ building repository for more detail. - -.. _numpy wheels : https://github.com/MacPython/numpy-wheels - - -Other ------ -- Release Notes -- Changelog - - -Source distribution -------------------- -We build source releases in both .zip and .tar.gz formats. - - -Release process -=============== - -Agree on a release schedule ---------------------------- -A typical release schedule is one beta, two release candidates and a final -release. It's best to discuss the timing on the mailing list first, in order -for people to get their commits in on time, get doc wiki edits merged, etc. -After a date is set, create a new maintenance/x.y.z branch, add new empty -release notes for the next version in the main branch and update the Trac -Milestones. - - -Make sure current branch builds a package correctly ---------------------------------------------------- -:: - - git clean -fxd - python setup.py bdist_wheel - python setup.py sdist - -For details of the build process itself, it is -best to read the pavement.py script. - -.. note:: The following steps are repeated for the beta(s), release - candidates(s) and the final release. - - -Check deprecations ------------------- -Before the release branch is made, it should be checked that all deprecated -code that should be removed is actually removed, and all new deprecations say -in the docstring or deprecation warning at what version the code will be -removed. - -Check the C API version number ------------------------------- -The C API version needs to be tracked in three places - -- numpy/core/setup_common.py -- numpy/core/code_generators/cversions.txt -- numpy/core/include/numpy/numpyconfig.h - -There are three steps to the process. - -1. If the API has changed, increment the C_API_VERSION in setup_common.py. The - API is unchanged only if any code compiled against the current API will be - backward compatible with the last released NumPy version. Any changes to - C structures or additions to the public interface will make the new API - not backward compatible. - -2. If the C_API_VERSION in the first step has changed, or if the hash of - the API has changed, the cversions.txt file needs to be updated. To check - the hash, run the script numpy/core/cversions.py and note the API hash that - is printed. If that hash does not match the last hash in - numpy/core/code_generators/cversions.txt the hash has changed. Using both - the appropriate C_API_VERSION and hash, add a new entry to cversions.txt. - If the API version was not changed, but the hash differs, you will need to - comment out the previous entry for that API version. For instance, in NumPy - 1.9 annotations were added, which changed the hash, but the API was the - same as in 1.8. The hash serves as a check for API changes, but it is not - definitive. - - If steps 1 and 2 are done correctly, compiling the release should not give - a warning "API mismatch detect at the beginning of the build". - -3. The numpy/core/include/numpy/numpyconfig.h will need a new - NPY_X_Y_API_VERSION macro, where X and Y are the major and minor version - numbers of the release. The value given to that macro only needs to be - increased from the previous version if some of the functions or macros in - the include files were deprecated. - -The C ABI version number in numpy/core/setup_common.py should only be -updated for a major release. - - -Check the release notes ------------------------ -Use `towncrier`_ to build the release note and -commit the changes. This will remove all the fragments from -``doc/release/upcoming_changes`` and add ``doc/release/-note.rst``. - - towncrier build --version "" - git commit -m"Create release note" - -Check that the release notes are up-to-date. - -Update the release notes with a Highlights section. Mention some of the -following: - - - major new features - - deprecated and removed features - - supported Python versions - - for SciPy, supported NumPy version(s) - - outlook for the near future - -.. _towncrier: https://pypi.org/project/towncrier/ - - -Update the release status and create a release "tag" ----------------------------------------------------- -Identify the commit hash of the release, e.g. 1b2e1d63ff:: - - git co 1b2e1d63ff # gives warning about detached head - -First, change/check the following variables in ``pavement.py`` depending on the -release version:: - - RELEASE_NOTES = 'doc/release/1.7.0-notes.rst' - LOG_START = 'v1.6.0' - LOG_END = 'maintenance/1.7.x' - -Do any other changes. When you are ready to release, do the following -changes:: - - diff --git a/setup.py b/setup.py - index b1f53e3..8b36dbe 100755 - --- a/setup.py - +++ b/setup.py - @@ -57,7 +57,7 @@ PLATFORMS = ["Windows", "Linux", "Solaris", "Mac OS- - MAJOR = 1 - MINOR = 7 - MICRO = 0 - -ISRELEASED = False - +ISRELEASED = True - VERSION = '%d.%d.%drc1' % (MAJOR, MINOR, MICRO) - - # Return the git revision as a string - -And make sure the ``VERSION`` variable is set properly. - -Now you can make the release commit and tag. We recommend you don't push -the commit or tag immediately, just in case you need to do more cleanup. We -prefer to defer the push of the tag until we're confident this is the exact -form of the released code (see: :ref:`push-tag-and-commit`): - - git commit -s -m "REL: Release." setup.py - git tag -s - -The ``-s`` flag makes a PGP (usually GPG) signed tag. Please do sign the -release tags. - -The release tag should have the release number in the annotation (tag -message). Unfortunately, the name of a tag can be changed without breaking the -signature, the contents of the message cannot. - -See: https://github.com/scipy/scipy/issues/4919 for a discussion of signing -release tags, and https://keyring.debian.org/creating-key.html for instructions -on creating a GPG key if you do not have one. - -To make your key more readily identifiable as you, consider sending your key -to public keyservers, with a command such as:: - - gpg --send-keys - - -Update the version of the main branch -------------------------------------- -Increment the release number in setup.py. Release candidates should have "rc1" -(or "rc2", "rcN") appended to the X.Y.Z format. - -Also create a new version hash in cversions.txt and a corresponding version -define NPY_x_y_API_VERSION in numpyconfig.h - - -Trigger the wheel builds ------------------------- -See the `numpy wheels`_ repository. - -In that repository edit the files: - -- ``azure/posix.yml`` -- ``azure/windows.yml``. - -In both cases, set the ``BUILD_COMMIT`` variable to the current release tag - -e.g. ``v1.19.0``:: - - $ gvim azure/posix.yml azure/windows.yml - $ git commit -a - $ git push upstream HEAD - -Make sure that the release tag has been pushed. - -Trigger a build by pushing a commit of your edits to the repository. Note that -you can do this on a branch, but it must be pushed upstream to the -``MacPython/numpy-wheels`` repository to trigger uploads since only -that repo has the appropriate tokens to allow uploads. - -The wheels, once built, appear at https://anaconda.org/multibuild-wheels-staging/numpy - -Make the release ----------------- -Build the changelog and notes for upload with:: - - paver write_release - - -Build and archive documentation -------------------------------- -Do:: - - cd doc/ - make dist - -to check that the documentation is in a buildable state. Then, after tagging, -create an archive of the documentation in the numpy/doc repo:: - - # This checks out github.com/numpy/doc and adds (``git add``) the - # documentation to the checked out repo. - make merge-doc - # Now edit the ``index.html`` file in the repo to reflect the new content. - # If the documentation is for a non-patch release (e.g. 1.19 -> 1.20), - # make sure to update the ``stable`` symlink to point to the new directory. - ln -sfn stable - # Commit the changes - git -C build/merge commit -am "Add documentation for " - # Push to numpy/doc repo - git -C build/merge push - - -Update PyPI ------------ -The wheels and source should be uploaded to PyPI. - -You should upload the wheels first, and the source formats last, to make sure -that pip users don't accidentally get a source install when they were -expecting a binary wheel. - -You can do this automatically using the ``wheel-uploader`` script from -https://github.com/MacPython/terryfy. Here is the recommended incantation for -downloading all the Windows, Manylinux, OSX wheels and uploading to PyPI. :: - - NPY_WHLS=~/wheelhouse # local directory to cache wheel downloads - CDN_URL=https://anaconda.org/multibuild-wheels-staging/numpy/files - wheel-uploader -u $CDN_URL -w $NPY_WHLS -v -s -t win numpy 1.11.1rc1 - wheel-uploader -u $CDN_URL -w warehouse -v -s -t macosx numpy 1.11.1rc1 - wheel-uploader -u $CDN_URL -w warehouse -v -s -t manylinux1 numpy 1.11.1rc1 - -The ``-v`` flag gives verbose feedback, ``-s`` causes the script to sign the -wheels with your GPG key before upload. Don't forget to upload the wheels -before the source tarball, so there is no period for which people switch from -an expected binary install to a source install from PyPI. - -There are two ways to update the source release on PyPI, the first one is:: - - $ git clean -fxd # to be safe - $ python setup.py sdist --formats=gztar,zip # to check - # python setup.py sdist --formats=gztar,zip upload --sign - -This will ask for your key PGP passphrase, in order to sign the built source -packages. - -The second way is to upload the PKG_INFO file inside the sdist dir in the -web interface of PyPI. The source tarball can also be uploaded through this -interface. - -.. _push-tag-and-commit: - - -Push the release tag and commit -------------------------------- -Finally, now you are confident this tag correctly defines the source code that -you released you can push the tag and release commit up to github:: - - git push # Push release commit - git push upstream # Push tag named - -where ``upstream`` points to the main https://github.com/numpy/numpy.git -repository. - - -Update scipy.org ----------------- -A release announcement with a link to the download site should be placed in the -sidebar of the front page of scipy.org. - -The scipy.org should be a PR at https://github.com/scipy/scipy.org. The file -that needs modification is ``www/index.rst``. Search for ``News``. - - -Update oldest-supported-numpy ------------------------------ -If this release is the first one to support a new Python version, or the first -to provide wheels for a new platform or PyPy version, the version pinnings -in https://github.com/scipy/oldest-supported-numpy should be updated. -Either submit a PR with changes to ``setup.cfg`` there, or open an issue with -info on needed changes. - - -Announce to the lists ---------------------- -The release should be announced on the mailing lists of -NumPy and SciPy, to python-announce, and possibly also those of -Matplotlib, IPython and/or Pygame. - -During the beta/RC phase, an explicit request for testing the binaries with -several other libraries (SciPy/Matplotlib/Pygame) should be posted on the -mailing list. - - -Announce to Linux Weekly News ------------------------------ -Email the editor of LWN to let them know of the release. Directions at: -https://lwn.net/op/FAQ.lwn#contact - - -After the final release ------------------------ -After the final release is announced, a few administrative tasks are left to be -done: - - - Forward port changes in the release branch to release notes and release - scripts, if any, to main branch. - - Update the Milestones in Trac. diff --git a/doc/Makefile b/doc/Makefile index 16fc3229d4c9..6d3c93203b55 100644 --- a/doc/Makefile +++ b/doc/Makefile @@ -26,26 +26,25 @@ FILES= PAPEROPT_a4 = -D latex_paper_size=a4 PAPEROPT_letter = -D latex_paper_size=letter ALLSPHINXOPTS = -WT --keep-going -d build/doctrees $(PAPEROPT_$(PAPER)) \ - $(SPHINXOPTS) source + $(SPHINXOPTS) source -.PHONY: help clean html web pickle htmlhelp latex changes linkcheck \ - dist dist-build gitwash-update version-check html-build latex-build \ - merge-doc show +.PHONY: help clean html web htmlhelp latex changes linkcheck \ + dist dist-build gitwash-update version-check html-build latex-build \ + merge-doc show docenv #------------------------------------------------------------------------------ help: @echo "Please use \`make ' where is one of" + @echo " clean to remove generated doc files and start fresh" + @echo " docenv make a virtual environment in which to build docs" @echo " html to make standalone HTML files" - @echo " html-scipyorg to make standalone HTML files with scipy.org theming" - @echo " pickle to make pickle files (usable by e.g. sphinx-web)" @echo " htmlhelp to make HTML files and a HTML help project" @echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter" @echo " changes to make an overview over all changed/added/deprecated items" @echo " linkcheck to check all external links for integrity" @echo " dist PYVER=... to make a distribution-ready tree" @echo " gitwash-update GITWASH=path/to/gitwash update gitwash developer docs" - @echo " upload USERNAME=... RELEASE=... to upload built docs to docs.scipy.org" @echo " merge-doc TAG=... to clone numpy/doc and archive documentation into it" @echo " show to show the html output in a browser" @@ -53,6 +52,16 @@ clean: -rm -rf build/* find . -name generated -type d -prune -exec rm -rf "{}" ";" +docenv: + $(PYTHON) -mvenv docenv + ( \ + . docenv/bin/activate; \ + pip install -q --upgrade pip; \ + pip install -q -r ../test_requirements.txt; \ + pip install -q -r ../doc_requirements.txt; \ + pip install -q ..; \ + ) + gitwash-update: rm -rf source/dev/gitwash install -d source/dev/gitwash @@ -69,17 +78,9 @@ gitwash-update: # We have to be careful of some issues: # # - Everything must be done using the same Python version -# - We must use eggs (otherwise they might override PYTHONPATH on import). -# - Different versions of easy_install install to different directories (!) # - -INSTALL_DIR = $(CURDIR)/build/inst-dist -INSTALL_PPH = $(INSTALL_DIR)/lib/python$(PYVER)/site-packages:$(INSTALL_DIR)/local/lib/python$(PYVER)/site-packages:$(INSTALL_DIR)/lib/python$(PYVER)/dist-packages:$(INSTALL_DIR)/local/lib/python$(PYVER)/dist-packages -UPLOAD_DIR=/srv/docs_scipy_org/doc/numpy-$(RELEASE) - -DIST_VARS=SPHINXBUILD="LANG=C PYTHONPATH=$(INSTALL_PPH) python$(PYVER) `which sphinx-build`" PYTHON="PYTHONPATH=$(INSTALL_PPH) python$(PYVER)" - +#SPHINXBUILD="LANG=C sphinx-build" NUMPYVER:=$(shell $(PYTHON) -c "import numpy; print(numpy.version.git_revision[:10])" 2>/dev/null) GITVER ?= $(shell cd ..; $(PYTHON) -c "import versioneer as v; print(v.get_versions()['full-revisionid'][:10])") @@ -88,6 +89,7 @@ ifeq "$(GITVER)" "Unknown" # @echo sdist build with unlabeled sources else ifeq ("", "$(NUMPYVER)") @echo numpy not found, cannot build documentation without successful \"import numpy\" + @echo Try overriding the makefile PYTHON variable with '"make PYTHON=python $(MAKECMDGOALS)"' @exit 1 else ifneq ($(NUMPYVER),$(GITVER)) @echo installed numpy $(NUMPYVER) != current repo git version \'$(GITVER)\' @@ -101,45 +103,15 @@ endif dist: build/dist.tar.gz -build/dist.tar.gz: - make $(DIST_VARS) real-dist +build/dist.tar.gz: real-dist -real-dist: dist-build html-build - test -d build/latex || make latex-build - make -C build/latex all-pdf - -rm -rf build/dist +real-dist: html-build cp -r build/html build/dist cd build/html && zip -9r ../dist/numpy-html.zip . - cp build/latex/numpy-ref.pdf build/dist - cp build/latex/numpy-user.pdf build/dist cd build/dist && tar czf ../dist.tar.gz * chmod ug=rwX,o=rX -R build/dist find build/dist -type d -print0 | xargs -0r chmod g+s -dist-build: - rm -f ../dist/*.egg - cd .. && $(PYTHON) setup.py bdist_egg - install -d $(subst :, ,$(INSTALL_PPH)) - $(PYTHON) `which easy_install` --prefix=$(INSTALL_DIR) ../dist/*.egg - -upload: build/dist.tar.gz - # SSH must be correctly configured for this to work. - # Assumes that ``make dist`` was already run - # Example usage: ``make upload USERNAME=rgommers RELEASE=1.10.1`` - ssh $(USERNAME)@docs.scipy.org mkdir $(UPLOAD_DIR) - scp build/dist.tar.gz $(USERNAME)@docs.scipy.org:$(UPLOAD_DIR) - ssh $(USERNAME)@docs.scipy.org tar xvC $(UPLOAD_DIR) \ - -zf $(UPLOAD_DIR)/dist.tar.gz - ssh $(USERNAME)@docs.scipy.org mv $(UPLOAD_DIR)/numpy-ref.pdf \ - $(UPLOAD_DIR)/numpy-ref-$(RELEASE).pdf - ssh $(USERNAME)@docs.scipy.org mv $(UPLOAD_DIR)/numpy-user.pdf \ - $(UPLOAD_DIR)/numpy-user-$(RELEASE).pdf - ssh $(USERNAME)@docs.scipy.org mv $(UPLOAD_DIR)/numpy-html.zip \ - $(UPLOAD_DIR)/numpy-html-$(RELEASE).zip - ssh $(USERNAME)@docs.scipy.org rm $(UPLOAD_DIR)/dist.tar.gz - ssh $(USERNAME)@docs.scipy.org ln -snf numpy-$(RELEASE) /srv/docs_scipy_org/doc/numpy - - merge-doc: build/dist.tar.gz ifeq "$(TAG)" "" echo tag "$(TAG)" not of the form 1.18; @@ -156,7 +128,7 @@ endif tar -C build/merge/$(TAG) -xf build/dist.tar.gz git -C build/merge add $(TAG) @# For now, the user must do this. If it is onerous, automate it and change - @# the instructions in doc/HOWTO_RELEASE.rst.txt + @# the instructions in doc/HOWTO_RELEASE.rst @echo " " @echo New documentation archive added to ./build/merge. @echo Now add/modify the appropriate section after @@ -188,22 +160,6 @@ endif @echo @echo "Build finished. The HTML pages are in build/html." -html-scipyorg: - mkdir -p build/html build/doctrees - $(SPHINXBUILD) -t scipyorg -b html $(ALLSPHINXOPTS) build/html-scipyorg $(FILES) - @echo - @echo "Build finished. The HTML pages are in build/html-scipyorg." - -pickle: generate version-check - mkdir -p build/pickle build/doctrees - $(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) build/pickle $(FILES) - @echo - @echo "Build finished; now you can process the pickle files or run" - @echo " sphinx-web build/pickle" - @echo "to start the sphinx-web server." - -web: pickle - htmlhelp: generate version-check mkdir -p build/htmlhelp build/doctrees $(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) build/htmlhelp $(FILES) @@ -247,7 +203,6 @@ linkcheck: generate version-check @echo @echo "Link check complete; look for any errors in the above output " \ "or in build/linkcheck/output.txt." - texinfo: $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) build/texinfo @echo @@ -261,6 +216,6 @@ info: make -C build/texinfo info @echo "makeinfo finished; the Info files are in build/texinfo." + show: @python -c "import webbrowser; webbrowser.open_new_tab('file://$(PWD)/build/html/index.html')" - diff --git a/doc/Py3K.rst.txt b/doc/Py3K.rst similarity index 100% rename from doc/Py3K.rst.txt rename to doc/Py3K.rst diff --git a/doc/RELEASE_WALKTHROUGH.rst.txt b/doc/RELEASE_WALKTHROUGH.rst similarity index 53% rename from doc/RELEASE_WALKTHROUGH.rst.txt rename to doc/RELEASE_WALKTHROUGH.rst index 42d84e04b25a..855181c9f3a7 100644 --- a/doc/RELEASE_WALKTHROUGH.rst.txt +++ b/doc/RELEASE_WALKTHROUGH.rst @@ -1,22 +1,51 @@ -This file contains a walkthrough of the NumPy 1.21.0 release on Linux, modified -for building on azure and uploading to anaconda.org -The commands can be copied into the command line, but be sure to -replace 1.21.0 by the correct version. +This is a walkthrough of the NumPy 1.21.0 release on Linux, modified for +building with GitHub Actions and cibuildwheels and uploading to the +`anaconda.org staging repository for NumPy `_. +The commands can be copied into the command line, but be sure to replace 1.21.0 +by the correct version. This should be read together with the +:ref:`general release guide `. + +Facility preparation +==================== + +Before beginning to make a release, use the ``*_requirements.txt`` files to +ensure that you have the needed software. Most software can be installed with +pip, but some will require apt-get, dnf, or whatever your system uses for +software. You will also need a GitHub personal access token (PAT) to push the +documentation. There are a few ways to streamline things: -This should be read together with the general directions in `releasing`. +- Git can be set up to use a keyring to store your GitHub personal access token. + Search online for the details. +- You can use the ``keyring`` app to store the PyPI password for twine. See the + online twine documentation for details. -Release Preparation +Release preparation =================== +Add/drop Python versions +------------------------ + +When adding or dropping Python versions, three files need to be edited: + +- .github/workflows/wheels.yml # for github cibuildwheel +- .travis.yml # for cibuildwheel aarch64 builds +- setup.py # for classifier and minimum version check. + +Make these changes in an ordinary PR against main and backport if necessary. +Using the `BLD:` prefix (build label) for the commit summary will cause the +wheel builds to be run so that the changes will be tested, We currently release +wheels for new Python versions after the first Python rc once manylinux and +cibuildwheel support it. For Python 3.11 we were able to release within a week +of the rc1 announcement. + Backport Pull Requests ---------------------- Changes that have been marked for this release must be backported to the maintenance/1.21.x branch. - -Update Release documentation +Update release documentation ---------------------------- Four documents usually need to be updated or created before making a release: @@ -62,17 +91,17 @@ done. Note that the ``:orphan:`` markup at the top, if present, will need changing to ``.. currentmodule:: numpy`` and the ``doc/source/release.rst`` index file will need updating. -Check the pavement.py file -~~~~~~~~~~~~~~~~~~~~~~~~~~ +Check the ``pavement.py`` file +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Check that the pavement.py file points to the correct release notes. It should have been updated after the last release, but if not, fix it now:: - $gvim pavement.py + $ gvim pavement.py -Release Walkthrough -==================== +Release walkthrough +=================== Note that in the code snippets below, ``upstream`` refers to the root repository on GitHub and ``origin`` to its fork in your personal GitHub repositories. You may @@ -80,8 +109,8 @@ need to make adjustments if you have not forked the repository but simply cloned it locally. You can also edit ``.git/config`` and add ``upstream`` if it isn't already present. -Prepare the release commit --------------------------- +1. Prepare the release commit +----------------------------- Checkout the branch for the release, make sure it is up to date, and clean the repository:: @@ -101,66 +130,62 @@ repository:: $ git tag -a -s v1.21.0 -m"NumPy 1.21.0 release" $ git push upstream v1.21.0 +If you need to delete the tag due to error:: + + $ git tag -d v1.21.0 + $ git push --delete upstream v1.21.0 -Build source releases ---------------------- +2. Build wheels +--------------- -Paver is used to build the source releases. It will create the ``release`` and -``release/installers`` directories and put the ``*.zip`` and ``*.tar.gz`` -source releases in the latter. :: +Build wheels via cibuildwheel (preferred) +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - $ paver sdist # sdist will do a git clean -xdfq, so we omit that +Tagging the build at the beginning of this process will trigger a wheel build +via cibuildwheel and upload wheels and an sdist to the staging repo. The CI run +on github actions (for all x86-based and macOS arm64 wheels) takes about 1 1/4 +hours. The CI run on travis (for aarch64) takes less time. You can check for +uploaded files at the `staging repository`_, but note that it is not closely +synched with what you see of the running jobs. +If you wish to manually trigger a wheel build, you can do so: -Build wheels ------------- +- On github actions -> `Wheel builder`_ there is a "Run workflow" button, click + on it and choose the tag to build +- On travis_ there is a "More Options" button, click on it and choose a branch + to build. There does not appear to be an option to build a tag. -Trigger the wheels build by pointing the numpy-wheels repository at this -commit. This can take up to an hour. The numpy-wheels repository is cloned from -``_. If this is the first release in -a series, start with a pull as the repo may have been accessed and changed by -someone else, then create a new branch for the series. If the branch already -exists skip this:: +If a wheel build fails for unrelated reasons, you can rerun it individually: - $ cd ../numpy-wheels - $ git checkout main - $ git pull upstream main - $ git branch v1.21.x - -Checkout the new branch and edit the ``azure-pipelines.yml`` and -``.travis.yml`` files to make sure they have the correct version, and put in -the commit hash for the ``REL`` commit created above for ``BUILD_COMMIT`` -variable. The ``azure/posix.yml`` and ``.travis.yml`` files may also need the -Cython versions updated to keep up with Python releases, but generally just -do:: - - $ git checkout v1.21.x - $ gvim azure-pipelines.yml .travis.yml - $ git commit -a -m"NumPy 1.21.0 release." - $ git push upstream HEAD +- On github actions select `Wheel builder`_ click on the commit that contains + the build you want to rerun. On the left there is a list of wheel builds, + select the one you want to rerun and on the resulting page hit the + counterclockwise arrows button. +- On travis_ select the failing build, which will take you to the travis job for + that build. Hit the restart job button. -Now wait. If you get nervous at the amount of time taken -- the builds can take -a while -- you can check the build progress by following the links -provided at ``_ to check the -build status. Check if all the needed wheels have been built and -uploaded to the staging repository before proceeding. +Note that if you do need to rerun jobs, you will need to delete the uploaded +file, if any, in the anaconda `staging repository`_, The old files will not be +overwritten. -Note that sometimes builds, like tests, fail for unrelated reasons and you will -need to rerun them. You will need to be logged in under 'numpy' to do this -on azure. +.. _`staging repository`: https://anaconda.org/multibuild-wheels-staging/numpy/files +.. _`Wheel builder`: https://github.com/numpy/numpy/actions/workflows/wheels.yml +.. _travis : https://app.travis-ci.com/github/numpy/numpy -Download wheels ---------------- + +3. Download wheels +------------------ When the wheels have all been successfully built and staged, download them from the Anaconda staging directory using the ``tools/download-wheels.py`` script:: $ cd ../numpy + $ mkdir -p release/installers $ python3 tools/download-wheels.py 1.21.0 -Generate the README files -------------------------- +4. Generate the README files +---------------------------- This needs to be done after all installers are downloaded, but before the pavement file is updated for continued development:: @@ -168,8 +193,8 @@ file is updated for continued development:: $ paver write_release -Reset the maintenance branch into a development state ------------------------------------------------------ +5. Reset the maintenance branch into a development state (skip for prereleases) +------------------------------------------------------------------------------- Create release notes for next release and edit them to set the version. These notes will be a skeleton and have little content:: @@ -179,7 +204,7 @@ notes will be a skeleton and have little content:: $ git add doc/source/release/1.21.1-notes.rst Add new release notes to the documentation release list and update the -``RELEASE_NOTES`` variable in ``pavement.py``. +``RELEASE_NOTES`` variable in ``pavement.py``:: $ gvim doc/source/release.rst pavement.py @@ -189,15 +214,15 @@ Commit the result:: $ git push upstream HEAD -Upload to PyPI --------------- +6. Upload to PyPI +----------------- Upload to PyPI using ``twine``. A recent version of ``twine`` of is needed after recent PyPI changes, version ``3.4.1`` was used here:: $ cd ../numpy $ twine upload release/installers/*.whl - $ twine upload release/installers/numpy-1.21.0.zip # Upload last. + $ twine upload release/installers/numpy-1.21.0.tar.gz # Upload last. If one of the commands breaks in the middle, you may need to selectively upload the remaining files because PyPI does not allow the same file to be uploaded @@ -208,8 +233,8 @@ wheel. PyPI only allows a single source distribution, here we have chosen the zip archive. -Upload files to github ----------------------- +7. Upload files to github +------------------------- Go to ``_, there should be a ``v1.21.0 tag``, click on it and hit the edit button for that tag. There are two ways to @@ -221,70 +246,89 @@ Then copy the contents to the clipboard and paste them into the text window. It may take several tries to get it look right. Then - Upload ``release/installers/numpy-1.21.0.tar.gz`` as a binary file. -- Upload ``release/installers/numpy-1.21.0.zip`` as a binary file. - Upload ``release/README.rst`` as a binary file. - Upload ``doc/changelog/1.21.0-changelog.rst`` as a binary file. - Check the pre-release button if this is a pre-releases. - Hit the ``{Publish,Update} release`` button at the bottom. -Upload documents to numpy.org ------------------------------ +8. Upload documents to numpy.org (skip for prereleases) +------------------------------------------------------- + +.. note:: You will need a GitHub personal access token to push the update. This step is only needed for final releases and can be skipped for pre-releases and most patch releases. ``make merge-doc`` clones the ``numpy/doc`` repo into ``doc/build/merge`` and updates it with the new documentation:: -Note that if you have a `.local` numpy install, you should either remove it or -install the current version for the docs to pick up the correct NumPy version. + $ git clean -xdfq + $ git co v1.21.0 $ pushd doc - $ make dist + $ make docenv && source docenv/bin/activate $ make merge-doc - $ popd + $ pushd build/merge If the release series is a new one, you will need to add a new section to the ``doc/build/merge/index.html`` front page just after the "insert here" comment:: - $ gvim doc/build/merge/index.html +/'insert here' + $ gvim index.html +/'insert here' + +Further, update the version-switcher json file to add the new release and +update the version marked `(stable)`:: + + $ gvim _static/versions.json -Otherwise, only the ``zip`` and ``pdf`` links should be updated with the -new tag name:: +Otherwise, only the ``zip`` link should be updated with the new tag name. Since +we are no longer generating ``pdf`` files, remove the line for the ``pdf`` +files if present:: - $ gvim doc/build/merge/index.html +/'tag v1.21' + $ gvim index.html +/'tag v1.21' You can "test run" the new documentation in a browser to make sure the links work:: - $ firefox doc/build/merge/index.html + $ firefox index.html # or google-chrome, etc. -Update the stable link:: +Update the stable link and update:: $ ln -sfn 1.21 stable + $ ls -l # check the link -Once everything seems satisfactory, commit and upload the changes:: +Once everything seems satisfactory, update, commit and upload the changes:: - $ pushd doc/build/merge + $ python3 update.py $ git commit -a -m"Add documentation for v1.21.0" $ git push + $ deactivate + $ popd $ popd -Announce the release on scipy.org ---------------------------------- -This assumes that you have forked ``_:: +9. Announce the release on numpy.org (skip for prereleases) +----------------------------------------------------------- + +This assumes that you have forked ``_:: - $ cd ../scipy.org - $ git checkout master - $ git pull upstream master - $ git checkout -b numpy-1.21.0 - $ gvim www/index.rst # edit the News section - $ git commit -a + $ cd ../numpy.org + $ git checkout main + $ git pull upstream main + $ git checkout -b announce-numpy-1.21.0 + $ gvim content/en/news.md + +- For all releases, go to the bottom of the page and add a one line link. Look + to the previous links for example. +- For the ``*.0`` release in a cycle, add a new section at the top with a short + description of the new features and point the news link to it. + +commit and push:: + + $ git commit -a -m"announce the NumPy 1.21.0 release" $ git push origin HEAD -Now go to your fork and make a pull request for the branch. +Go to your Github fork and make a pull request. -Announce to mailing lists -------------------------- +10. Announce to mailing lists +----------------------------- The release should be announced on the numpy-discussion, scipy-devel, scipy-user, and python-announce-list mailing lists. Look at previous @@ -293,8 +337,8 @@ as generated for the release notes above. If you crosspost, make sure that python-announce-list is BCC so that replies will not be sent to that list. -Post-Release Tasks ------------------- +11. Post-release tasks (skip for prereleases) +--------------------------------------------- Checkout main and forward port the documentation changes:: @@ -303,9 +347,18 @@ Checkout main and forward port the documentation changes:: $ git checkout maintenance/1.21.x doc/changelog/1.21.0-changelog.rst $ git checkout maintenance/1.21.x .mailmap # only if updated for release. $ gvim doc/source/release.rst # Add link to new notes - $ git add doc/changelog/1.21.0-changelog.rst doc/source/release/1.21.0-notes.rst $ git status # check status before commit - $ git commit -a -m"REL: Update main after 1.21.0 release." + $ git commit -a -m"MAINT: Update main after 1.21.0 release." $ git push origin HEAD Go to GitHub and make a PR. + +12. Update oldest-supported-numpy +--------------------------------- + +If this release is the first one to support a new Python version, or the first +to provide wheels for a new platform or PyPy version, the version pinnings +in https://github.com/scipy/oldest-supported-numpy should be updated. +Either submit a PR with changes to ``setup.cfg`` there, or open an issue with +info on needed changes. + diff --git a/doc/TESTS.rst.txt b/doc/TESTS.rst similarity index 96% rename from doc/TESTS.rst.txt rename to doc/TESTS.rst index 0d8137f4a7e1..9c5e8571ff64 100644 --- a/doc/TESTS.rst.txt +++ b/doc/TESTS.rst @@ -178,30 +178,33 @@ Similarly for methods:: Easier setup and teardown functions / methods --------------------------------------------- -Testing looks for module-level or class-level setup and teardown functions by -name; thus:: +Testing looks for module-level or class method-level setup and teardown +functions by name; thus:: - def setup(): + def setup_module(): """Module-level setup""" print('doing setup') - def teardown(): + def teardown_module(): """Module-level teardown""" print('doing teardown') class TestMe: - def setup(): + def setup_method(self): """Class-level setup""" print('doing setup') - def teardown(): + def teardown_method(): """Class-level teardown""" print('doing teardown') Setup and teardown functions to functions and methods are known as "fixtures", -and their use is not encouraged. +and they should be used sparingly. +``pytest`` supports more general fixture at various scopes which may be used +automatically via special arguments. For example, the special argument name +``tmpdir`` is used in test to create a temporary directory. Parametric tests ---------------- diff --git a/doc/changelog/1.12.0-changelog.rst b/doc/changelog/1.12.0-changelog.rst index 2e91f510f529..052714374445 100644 --- a/doc/changelog/1.12.0-changelog.rst +++ b/doc/changelog/1.12.0-changelog.rst @@ -283,7 +283,7 @@ A total of 418 pull requests were merged for this release. * `#7373 `__: ENH: Add bitwise_and identity * `#7378 `__: added NumPy logo and separator * `#7382 `__: MAINT: cleanup np.average -* `#7385 `__: DOC: note about wheels / windows wheels for pypi +* `#7385 `__: DOC: note about wheels / windows wheels for PyPI * `#7386 `__: Added label icon to Travis status * `#7397 `__: BUG: incorrect type for objects whose __len__ fails * `#7398 `__: DOC: fix typo diff --git a/doc/changelog/1.15.0-changelog.rst b/doc/changelog/1.15.0-changelog.rst index dd5544ac9fec..33823f809d10 100644 --- a/doc/changelog/1.15.0-changelog.rst +++ b/doc/changelog/1.15.0-changelog.rst @@ -303,7 +303,7 @@ A total of 438 pull requests were merged for this release. * `#10566 `__: BUG: Fix travis failure in previous commit * `#10571 `__: BUG: Fix corner-case behavior of cond() and use SVD when possible * `#10576 `__: MAINT: Fix misc. documentation typos -* `#10583 `__: MAINT: Fix typos in DISTUTILS.rst.txt. +* `#10583 `__: MAINT: Fix typos in DISTUTILS.rst. * `#10588 `__: BUG: Revert sort optimization in np.unique. * `#10589 `__: BUG: fix entry_points typo for from-template * `#10591 `__: ENH: Add histogram_bin_edges function and test @@ -580,5 +580,5 @@ A total of 438 pull requests were merged for this release. * `#11532 `__: BUG: Decref of field title caused segfault * `#11540 `__: DOC: Update the 1.15.0 release notes. * `#11577 `__: BLD: Modify cpu detection and printing to get working aarch64... -* `#11578 `__: DOC: link to TESTS.rst.txt testing guidelines, tweak testing... +* `#11578 `__: DOC: link to TESTS.rst testing guidelines, tweak testing... * `#11602 `__: TST: Add Python 3.7 to CI testing diff --git a/doc/changelog/1.16.0-changelog.rst b/doc/changelog/1.16.0-changelog.rst index 8aca5e643b1a..8f7afac899e0 100644 --- a/doc/changelog/1.16.0-changelog.rst +++ b/doc/changelog/1.16.0-changelog.rst @@ -138,7 +138,7 @@ A total of 490 pull requests were merged for this release. * `#10998 `__: DOC: removed spurious FIXME comment in number.c * `#11002 `__: MAINT: add clearer message to assist users with failed builds. * `#11016 `__: ENH: Add AARCH32 support. -* `#11084 `__: DOC: link to TESTS.rst.txt testing guidelines, tweak testing... +* `#11084 `__: DOC: link to TESTS.rst testing guidelines, tweak testing... * `#11119 `__: ENH: Chain exceptions to give better error messages for invalid... * `#11175 `__: ENH: Generalized ufunc signature expansion for frozen and flexible... * `#11197 `__: BUG/ENH: Removed non-standard scaling of the covariance matrix... diff --git a/doc/changelog/1.17.0-changelog.rst b/doc/changelog/1.17.0-changelog.rst index 8179c180bad3..dcac25bc7030 100644 --- a/doc/changelog/1.17.0-changelog.rst +++ b/doc/changelog/1.17.0-changelog.rst @@ -239,7 +239,7 @@ A total of 532 pull requests were merged for this release. * `#12594 `__: DEV, BUILD: add pypy3 to azure CI * `#12596 `__: ENH: improve performance of numpy.core.records.fromarrays * `#12601 `__: DOC: Correct documentation of `numpy.delete` obj parameter. -* `#12602 `__: DOC: Update RELEASE_WALKTHROUGH.rst.txt. +* `#12602 `__: DOC: Update RELEASE_WALKTHROUGH.rst. * `#12604 `__: BUG: Check that dtype and formats arguments for None. * `#12606 `__: DOC: Document NPY_SORTKIND parameter in PyArray_Sort * `#12608 `__: MAINT: Use `*.format` for some strings. @@ -609,7 +609,7 @@ A total of 532 pull requests were merged for this release. * `#13724 `__: MAINT: fix use of cache_dim * `#13725 `__: BUG: fix compilation of 3rd party modules with Py_LIMITED_API... * `#13726 `__: MAINT: Update PCG jump sizes -* `#13729 `__: DOC: Merge together DISTUTILS.rst.txt#template-files" and distutils.r… +* `#13729 `__: DOC: Merge together DISTUTILS.rst#template-files" and distutils.r… * `#13730 `__: MAINT: Change keyword from reserved word * `#13737 `__: DOC: Mention and try to explain pairwise summation in sum * `#13741 `__: MAINT: random: Remove unused empty file binomial.h. @@ -630,7 +630,7 @@ A total of 532 pull requests were merged for this release. * `#13774 `__: BUG: Make ``Generator._masked`` flag default to ``False``. * `#13777 `__: MAINT: Remove duplication of should_use_min_scalar_type function * `#13780 `__: ENH: use SeedSequence instead of seed() -* `#13781 `__: DOC: Update TESTS.rst.txt for pytest +* `#13781 `__: DOC: Update TESTS.rst for pytest * `#13786 `__: MAINT: random: Fix a few compiler warnings. * `#13787 `__: DOC: Fixed the problem of "versionadded" * `#13788 `__: MAINT: fix 'in' -> 'is' typo diff --git a/doc/changelog/1.19.0-changelog.rst b/doc/changelog/1.19.0-changelog.rst index bde00249972a..93e8d3b57c1a 100644 --- a/doc/changelog/1.19.0-changelog.rst +++ b/doc/changelog/1.19.0-changelog.rst @@ -162,7 +162,7 @@ A total of 488 pull requests were merged for this release. * `#15035 `__: BUG: add endfunction, endsubroutine to valid fortran end words * `#15040 `__: TST: Add test for object method (and general unary) loops * `#15042 `__: REL: Update master after 1.18.x branch. -* `#15043 `__: DOC: Update HOWTO_RELEASE.rst.txt +* `#15043 `__: DOC: Update HOWTO_RELEASE.rst * `#15046 `__: API, DOC: change names to multivariate_hypergeometric, improve... * `#15050 `__: DOC: Fix statement about norms * `#15052 `__: MAINT: follow-up cleanup for blas64 PR diff --git a/doc/changelog/1.20.0-changelog.rst b/doc/changelog/1.20.0-changelog.rst index f06bd8a8d22d..f2af4a7de01c 100644 --- a/doc/changelog/1.20.0-changelog.rst +++ b/doc/changelog/1.20.0-changelog.rst @@ -714,7 +714,7 @@ A total of 716 pull requests were merged for this release. * `#17440 `__: DOC: Cleaner template for PRs * `#17442 `__: MAINT: fix exception chaining in format.py * `#17443 `__: ENH: Warn on unsupported Python 3.10+ -* `#17444 `__: ENH: Add ``Typing :: Typed`` to the PyPi classifier +* `#17444 `__: ENH: Add ``Typing :: Typed`` to the PyPI classifier * `#17445 `__: DOC: Fix the references for macros * `#17447 `__: NEP: update NEP 42 with discussion of type hinting applications * `#17448 `__: DOC: Remove CoC pages from Sphinx diff --git a/doc/changelog/1.21.0-changelog.rst b/doc/changelog/1.21.0-changelog.rst index 947da4da740e..158c5a8cfa56 100644 --- a/doc/changelog/1.21.0-changelog.rst +++ b/doc/changelog/1.21.0-changelog.rst @@ -296,7 +296,7 @@ A total of 581 pull requests were merged for this release. * `#18045 `__: MAINT: Bump pytest from 6.2.0 to 6.2.1 * `#18046 `__: TST: add back sdist test run * `#18047 `__: BLD,DOC: pin sphinx to 3.3.1 -* `#18048 `__: DOC: Update TESTS.rst.txt +* `#18048 `__: DOC: Update TESTS.rst * `#18050 `__: MAINT: Add aliases for commonly used `ArrayLike` objects * `#18051 `__: DEP: deprecate np.testing.dec * `#18052 `__: BUG: Fix concatenation when the output is "S" or "U" diff --git a/doc/changelog/1.21.5-changelog.rst b/doc/changelog/1.21.5-changelog.rst new file mode 100644 index 000000000000..acd3599d48ef --- /dev/null +++ b/doc/changelog/1.21.5-changelog.rst @@ -0,0 +1,31 @@ + +Contributors +============ + +A total of 7 people contributed to this release. People with a "+" by their +names contributed a patch for the first time. + +* Bas van Beek +* Charles Harris +* Matti Picus +* Rohit Goswami + +* Ross Barnowski +* Sayed Adel +* Sebastian Berg + +Pull requests merged +==================== + +A total of 11 pull requests were merged for this release. + +* `#20357 `__: MAINT: Do not forward `__(deep)copy__` calls of `_GenericAlias`... +* `#20462 `__: BUG: Fix float16 einsum fastpaths using wrong tempvar +* `#20463 `__: BUG, DIST: Print os error message when the executable not exist +* `#20464 `__: BLD: Verify the ability to compile C++ sources before initiating... +* `#20465 `__: BUG: Force ``npymath` ` to respect ``npy_longdouble`` +* `#20466 `__: BUG: Fix failure to create aligned, empty structured dtype +* `#20467 `__: ENH: provide a convenience function to replace npy_load_module +* `#20495 `__: MAINT: update wheel to version that supports python3.10 +* `#20497 `__: BUG: Clear errors correctly in F2PY conversions +* `#20613 `__: DEV: add a warningfilter to fix pytest workflow. +* `#20618 `__: MAINT: Help boost::python libraries at least not crash diff --git a/doc/changelog/1.21.6-changelog.rst b/doc/changelog/1.21.6-changelog.rst new file mode 100644 index 000000000000..5d869ee0fe50 --- /dev/null +++ b/doc/changelog/1.21.6-changelog.rst @@ -0,0 +1,15 @@ + +Contributors +============ + +A total of 1 people contributed to this release. People with a "+" by their +names contributed a patch for the first time. + +* Charles Harris + +Pull requests merged +==================== + +A total of 1 pull requests were merged for this release. + +* `#21318 `__: REV: Revert pull request #20464 from charris/backport-20354 diff --git a/doc/changelog/1.22.0-changelog.rst b/doc/changelog/1.22.0-changelog.rst new file mode 100644 index 000000000000..c7a49bc13376 --- /dev/null +++ b/doc/changelog/1.22.0-changelog.rst @@ -0,0 +1,775 @@ + +Contributors +============ + +A total of 153 people contributed to this release. People with a "+" by their +names contributed a patch for the first time. + +* @DWesl +* @Illviljan +* @h-vetinari +* @yan-wyb + +* Aaron Meurer +* Abel Aoun + +* Adrian Gao + +* Ahmet Can Solak + +* Ajay DS + +* Alban Colley + +* Alberto Rubiales + +* Alessia Marcolini + +* Amit Kumar + +* Andrei Batomunkuev + +* Andrew Watson + +* Anirudh Dagar + +* Ankit Dwivedi + +* Antony Lee +* Arfy Slowy + +* Arryan Singh + +* Arun Palaniappen + +* Arushi Sharma + +* Bas van Beek +* Brent Brewington + +* Carl Johnsen + +* Carl Michal + +* Charles Harris +* Chiara Marmo +* Chris Fu (傅立业) + +* Christoph Buchner + +* Christoph Reiter + +* Chunlin Fang +* Clément Robert + +* Constanza Fierro +* Damien Caliste +* Daniel Ching +* David Badnar + +* David Cortes + +* David Okpare + +* Derek Huang + +* Developer-Ecosystem-Engineering + +* Dima Pasechnik +* Dimitri Papadopoulos + +* Dmitriy Fishman + +* Eero Vaher + +* Elias Koromilas + +* Eliaz Bobadilla + +* Elisha Hollander + +* Eric Wieser +* Eskild Eriksen + +* Evan Miller + +* Fayas Noushad + +* Gagandeep Singh + +* Ganesh Kathiresan +* Ghiles Meddour + +* Greg Lucas +* Gregory R. Lee +* Guo Shuai + +* Gwyn Ciesla + +* Hameer Abbasi +* Hector Martin + +* Henry Schreiner + +* Himanshu + +* Hood Chatham + +* Hugo Defois + +* Hugo van Kemenade +* I-Shen Leong + +* Imen Rajhi + +* Irina Maria Mocan + +* Irit Katriel + +* Isuru Fernando +* Jakob Jakobson +* Jerry Morrison + +* Jessi J Zhao + +* Joe Marshall + +* Johan von Forstner + +* Jonas I. Liechti + +* Jonathan Reichelt Gjertsen + +* Joshua Himmens + +* Jérome Eertmans +* Jérôme Kieffer + +* KIU Shueng Chuan + +* Kazuki Sakamoto + +* Kenichi Maehashi +* Kenny Huynh + +* Kent R. Spillner + +* Kevin Granados + +* Kevin Modzelewski + +* Kevin Sheppard +* Lalit Musmade + +* Malik Idrees Hasan Khan + +* Marco Aurelio da Costa + +* Margret Pax + +* Mars Lee + +* Marten van Kerkwijk +* Matthew Barber + +* Matthew Brett +* Matthias Bussonnier +* Matthieu Dartiailh +* Matti Picus +* Melissa Weber Mendonça +* Michael McCann + +* Mike Jarvis + +* Mike McCann + +* Mike Toews +* Mukulika Pahari +* Nick Pope + +* Nick Wogan + +* Niels Dunnewind + +* Niko Savola + +* Nikola Forró +* Niyas Sait + +* Pamphile ROY +* Paul Ganssle + +* Pauli Virtanen +* Pearu Peterson +* Peter Hawkins + +* Peter Tillema + +* Prathmesh Shirsat + +* Raghuveer Devulapalli +* Ralf Gommers +* Robert Kern +* Rohit Goswami + +* Ronan Lamy +* Ross Barnowski +* Roy Jacobson + +* Samyak S Sarnayak + +* Sayantika Banik + +* Sayed Adel +* Sebastian Berg +* Sebastian Schleehauf + +* Serge Guelton +* Shriraj Hegde + +* Shubham Gupta + +* Sista Seetaram + +* Stefan van der Walt +* Stephannie Jimenez Gacha + +* Tania Allard +* Theodoros Nikolaou + +* Thomas Green + +* Thomas J. Fan +* Thomas Li + +* Tim Hoffmann +* Tom Tan + +* Tyler Reddy +* Vijay Arora + +* Vinith Kishore + +* Warren Weckesser +* Yang Hau +* Yashasvi Misra +* Yuval Ofek + +* Zac Hatfield-Dodds +* Zhang Na + + +Pull requests merged +==================== + +A total of 609 pull requests were merged for this release. + +* `#15847 `__: BUG: avoid infinite recurrence on dependencies in crackfortran +* `#16740 `__: ENH: Add broadcast support to Generator.multinomial +* `#16796 `__: DOC: Added a warning about fractional steps in np.arange +* `#17530 `__: ENH: Allow ``ctypeslib.load_library`` to take any path-like object +* `#17582 `__: ENH: Configurable allocator +* `#18203 `__: MAINT: Speedup np.quantile. +* `#18330 `__: TST: Add cygwin build to CI +* `#18421 `__: DOC: Adjust polyfit doc to clarify the meaning of w +* `#18536 `__: ENH: Add smallest_normal and smallest_subnormal attributes to... +* `#18585 `__: ENH: Implementation of the NEP 47 (adopting the array API standard) +* `#18759 `__: BUG: revise string_from_pyobj/try_pyarr_from_string with respect... +* `#18762 `__: MAINT: Remove unused imports and unreachable code +* `#18775 `__: DOC: Ensure that we add documentation also as to the dict for... +* `#18884 `__: DOC: Add support for documenting C/C++ via Doxygen & Breathe +* `#18905 `__: MAINT: Refactor reductions to use NEP 43 style dispatching/promotion +* `#18964 `__: DOC: replace np.ma functions' return types with ``MaskedArray`` +* `#18984 `__: DOC: add example showing how to convert POSIX timestamps to datetime64 +* `#19003 `__: DOC: Remove misleading info about Fortran compiler in Building... +* `#19016 `__: BUG: Update coordinates on PyArray_ITER_GOTO1D +* `#19022 `__: SIMD: Add new universal intrinsic for ceil +* `#19023 `__: BUG: fix np.ma.MaskedArray.anom when input is masked +* `#19036 `__: MAINT: replace imgmath with mathjax for docs +* `#19058 `__: BUG: Fixes to getter signatures +* `#19060 `__: ENH: Add initial annotations to ``np.core.multiarray`` +* `#19062 `__: ENH: Add a mypy plugin for inferring the precision of ``np.ctypeslib.c_intp`` +* `#19070 `__: REL: Prepare for NumPy 1.22.0 development +* `#19071 `__: BUG: Fix compile-time test of POPCNT +* `#19072 `__: BUG, TST: Fix test_numpy_version. +* `#19082 `__: MAINT: Bump hypothesis from 6.12.0 to 6.13.4 +* `#19083 `__: ENH: Implement the DLPack Array API protocols for ndarray. +* `#19086 `__: BUG: Linter should only run on pull requests. +* `#19087 `__: DOC: Add note to savez about naming variables with keyword ``file``. +* `#19089 `__: DOC: Add example to histogram2d docstring +* `#19090 `__: MAINT: removed unused imports listed in LGTM +* `#19092 `__: BUG: Fixed an issue wherein ``_GenericAlias.__getitem__`` would... +* `#19093 `__: DOC: add a "Returns" section for ``np.frombuffer`` +* `#19096 `__: BUG: Fix setup.py to work in maintenance branches. +* `#19098 `__: BUG, SIMD: Fix detect host/native CPU features on ICC during... +* `#19099 `__: DOC: fixed unsigned integer alias links. +* `#19102 `__: MAINT: Removed suitable unused variables shown in LGTM +* `#19110 `__: DOC: Fix the documented default value of the ``order`` parameter... +* `#19115 `__: DOC: Misc fixes to ``absolute_beginners.html`` +* `#19118 `__: MAINT: Misc cleaning of ``numpy.typing`` +* `#19119 `__: BUG: Adjust shallow clone in the gitpod container +* `#19121 `__: DOC: Fix missing files and deprecated commands. +* `#19124 `__: BUG: Fixed an issue wherein ``poly1d.__getitem__`` could return... +* `#19128 `__: DOC:``Building the NumPy API and reference docs`` rewrite +* `#19130 `__: ENH: SIMD architectures to show_config +* `#19131 `__: DOC: added explanation about tril/triu n-dimensional functionality. +* `#19132 `__: BUG: Use larger fetch depth in gitpod.yml +* `#19135 `__: BUG: Remove complex floor divide +* `#19139 `__: MAINT: Bump hypothesis from 6.13.4 to 6.13.10 +* `#19140 `__: ENH: Add dtype-support to 3 ``generic``/``ndarray`` methods +* `#19142 `__: BUG: expose ``short_version`` as previously in version.py +* `#19151 `__: ENH: Vectorising np.linalg.qr +* `#19165 `__: DOC: Explicitly mention that ``searchsorted`` returns an integer... +* `#19167 `__: ENH: Improve readibility of error message in terminal. +* `#19170 `__: API: Delay string and number promotion deprecation/future warning +* `#19172 `__: BUG: Fixed an issue wherein ``_GenericAlias`` could raise for non-iterable... +* `#19173 `__: ENH: Add support for copy modes to NumPy +* `#19174 `__: MAINT, BUG: Adapt ``castingimpl.casting`` to denote a minimal level +* `#19176 `__: REV,BUG: Replace ``NotImplemented`` with ``typing.Any`` +* `#19177 `__: BUG: Add ``-std=c99`` to intel icc compiler flags on linux +* `#19179 `__: ENH: Add annotations for ``np.testing`` +* `#19181 `__: MAINT: Bump pytest-cov from 2.12.0 to 2.12.1 +* `#19182 `__: MAINT: Bump hypothesis from 6.13.10 to 6.13.14 +* `#19185 `__: DOC: Crosslinking to Gitpod guide +* `#19186 `__: DOC: ndindex class docstrings fix +* `#19188 `__: NEP: Accept NEP 35 (``like=`` keyword for array creation) as final +* `#19195 `__: DOC: Link issue label +* `#19196 `__: DOC: update references to other repos head branch to 'main' +* `#19200 `__: DOC: NeighborhoodIterator position on creation +* `#19202 `__: BUG: Fix out-of-bounds access in convert_datetime_divisor_to_multiple +* `#19209 `__: TST: Ignore exp FP exceptions test for glibc ver < 2.17 +* `#19211 `__: ENH: Adding keepdims to np.argmin,np.argmax +* `#19212 `__: MAINT: Add annotations for the missing ``period`` parameter to... +* `#19214 `__: ENH: Support major version larger than 9 in ``NumpyVersion`` +* `#19218 `__: MAINT: Add ``complex`` as allowed type for the ``np.complexfloating``... +* `#19223 `__: ENH: Add annotations for ``np.pad`` +* `#19224 `__: MAINT: Remove python 2 specific string comparison code +* `#19225 `__: DOC: Fix some inconsistencies in the docstring of matrix_rank +* `#19227 `__: ENH: Add annotations to ``np.core.multiarray`` part 2/4 +* `#19228 `__: BUG: Invalid dtypes comparison should not raise ``TypeError`` +* `#19235 `__: Revert "BUG: revise string_from_pyobj/try_pyarr_from_string with... +* `#19237 `__: ENH: Add annotations to ``np.core.multiarray`` part 3/4 +* `#19241 `__: MAINT: Bump hypothesis from 6.13.14 to 6.14.0 +* `#19242 `__: MAINT: Bump mypy from 0.812 to 0.902 +* `#19244 `__: BUG: Fix an issue wherein assigment to ``np.ma.masked_array`` ignores... +* `#19245 `__: ENH: Add dtype-support to the ``np.core.shape_base`` annotations +* `#19251 `__: BUG: revise string_from_pyobj/try_pyarr_from_string with respect... +* `#19254 `__: MAINT: Refactor output ufunc wrapping logic +* `#19256 `__: DOC: Fix formatting in rot90() docstring +* `#19257 `__: MAINT: Move array-prep and type resolution to earlier +* `#19258 `__: MAINT: Refactor and simplify the main ufunc iterator loop code +* `#19259 `__: MAINT: Align masked with normal ufunc loops +* `#19261 `__: ENH: Add annotations for ``np.lib.twodim_base`` +* `#19262 `__: MAINT: Some tiny fixes and style changes in ``ufunc_object.c`` +* `#19263 `__: STY: Small changes to the ``PyUFunc_ReduceWrapper`` +* `#19264 `__: DOC: fix duplicate navbar in development documentation index +* `#19275 `__: MAINT: Misc typing maintenance for ``np.dtype`` +* `#19276 `__: BUG: Fix ``arr.flat.index`` for large arrays and big-endian machines +* `#19277 `__: BUG: Add missing DECREF in new path +* `#19278 `__: MAINT: Remove accidentally created directory. +* `#19281 `__: ENH: add ``numpy.f2py.get_include`` function +* `#19284 `__: NEP: Fixes from NEP36 feedback +* `#19285 `__: MAINT: Use Ubuntu focal for travis-ci builds. +* `#19286 `__: ENH: Add annotations for ``np.lib.type_check`` +* `#19289 `__: BUG: Fix reference count leak in ufunc dtype handling +* `#19290 `__: DOC: Unpin pydata sphinx theme and update config to avoid long... +* `#19292 `__: MAINT: Add lightweight identity-hash map +* `#19293 `__: MAINT: Add simple tuple creation helper and use it +* `#19295 `__: DOC: Add ``versionadded`` directives to ``numpy.typing`` +* `#19298 `__: DOC: Add documentation for ``np.ctypeslib.c_intp`` +* `#19301 `__: BUG: Do not raise deprecation warning for all nans in unique +* `#19306 `__: DOC: Fix some docstrings that crash pdf generation. +* `#19314 `__: MAINT: bump scipy-mathjax +* `#19316 `__: BUG: Fix warning problems of the mod operator +* `#19317 `__: MAINT: Clean up multiarray interned strings +* `#19320 `__: REL: Update main after 1.21.0 release. +* `#19322 `__: BUG: Fix cast safety and comparisons for zero sized voids +* `#19323 `__: BUG: Correct Cython declaration in random +* `#19326 `__: BUG: protect against accessing base attribute of a NULL subarray +* `#19328 `__: MAINT: Replace ``"dtype[Any]"`` with ``dtype`` in the definiton of... +* `#19329 `__: ENH Add a conda-based CI job on azure. +* `#19338 `__: DOC: Removed duplicate instructions for building docs from ``dev/index``... +* `#19344 `__: MAINT: Annotate missing attributes of ``np.number`` subclasses +* `#19355 `__: ENH: Adding ``bit_count`` (popcount) +* `#19356 `__: API: Ensure np.vectorize outputs can be subclasses. +* `#19359 `__: ENH: Add annotations for ``np.f2py`` +* `#19360 `__: MAINT: remove ``print()``'s in distutils template handling +* `#19361 `__: ENH: Use literals for annotating ``int``- & ``str``-based constants +* `#19362 `__: BUG, SIMD: Fix detecting AVX512 features on Darwin +* `#19368 `__: MAINT: Bump mypy from 0.902 to 0.910 +* `#19369 `__: DOC: Moved VQ example & target from duplicate array broadcasting... +* `#19370 `__: MAINT: Move masked strided/inner-loop code to its "final" place +* `#19371 `__: MAINT: Use cast-is-view flag for the ufunc trivial-loop check +* `#19378 `__: DOC: fix remaining np.min/np.max usages +* `#19380 `__: BUG: Fix NULL special case in object-to-any cast code +* `#19381 `__: MAINT: Modify initialization order during multiarray import +* `#19393 `__: MAINT: fix overly broad exception handling listed in LGTM +* `#19394 `__: BUG, SIMD: Fix infinite loop during count non-zero on GCC-11 +* `#19396 `__: BUG: fix a numpy.npiter leak in npyiter_multi_index_set +* `#19402 `__: DOC: typo fix +* `#19403 `__: BUG: Fix memory leak in function npyiter_multi_index_set +* `#19404 `__: NEP: update NEP with the PyDataMem_Handler struct as implemented... +* `#19407 `__: DOC: Rearranged parts of the Indexing docs to consolidate content +* `#19408 `__: ENH: Add annotations for misc python-based functions +* `#19409 `__: BUG: fix some memory leaks in ufunc_object +* `#19412 `__: MAINT: Bump sphinx from 4.0.1 to 4.0.3 +* `#19413 `__: MAINT: Bump hypothesis from 6.14.0 to 6.14.1 +* `#19416 `__: DOC: Remove duplicate information about governance +* `#19418 `__: DOC: Removing tutorials from sphinx documentation +* `#19419 `__: BUG: fix f2py markinnerspace for multiple quotations +* `#19421 `__: ENH: Add annotations for ``np.core.getlimits`` +* `#19422 `__: DOC: Additional ideas related to numpy-tutorials integration +* `#19423 `__: Skip finite recursion and refcounting tests for pyston +* `#19426 `__: MAINT: Use arm64-graviton2 for testing on travis +* `#19429 `__: BUG: Fix some multiarray leaks +* `#19431 `__: MAINT: Delete old SSE2 ``absolute`` implementation +* `#19434 `__: MAINT: Fix the module of ``flagsobj`` +* `#19436 `__: ENH: Improve the annotations of ``flagsobj`` +* `#19440 `__: MAINT: factored out _PyArray_ArgMinMaxCommon +* `#19442 `__: MAINT: Use "with open(...)" +* `#19444 `__: ENH: Add annotations for ``np.lib.shape_base`` +* `#19445 `__: DOC: broadcast_to() supports int as shape parameter +* `#19446 `__: MAINT: Start testing with Python 3.10.0b3. +* `#19447 `__: DOC: BLAS/LAPACK linking rules +* `#19450 `__: TST: Simplify property-based test +* `#19451 `__: BUG: Make openblas_support support ILP64 on Windows. +* `#19456 `__: TST: Fix a ``GenericAlias`` test failure for python 3.9.0 +* `#19458 `__: MAINT: Avoid unicode characters in division SIMD code comments +* `#19459 `__: ENH: Add the ``axis`` and ``ndim`` attributes to ``np.AxisError`` +* `#19460 `__: MAINT: Bump sphinx from 4.0.3 to 4.1.0 +* `#19461 `__: MAINT: Bump hypothesis from 6.14.1 to 6.14.2 +* `#19462 `__: BUILD: move to OpenBLAS 0.3.16 +* `#19463 `__: MAINT: Use straight arm64 in TravisCI. +* `#19468 `__: MAINT: Add missing ``dtype`` overloads for object- and ctypes-based... +* `#19475 `__: DOC: Fix see also references in ``numpy.resize`` +* `#19478 `__: ENH: Vectorizing umath module using AVX-512 (open sourced from... +* `#19479 `__: BLD: Add clang ``-ftrapping-math`` also for ``compiler_so`` +* `#19483 `__: MAINT: Update for using ``openblas64_``. +* `#19485 `__: TST/BENCH: Adding test coverage and benchmarks for floating point... +* `#19486 `__: DOC: Add link to NumPy PDF docs +* `#19491 `__: MAINT: Disable test_blas64_dot. +* `#19492 `__: BUILD: update OpenBLAS to v0.3.17 +* `#19493 `__: TST: generalise ``clip`` test +* `#19498 `__: MAINT: Update manylinux ci test to manylinux2014 +* `#19506 `__: DOC: Fix typos +* `#19512 `__: REL: Update main after 1.21.1 release. +* `#19513 `__: ENH: Add support for windows on arm targets +* `#19516 `__: DOC: Created fundamentals doc for explanations in ``ufunc`` reference... +* `#19517 `__: MAINT: Bump sphinx from 4.1.0 to 4.1.1 +* `#19518 `__: MAINT: Bump hypothesis from 6.14.2 to 6.14.3 +* `#19519 `__: MAINT: Bump cython from 0.29.23 to 0.29.24 +* `#19525 `__: TST: Test that ``numpy.typing`` can be imported in the absence... +* `#19526 `__: MAINT: bump Sphinx in environment.yml file +* `#19527 `__: BLD: Add LoongArch support +* `#19529 `__: SIMD: Force inlining all functions that accept AVX registers +* `#19534 `__: BLD: Tell fortran compiler Cygwin doesn't support rpath. +* `#19535 `__: TST: Add Cygwin to the x86 feature tests. +* `#19538 `__: DOC: Fix typo in PCG64 +* `#19539 `__: DEP: Remove deprecated numeric style dtype strings +* `#19540 `__: MAINT: Update the ``np.finfo`` annotations +* `#19542 `__: TST: Parametrize a few more tests. +* `#19543 `__: MAINT: Improve the ``np.core.numerictypes`` stubs +* `#19545 `__: DOC: Add clarification +* `#19546 `__: DOC: Add link and explanation of ``_add_newdocs`` to developer... +* `#19547 `__: BLD: Use cygpath utility for path conversion in cyg2win32 +* `#19554 `__: MAINT: add missing dunder method to nditer type hints +* `#19557 `__: DOC: clarify doc re: unsupported keys in savez. +* `#19559 `__: ENH: Add annotations for ``__path__`` and ``PytestTester`` +* `#19560 `__: TST: Bump the GitHub actions python 3.10 version +* `#19561 `__: DOC: Remove explicit parameter sparse=False in meshgrid() indexing... +* `#19563 `__: MAINT: Bump hypothesis from 6.14.3 to 6.14.4 +* `#19564 `__: TST: Add "Scaled float" custom DType for testng +* `#19565 `__: DOC: Fix sphinx warnings in c-info.beyond-basics.rst +* `#19566 `__: DOC: Remove ``dot`` docstring in numpy/core/_add_newdocs.py +* `#19567 `__: DOC: Fix Unknown section warning when building docs +* `#19568 `__: BUG: Seed random state in test_vonmises_large_kappa_range. +* `#19571 `__: MAINT: Refactor UFunc core to use NEP 43 style dispatching +* `#19572 `__: MAINT: Cleanup unused function _move_axis_to_0 +* `#19576 `__: MAINT: Make Python3.8 the default for CI testing. +* `#19578 `__: TST: Add basic tests for custom DType (scaled float) ufuncs +* `#19580 `__: ENH: Add basic promoter capability to ufunc dispatching +* `#19582 `__: BLD: load extra flags when checking for libflame +* `#19587 `__: MAINT: Refactor DType slots into an opaque, allocated struct +* `#19590 `__: DOC Fix sphinx warnings related to scope of c:macro. +* `#19593 `__: DOC,MAINT: Update wording surrounding ``fname`` parameter for loadtxt/genfromtxt +* `#19595 `__: MAINT: Bump sphinx from 4.1.1 to 4.1.2 +* `#19596 `__: MAINT: Bump hypothesis from 6.14.4 to 6.14.5 +* `#19598 `__: PERF: Speed-up common case of loadtxt()ing non-hex floats. +* `#19599 `__: PERF: Avoid using ``@recursive``. +* `#19600 `__: BUG: Fix bad write in masked iterator output copy paths +* `#19601 `__: PERF: Speedup comments handling in loadtxt. +* `#19605 `__: DEV: Update default Python in benchmark config. +* `#19607 `__: BUG: Fix NaT handling in the PyArray_CompareFunc for datetime... +* `#19608 `__: PERF: Specialize loadtxt packer for uniform-dtype data. +* `#19609 `__: PERF: In loadtxt, decide once and for all whether decoding is... +* `#19610 `__: PERF: Special-case single-converter in loadtxt. +* `#19612 `__: TST: Bump the python 3.10 test version from beta4 to rc1 +* `#19613 `__: DOC: isclose accepts boolean input +* `#19615 `__: MAINT: Proposal to expire three deprecated functions in numpy.lib.npyio +* `#19616 `__: MAINT: In loadtxt, refactor detection of the number of columns. +* `#19618 `__: MAINT: Optimize loadtxt usecols. +* `#19619 `__: MAINT: Include .coveragerc in source distributions to support... +* `#19620 `__: PERF: Simplify some of loadtxt's standard converters. +* `#19621 `__: BUG: The normal cast-safety for ufunc loops is "no" casting +* `#19622 `__: MAINT: Skip a type check in loadtxt when using user converters. +* `#19627 `__: BUG: Ignore whitespaces while parsing gufunc signatures +* `#19628 `__: TST: avoid distutils.sysconfig in runtests.py +* `#19632 `__: BUG,DEP: Non-default UFunc signature/dtype usage should be deprecated +* `#19633 `__: MAINT: Bump hypothesis from 6.14.5 to 6.14.6 +* `#19638 `__: MAINT: Remove import time compile +* `#19639 `__: MAINT: Update Cython version for Python 3.10. +* `#19640 `__: BUG: Remove logical object ufuncs with bool output +* `#19642 `__: BLD, SIMD: Fix testing extra checks when ``-Werror`` isn't applicable... +* `#19645 `__: DOC: Reorganized the documentation contribution docs +* `#19654 `__: BUG: add base to templated arguments for platlib +* `#19663 `__: NEP: add qualifier for free(), mention ContextVar +* `#19665 `__: MAINT: Drop Python3.7 from supported versions. +* `#19667 `__: ENH: Add annotations for ``np.lib.npyio`` +* `#19672 `__: BLD: update circleCI docker image +* `#19678 `__: REL: Update main after 1.21.2 release. +* `#19680 `__: ENH: Allow ``np.fromregex`` to accept ``os.PathLike`` implementations +* `#19681 `__: MAINT: Update wheel requirement from <0.36.3 to <0.37.1 +* `#19682 `__: MAINT: Bump hypothesis from 6.14.6 to 6.14.7 +* `#19683 `__: ENH: Add annotations for ``np.lib.stride_tricks`` +* `#19686 `__: ENH: Add spaces after punctuation in dtype repr/str. +* `#19692 `__: DOC: Fix trivial doc typo. +* `#19693 `__: MAINT: In loadtxt, inline read_data. +* `#19695 `__: DOC: Fix typo in ``unwrap`` docstring. +* `#19698 `__: DOC: fix typo in example +* `#19702 `__: MAINT: Replace deprecated unittest aliases +* `#19713 `__: MAINT: Replace numpy custom generation engine by raw C++ +* `#19714 `__: MAINT: Remove redundant Python2 float/int conversions +* `#19715 `__: BUG: Casting ``bool_`` to float16 +* `#19725 `__: MAINT: Use a contextmanager to ensure loadtxt closes the input... +* `#19727 `__: DOC: fix basics.creation.rst to address issue 19726 +* `#19730 `__: BUG: Fix reference leak of capi_tmp in f2py/cb_rules.py +* `#19731 `__: BUG: fix time cast-safety for ``factor*unit`` e.g. in ``10**6*ms``... +* `#19732 `__: MAINT: Spelling fixes in documentation +* `#19733 `__: DOC: add citation file for GitHub support +* `#19736 `__: BUG: Fix passing a MaskedArray instance to ``MaskedArray.__setitem__`` +* `#19738 `__: MAINT: Bump hypothesis from 6.14.7 to 6.15.0 +* `#19739 `__: NEP: Update NEP 47: Adopting the array API standard +* `#19742 `__: MAINT: Remove redundant test. +* `#19743 `__: MAINT: Avoid use of confusing compat aliases. +* `#19747 `__: MAINT: Update README.md with badges +* `#19754 `__: ENH: Add clang-format file +* `#19758 `__: MAINT: Remove redundant semicolon +* `#19764 `__: BUG: np.around fails when using doctest +* `#19766 `__: BUG: Remove np.around's footnote [2] +* `#19775 `__: MAINT,DOC: Readability improvements and cleanup for f2py +* `#19776 `__: DOC: Add explanation of a sparse mesh grid +* `#19781 `__: MAINT: refactor "for ... in range(len(" statements +* `#19784 `__: MAINT: Remove typing code-paths specific to Python 3.7 +* `#19789 `__: MAINT: Bump hypothesis from 6.15.0 to 6.17.3 +* `#19791 `__: DOC: Created an explanation document for copies and views +* `#19799 `__: TST: Drop typing-extensions from test_requirements.txt +* `#19800 `__: ENH: Add entry point for Array API implementation +* `#19802 `__: STY: Use the new PEP 457 positional-only syntax for typing +* `#19803 `__: ENH: Add ``is_integer`` to ``np.floating`` & ``np.integer`` +* `#19805 `__: ENH: Symbolic solver for dimension specifications. +* `#19809 `__: MAINT: Fix compiler warnings generated by convert_datatype.h. +* `#19810 `__: MAINT: Minor include rationalizations. +* `#19811 `__: DEP: Deprecate quote_args (from numpy.distutils.misc_util) +* `#19813 `__: DOC: Fix import of default_rng +* `#19814 `__: ENH: Replaced markdown issue templates with issue forms +* `#19815 `__: MAINT: revise OSError aliases (IOError, EnvironmentError) +* `#19817 `__: ENH: Use custom file-like protocols instead of ``typing.IO`` +* `#19818 `__: MAINT: fix unhashable instance and potential exception identified... +* `#19819 `__: MAINT: mark _version.py as generated +* `#19821 `__: BUG: Fixed an issue wherein certain ``nan`` functions could... +* `#19824 `__: MAINT: Small cleanups of includes in *.c files. +* `#19826 `__: MAINT: Standardize guards in numpy/core/include +* `#19827 `__: MAINT: Standardize guards in numpy/core/src/common. +* `#19829 `__: MAINT: Standardize guards in numpy/core/src/multiarray. +* `#19837 `__: MAINT: Bump hypothesis from 6.17.3 to 6.18.0 +* `#19838 `__: MAINT: Bump pytest from 6.2.4 to 6.2.5 +* `#19843 `__: TST: Fix/Improve cast nonstandard bool to numeric test +* `#19844 `__: DOC: Added missing C-API functions +* `#19845 `__: TST: Make nanfunc test ignore overflow instead of xfailing test +* `#19846 `__: MAINT: Update testing to 3.10rc2 +* `#19849 `__: DOC: Fix sentence casing in page titles +* `#19850 `__: Replace posix specific ssize_t with py_ssize_t to compile on... +* `#19854 `__: BUG: Fixed an issue wherein ``var`` would raise for 0d object arrays +* `#19856 `__: MAINT: Mark type-check-only ufunc subclasses as ufunc aliases... +* `#19857 `__: MAINT, ENH: Refactor percentile and quantile methods +* `#19862 `__: DOC: Add BRANCH_WALKTHROUGH +* `#19863 `__: BUG: Fix ``nanpercentile`` ignoring the dtype of all-nan arrays +* `#19864 `__: DOC: Update RELEASE_WALKTHROUGH +* `#19865 `__: DOC: Moved NumPy Internals to Under-the-hood documentation for... +* `#19867 `__: MAINT: Bump hypothesis from 6.18.0 to 6.21.1 +* `#19868 `__: MAINT: Bump sphinx from 4.1.2 to 4.2.0 +* `#19869 `__: BUG: ensure np.median does not drop subclass for NaN result. +* `#19870 `__: DOC: Small fixups for the release walkthrough +* `#19874 `__: DOC: Fix typo in upcoming changes filename +* `#19879 `__: ENH: Add ``__class_getitem__`` to ``ndarray``, ``dtype`` and ``number`` +* `#19882 `__: MAINT: Use SHA-256 instead of SHA-1 +* `#19883 `__: DOC: Fix the reported module names of objects in the ``numpy.typing``... +* `#19884 `__: TST: Make this sysconfig handling a bit more portable +* `#19887 `__: ENH: Add annotations for ``np.linalg`` +* `#19888 `__: BUG: core: Fix *_like strides for str and bytes dtype. +* `#19890 `__: DOC: Added hyperlink on numpy logo in README.md +* `#19893 `__: MAINT,DOC: f2py restructring +* `#19894 `__: ENH: Add a typing protocol for representing nested sequences +* `#19899 `__: DOC: replace return type in np.ma.* docstring +* `#19900 `__: DOC:Fixed refguide errors for basics.creation.rst +* `#19902 `__: BUG,DOC: Ignore upcoming_changes from refguide +* `#19903 `__: DOC: Fixed refguide errors for basics.broadcasting.rst +* `#19905 `__: DOC: fix docstring formatting of polynomial fit method return... +* `#19907 `__: MAINT: Bump hypothesis from 6.21.1 to 6.21.6 +* `#19908 `__: BUG: Check whether an error is already set for invalid casting +* `#19909 `__: MAINT: Re-export ``LinAlgError`` to the ``np.linalg.linalg`` stubs +* `#19911 `__: DOC: Typos found by codespell +* `#19913 `__: MAINT: Fix LGTM.com error: Unmatchable caret in regular expression +* `#19914 `__: MAINT: Fix LGTM.com warning in nditer_imp.h +* `#19915 `__: ENH: Add annotations for ``np.char`` +* `#19916 `__: MAINT: Repair ``make_lite.py`` +* `#19917 `__: ENH: Add annotations for ``np.lib.arraysetops`` +* `#19918 `__: MAINT: Override the modules of ``np.char`` and ``np.rec`` functions +* `#19919 `__: ENH: Create an experimental export of the new DType API +* `#19920 `__: DOC: Fix typos in NEPs, found by codespell +* `#19921 `__: DEP: Use ``delimiter`` rather than ``delimitor`` as kwarg in mrecords +* `#19925 `__: BUG: ufunc: Fix potential memory leak. +* `#19926 `__: BUG: Resolve Divide by Zero on Apple silicon + test failures +* `#19927 `__: BUG: Only call the get_versions() function once on import +* `#19928 `__: MAINT: lib: Check that the dtype given to fromregex is structured. +* `#19929 `__: duplicate item in see also. +* `#19933 `__: MAINT: random: Use expm1 where appropriate. +* `#19934 `__: BUG: core: Fix memory leak in the C function boundarraymethod_repr. +* `#19936 `__: BUG: Make sure __version__ is defined in setup mode +* `#19937 `__: ENH: Updates to numpy.array_api +* `#19939 `__: MAINT: Fix LGTM.com warning: Constant in conditional expression... +* `#19940 `__: MAINT: Fix LGTM.com warning: Variable ``isrec`` defined multiple... +* `#19942 `__: MAINT: Fix LGTM.com warning: Unreachable code +* `#19943 `__: MAINT: Fix LGTM.com warning: Variable ``f`` defined multiple times +* `#19944 `__: MAINT: Fix LGTM.com warning: Comparison result is always the... +* `#19946 `__: MAINT: Fix LGTM.com warning: Comparison result is always the... +* `#19948 `__: MAINT: Add annotations for three missing ``ndarray`` methods +* `#19949 `__: ENH: Add annotations for ``np.rec`` +* `#19951 `__: MAINT: Fix LGTM.com warning: Comparison is always false because... +* `#19953 `__: ENH: Add annotations to ``np.core.multiarray`` part 4/4 +* `#19957 `__: DOC: Add syntax highlighting, update pronouns +* `#19960 `__: DOC: Minor syntax fix for numpydoc warnings +* `#19961 `__: MAINT: Minor cleanups after merging gh-19805 +* `#19962 `__: DOC: Remove overstated TDD evangelism. +* `#19963 `__: DOC: rename ``np.lib.scimath`` to ``np.emath`` +* `#19965 `__: MAINT: Update funding link in FUNDING.yml +* `#19967 `__: DOC: Update basics.io.genfromtxt.rst +* `#19968 `__: ENH: nagfor from NAG is available on Darwin +* `#19969 `__: MAINT: Misc ``np.array_api`` annotation fixes +* `#19972 `__: MAINT: Bump hypothesis from 6.21.6 to 6.23.0 +* `#19974 `__: BUG: np.tan(np.inf) test failure in Apple silicon +* `#19976 `__: DOC Remove reference to ``PyArray_MultiIter_SIZE`` +* `#19977 `__: MAINT: clang-format for f2py +* `#19978 `__: MAINT: Reduce DepreciationWarnings, use more data API types for... +* `#19979 `__: ENH: Add annotations for ``np.memmap`` +* `#19980 `__: ENH: Add the linalg extension to the array_api submodule +* `#19981 `__: DOC: Deindent some sphinx declarations to avoid warnings. +* `#19983 `__: DOC: Specifically mention the C99 requirement in 'Building from... +* `#19984 `__: MAINT: Configure pytest to ignore array_api warnings. +* `#19986 `__: MAINT: Fix LGTM.com warning: Comparison result is always the... +* `#19987 `__: BUG: Remove double cast to char in favor of PyArray_BYTES +* `#19988 `__: DOC: Update links to online copy of Abramowitz and Stegun. +* `#19992 `__: ENH: nagfor - get_flags_linker_so() on darwin +* `#19995 `__: DOC: for new_order parameter, add alias for 'native' order +* `#19997 `__: STY: Harmonize rules with cb_rules for f2py +* `#19999 `__: DOC: Copy-edit and fix typos. +* `#20000 `__: BUG,DEP: Allow (arg-)partition to accept ``uint64`` indices +* `#20002 `__: MAINT: Introduce various linting and misc fixes to ``numpy.typing`` +* `#20003 `__: BLD: updated mypy version from 0.902 to 0.910 +* `#20004 `__: DOC: Fix typos in the random and f2py documentation. +* `#20006 `__: ENH: Add annotations for ``np.lib.function_base`` part 1 +* `#20007 `__: MAINT: Removed the ``cdoc`` directory +* `#20008 `__: BUG: Fix the ``lib.function_base`` window functions ignoring extended... +* `#20010 `__: MAINT: correct linker flags for NAG Fortran compiler +* `#20015 `__: DOC: np.select: use an example that also shows default value +* `#20016 `__: BUG: Add a warning for user dtypes modifying casts after use +* `#20018 `__: ENH: core: More informative error message for broadcast(*args) +* `#20019 `__: MAINT:redundant 'else' statement with 'for' loop#19077 +* `#20026 `__: MAINT: Test PyPy3.8 +* `#20027 `__: ENH: Add missing parameters to the ``nan`` functions +* `#20029 `__: MAINT: Bump pytz from 2021.1 to 2021.3 +* `#20031 `__: MAINT: Bump hypothesis from 6.23.0 to 6.23.1 +* `#20032 `__: MAINT: Bump pytest-cov from 2.12.1 to 3.0.0 +* `#20034 `__: ENH: Add annotations for ``np.lib.function_base`` part 2/3 +* `#20036 `__: ENH: Add annotations for ``np.lib.function_base`` part 3/3 +* `#20037 `__: MAINT: Fixed an issue wherein ``npt._NestedSequence`` was not a... +* `#20040 `__: TST: Add python 3.10 to the CI +* `#20047 `__: DOC:add an example to show flag writeable cleared upon copy related... +* `#20049 `__: BUG: Correct advance in PCG with emulated int128 +* `#20051 `__: DOC:add-html-reference-to-some-ma-methods +* `#20057 `__: MAINT: LGTM.com warnings +* `#20058 `__: MAINT: update OpenBLAS to 0.3.18 +* `#20059 `__: MAINT: LGTM.com recommendations +* `#20060 `__: MAINT: Remove encoding declarations: ``# -*- coding: utf-8 -*-`` +* `#20061 `__: DOC: Remove references to Python 2 +* `#20063 `__: ENH: Add annotations for ``np.lib.histograms`` +* `#20065 `__: ENH: Add annotations for ``np.lib.polynomial`` +* `#20066 `__: MAINT: A few updates to the array_api +* `#20067 `__: MAINT: Use ``Py_SET_TYPE`` macro instead of assigning to ``Py_TYPE`` +* `#20069 `__: BUG: Add workaround for missing ufunc error propagation +* `#20071 `__: MAINT: Remove unused imports and remove duplicated tests +* `#20076 `__: DOC: Document the dtype comparison operations +* `#20084 `__: MAINT: move "git submodule update" earlier in docker creation +* `#20087 `__: BLD: fix submodule update in gitpod.Dockerfile +* `#20088 `__: BUG: core: result_type(0, np.timedelta64(4)) would seg. fault. +* `#20091 `__: DOC: fix typo in docstring of bitwise_or +* `#20094 `__: BUG: AVX-512F log() overflows +* `#20096 `__: MAINT: Bump hypothesis from 6.23.1 to 6.23.2 +* `#20097 `__: MAINT: Bump pycodestyle from 2.7.0 to 2.8.0 +* `#20102 `__: BLD Uses cibuildwheel for linux + osx wheels [cd build] +* `#20104 `__: MAINT: Update F2PY documentation URL +* `#20105 `__: ENH: Add annotations for ``np.matrix`` +* `#20111 `__: DOC: fix minor typo in comment +* `#20115 `__: DOC: Modify code in absolute beginners tutorial to match image +* `#20116 `__: MAINT: Fix issue with C compiler args containing spaces +* `#20119 `__: DOC: Remove double property ctypes from ndarray +* `#20123 `__: DOC: Add note to iterable docstring about 0d arrays. +* `#20129 `__: ENH: Misc typing improvements to ``np.array_api`` +* `#20130 `__: MAINT: Bump hypothesis from 6.23.2 to 6.23.3 +* `#20134 `__: BUG: fix win32 np.clip slowness +* `#20136 `__: BUG: core: Fix incorrect check of NpyIter_Deallocate return value. +* `#20137 `__: DOC:Reword array has one axis +* `#20139 `__: MAINT,BUG: Fix ``ufunc.at`` to use new ufunc API +* `#20142 `__: MAINT: core: Update the comment about _parse_signature with more... +* `#20146 `__: DOC: Updated docstring for floating point rounding +* `#20149 `__: REL: Update main after 1.21.3 release. +* `#20150 `__: BUG: lib: Fix error raised by insert. +* `#20153 `__: BUG, SIMD: Fix 64-bit/8-bit integer division by a scalar +* `#20154 `__: MAINT: Add breathe to environment.yml +* `#20155 `__: BUG: Distutils patch to allow for 2 as a minor version (!) +* `#20156 `__: DOC: Fixed docstring for parameters 2 and -2 on linalg.cond +* `#20159 `__: BUG: Relax homogeneous signature fallback in type resolution +* `#20162 `__: BUG: fixes for MSVC version checks +* `#20163 `__: ENH: Expose promoters and Common-DType API experimentally +* `#20164 `__: MAINT: Remove useless custom tp_alloc and tp_free on ndarray +* `#20165 `__: ENH: Add annotations for ``np.chararray`` +* `#20166 `__: MAINT, STY: Run clang-format on cpp files and headers. +* `#20170 `__: More informative error for unparsable version +* `#20172 `__: Allow clib callable build flags +* `#20173 `__: TST: Disable test_partial_iteration_cleanup on 32 bit Windows. +* `#20174 `__: TST: xfail ``test_overrides`` when numpy is built with MKL support +* `#20179 `__: BUG: Do not use nonzero fastpath on unaligned arrays +* `#20182 `__: DOC, MAINT: Update build systems for f2py +* `#20183 `__: Thin compatibility layer for C/C++ math header +* `#20184 `__: MAINT: Miscellaneous typing cleanups +* `#20187 `__: BUG,DOC: Resolve a refguide failure for ``ndarray.__class_getitem__`` +* `#20188 `__: MAINT: Bump hypothesis from 6.23.3 to 6.24.0 +* `#20190 `__: BUG: Don't pass /arch:SSE2 to MSVC when targeting x64 +* `#20194 `__: DOC: add release note and move NEP 49 to Final +* `#20195 `__: DOC: Two small changes in array.rst: +* `#20196 `__: Fix minor grammar issues in docs +* `#20197 `__: DOC, MAINT : fixing typo in numpy doc +* `#20199 `__: ENH: Add dtype typing support to ``np.core.numeric`` +* `#20200 `__: MAINT: Only warn for transferred ownership if env variable is... +* `#20201 `__: DEP: Deprecate ``np.MachAr`` +* `#20205 `__: BUG,DOC: Fix ``random.power``'s error description +* `#20206 `__: CI: Add new workflow/action for testing universal intrinsics... +* `#20207 `__: ENH: Add prompt for title in issue forms +* `#20213 `__: DOC: Mention ``nan`` results in ``power`` and ``float_power``. +* `#20214 `__: BUG: fix test c-extension compilation inside a venv +* `#20217 `__: DOC: Add a release note for fully annotating the main numpy namespace +* `#20219 `__: BUG, SIMD: Workaround broadcasting SIMD 64-bit integers on MSVC... +* `#20222 `__: Run rebase on Cygwin CI +* `#20224 `__: BUG: Fix shadowed reference of ``dtype`` in type stubs +* `#20228 `__: MAINT: Better error message from histogram2d +* `#20230 `__: ENH: Add annotations for ``np.ctypeslib`` +* `#20232 `__: CI: Add new workflow for Intel SDE +* `#20234 `__: MAINT: Update vs2017 to vs2019. +* `#20235 `__: DOC: fix typo in example, put the return statement inside the... +* `#20237 `__: BUG: ``VOID_nonzero`` could sometimes mutate alignment flag +* `#20238 `__: BUG: Fix environment checking logic for ``NUMPY_WARN_IF_NO_MEM_POLICY`` +* `#20242 `__: DOC: centralized min-max documentation +* `#20243 `__: DOC: Fixes wording for fmod and remainder functions. +* `#20255 `__: DOC: fix missing link in "What is NumPy?" to broadcasting +* `#20256 `__: The module name in the reshape section of the absolute_beginners.html... +* `#20261 `__: [DOC] Fix math block in hermmulx, lagmulx +* `#20267 `__: Adding Examples to numpy.roll() +* `#20268 `__: MAINT: remove Dependabot +* `#20269 `__: MAINT: Bump hypothesis from 6.24.0 to 6.24.1 +* `#20270 `__: BUG: Fix headers for universal2 builds +* `#20271 `__: TST: Add a test for device property +* `#20274 `__: TST: Some fixes & refactoring around glibc-dependent skips in... +* `#20279 `__: ENH: Add annotations for ``np.fft`` +* `#20281 `__: DOC: Correct grammar in isfinite docstring +* `#20282 `__: MAINT: Fix runtests.py overriding $PYTHONPATH environment variable +* `#20283 `__: MAINT Fix typo for event name in wheels.yml +* `#20284 `__: BUG: Fix duplication of names in 'numpy.__all__'. +* `#20287 `__: TST, MAINT: module name excluded in typing tests +* `#20290 `__: DOC: Do not leave space between directive name and double colon. +* `#20292 `__: SIMD: replace raw SIMD of ceil with universal intrinsics +* `#20299 `__: BLD: in conda, pin setuptools to a known working version +* `#20303 `__: BUG: Fix requirement that user DTypes had to be heaptypes +* `#20307 `__: REL: Update main after 1.21.4 release. +* `#20308 `__: MAINT: Add ``IS_PYSTON`` to ``np.testing.__all__`` +* `#20309 `__: MAINT: Add annotations for a missing ``percentile`` interpolation... +* `#20310 `__: BUG: Fix float16 einsum fastpaths using wrong tempvar +* `#20314 `__: BUG: Get full precision for 32 bit floating point random values. +* `#20315 `__: MAINT: Remove Python <3.8 support from C +* `#20318 `__: MAINT: Remove codeql-analysis.yml. +* `#20325 `__: DOC: Remove non-existent quantile ``interpolation="inclusive"``... +* `#20327 `__: BUG,DEP: Fixup quantile/percentile and rename interpolation->method +* `#20331 `__: MAINT: Update quantile default lerp method +* `#20333 `__: DEP: remove code for supporting GCC <4 in Mingw32CCompiler +* `#20334 `__: MAINT: Rename commit trigger to "wheel build" for building wheels +* `#20342 `__: CI: Bump azure MacOS version to macOS-1015 +* `#20343 `__: ENH: add a 'version' field to PyDataMem_Handler +* `#20344 `__: BLD: do not position 'cxx=-std=c++11' as a default compiler flag +* `#20345 `__: ENH: Avoid re-encapsulation of the default handler +* `#20347 `__: MAINT: Do not forward ``__(deep)copy__`` calls of ``_GenericAlias``... +* `#20350 `__: DOC: random: Fix a mistake in the zipf example. +* `#20352 `__: ENH: Prefix log messages with their levels +* `#20353 `__: BUG, DIST: Print os error message when the executable not exist +* `#20354 `__: BLD: Verify the ability to compile C++ sources before initiating... +* `#20360 `__: BUG: Revert from ``long double`` changes, and force ``npymath`` to... +* `#20361 `__: MAINT: Update SVML sources to prevent an executable stack +* `#20364 `__: BUG: Relax unary ufunc (sqrt, etc.) stride assert +* `#20365 `__: BUG: Fix failure to create aligned, empty structured dtype +* `#20366 `__: MAINT,TST: Avoid small positive integers in refcount test +* `#20367 `__: ENH, SIMD: add new universal intrinsics for trunc +* `#20369 `__: MAINT: Fix newlines in diagnostics output of numpy.f2py. +* `#20373 `__: MAINT: Prepare for branching maintenance/1.22.x +* `#20379 `__: DOC: Fix formatting of a code example in ``numpy.random.Generator.multivariate_normal()``... +* `#20386 `__: REV: Add MaskedArray creation from non nd-array back in +* `#20402 `__: BLD: Fix Macos Builds [wheel build] +* `#20410 `__: BUG, SIMD: Fix ``exp`` FP stack overflow when ``AVX512_SKX`` is enabled +* `#20411 `__: ENH: provide a convenience function to replace npy_load_module... +* `#20415 `__: CI: CircleCI: Install numpy after processing doc_requirements.txt +* `#20419 `__: MAINT: import setuptools before distutils in one np.random test +* `#20420 `__: BUG: Clear errors correctly in F2PY conversions +* `#20429 `__: MAINT: Fix longdouble precision check in test_umath.py +* `#20430 `__: MAINT: Fix METH_NOARGS function signatures +* `#20434 `__: REL: Prepare for the NumPy 1.22.0r1 release. +* `#20436 `__: BUG: Fix an incorrect protocol used in ``np.lib.shape_base`` +* `#20473 `__: BUG: Fix two overload-related problems +* `#20474 `__: TST: remove obsolete TestF77Mismatch +* `#20475 `__: MAINT: Update the required setuptools version. +* `#20476 `__: BUG: Restore support for i386 and PowerPC (OS X) +* `#20487 `__: MAINT: update wheel to version that supports python3.10 +* `#20496 `__: TST: use pypy3.8-v7.3.7 final versions +* `#20502 `__: BUG: Fix the .T attribute in the array_api namespace +* `#20503 `__: BUG: Protect divide by 0 in multinomial distribution. +* `#20535 `__: BUG: Fix reduce promotion with out argument +* `#20538 `__: BUG: Fix handling of the dtype parameter to numpy.array_api.prod() +* `#20539 `__: PERF: Fix performance bug in dispatching cache +* `#20541 `__: REL: Prepare for NumPy 1.22.0rc2 release. +* `#20548 `__: REV: Revert adding a default ufunc promoter +* `#20576 `__: BUG: Fix small issues found using valgrind +* `#20577 `__: BUG: Fix sorting of int8/int16 +* `#20578 `__: ENH: Add ``__array__`` to the array_api Array object +* `#20579 `__: MAINT: make sure CI stays on VS2019 unless changed explicitly +* `#20585 `__: DOC: Update front page of documentation with Sphinx-Panels +* `#20598 `__: BUG: Fix issues (mainly) found using pytest-leaks +* `#20599 `__: MAINT: Fix two minor typing-related problems +* `#20600 `__: BUG: Fix leaks found using pytest-leaks +* `#20601 `__: MAINT: Check for buffer interface support rather than try/except +* `#20602 `__: BUG: Fix PyInit__umath_linalg type +* `#20605 `__: DEV: add a warningfilter to fix pytest workflow. +* `#20614 `__: TST: Bump mypy: 0.910 -> 0.920 +* `#20617 `__: MAINT: Help boost::python libraries at least not crash +* `#20632 `__: DOC: Document implementation of NEP 43 and experimental new DType... +* `#20649 `__: DOC: Modify SVG to be visible on Chrome +* `#20650 `__: BUG: Support env argument in CCompiler.spawn +* `#20651 `__: BUG: f2py: Simplify creation of an exception message. +* `#20680 `__: TYP,TST: Bump mypy to 0.930 +* `#20681 `__: BUG: Fix setstate logic for empty arrays +* `#20682 `__: ENH: Add ARM Compiler with ARM Performance Library support diff --git a/doc/changelog/1.22.1-changelog.rst b/doc/changelog/1.22.1-changelog.rst new file mode 100644 index 000000000000..3b401c1d2bc5 --- /dev/null +++ b/doc/changelog/1.22.1-changelog.rst @@ -0,0 +1,47 @@ + +Contributors +============ + +A total of 14 people contributed to this release. People with a "+" by their +names contributed a patch for the first time. + +* Arryan Singh +* Bas van Beek +* Charles Harris +* Denis Laxalde +* Isuru Fernando +* Kevin Sheppard +* Matthew Barber +* Matti Picus +* Melissa Weber Mendonça +* Mukulika Pahari +* Omid Rajaei + +* Pearu Peterson +* Ralf Gommers +* Sebastian Berg + +Pull requests merged +==================== + +A total of 20 pull requests were merged for this release. + +* `#20702 `__: MAINT, DOC: Post 1.22.0 release fixes. +* `#20703 `__: DOC, BUG: Use pngs instead of svgs. +* `#20704 `__: DOC:Fixed the link on user-guide landing page +* `#20714 `__: BUG: Restore vc141 support +* `#20724 `__: BUG: Fix array dimensions solver for multidimensional arguments... +* `#20725 `__: TYP: change type annotation for `__array_namespace__` to ModuleType +* `#20726 `__: TYP, MAINT: Allow `ndindex` to accept integer tuples +* `#20757 `__: BUG: Relax dtype identity check in reductions +* `#20763 `__: TYP: Allow time manipulation functions to accept `date` and `timedelta`... +* `#20768 `__: TYP: Relax the type of `ndarray.__array_finalize__` +* `#20795 `__: MAINT: Raise RuntimeError if setuptools version is too recent. +* `#20796 `__: BUG, DOC: Fixes SciPy docs build warnings +* `#20797 `__: DOC: fix OpenBLAS version in release note +* `#20798 `__: PERF: Optimize array check for bounded 0,1 values +* `#20805 `__: BUG: Fix that reduce-likes honor out always (and live in the... +* `#20806 `__: BUG: ``array_api.argsort(descending=True)`` respects relative... +* `#20807 `__: BUG: Allow integer inputs for pow-related functions in `array_api` +* `#20814 `__: DOC: Refer to NumPy, not pandas, in main page +* `#20815 `__: DOC: Update Copyright to 2022 [License] +* `#20819 `__: BUG: Return correctly shaped inverse indices in array_api set... diff --git a/doc/changelog/1.22.2-changelog.rst b/doc/changelog/1.22.2-changelog.rst new file mode 100644 index 000000000000..067ee2638720 --- /dev/null +++ b/doc/changelog/1.22.2-changelog.rst @@ -0,0 +1,48 @@ + +Contributors +============ + +A total of 14 people contributed to this release. People with a "+" by their +names contributed a patch for the first time. + +* Andrew J. Hesford + +* Bas van Beek +* Brénainn Woodsend + +* Charles Harris +* Hood Chatham +* Janus Heide + +* Leo Singer +* Matti Picus +* Mukulika Pahari +* Niyas Sait +* Pearu Peterson +* Ralf Gommers +* Sebastian Berg +* Serge Guelton + +Pull requests merged +==================== + +A total of 21 pull requests were merged for this release. + +* `#20842 `__: BLD: Add NPY_DISABLE_SVML env var to opt out of SVML +* `#20843 `__: BUG: Fix build of third party extensions with Py_LIMITED_API +* `#20844 `__: TYP: Fix pyright being unable to infer the ``real`` and ``imag``... +* `#20845 `__: BUG: Fix comparator function signatures +* `#20906 `__: BUG: Avoid importing ``numpy.distutils`` on import numpy.testing +* `#20907 `__: MAINT: remove outdated mingw32 fseek support +* `#20908 `__: TYP: Relax the return type of ``np.vectorize`` +* `#20909 `__: BUG: fix f2py's define for threading when building with Mingw +* `#20910 `__: BUG: distutils: fix building mixed C/Fortran extensions +* `#20912 `__: DOC,TST: Fix Pandas code example as per new release +* `#20935 `__: TYP, MAINT: Add annotations for ``flatiter.__setitem__`` +* `#20936 `__: MAINT, TYP: Added missing where typehints in ``fromnumeric.pyi`` +* `#20937 `__: BUG: Fix build_ext interaction with non numpy extensions +* `#20938 `__: BUG: Fix missing intrinsics for windows/arm64 target +* `#20945 `__: REL: Prepare for the NumPy 1.22.2 release. +* `#20982 `__: MAINT: f2py: don't generate code that triggers ``-Wsometimes-uninitialized``. +* `#20983 `__: BUG: Fix incorrect return type in reduce without initial value +* `#20984 `__: ENH: review return values for PyArray_DescrNew +* `#20985 `__: MAINT: be more tolerant of setuptools >= 60 +* `#20986 `__: BUG: Fix misplaced return. +* `#20992 `__: MAINT: Further small return value validation fixes diff --git a/doc/changelog/1.22.3-changelog.rst b/doc/changelog/1.22.3-changelog.rst new file mode 100644 index 000000000000..051e5665b231 --- /dev/null +++ b/doc/changelog/1.22.3-changelog.rst @@ -0,0 +1,32 @@ + +Contributors +============ + +A total of 9 people contributed to this release. People with a "+" by their +names contributed a patch for the first time. + +* @GalaxySnail + +* Alexandre de Siqueira +* Bas van Beek +* Charles Harris +* Melissa Weber Mendonça +* Ross Barnowski +* Sebastian Berg +* Tirth Patel +* Matthieu Darbois + +Pull requests merged +==================== + +A total of 10 pull requests were merged for this release. + +* `#21048 `__: MAINT: Use "3.10" instead of "3.10-dev" on travis. +* `#21106 `__: TYP,MAINT: Explicitly allow sequences of array-likes in ``np.concatenate`` +* `#21137 `__: BLD,DOC: skip broken ipython 8.1.0 +* `#21138 `__: BUG, ENH: np._from_dlpack: export correct device information +* `#21139 `__: BUG: Fix numba DUFuncs added loops getting picked up +* `#21140 `__: BUG: Fix unpickling an empty ndarray with a non-zero dimension... +* `#21141 `__: BUG: use ThreadPoolExecutor instead of ThreadPool +* `#21142 `__: API: Disallow strings in logical ufuncs +* `#21143 `__: MAINT, DOC: Fix SciPy intersphinx link +* `#21148 `__: BUG,ENH: np._from_dlpack: export arrays with any strided size-1... diff --git a/doc/changelog/1.22.4-changelog.rst b/doc/changelog/1.22.4-changelog.rst new file mode 100644 index 000000000000..0f3e54ebb71b --- /dev/null +++ b/doc/changelog/1.22.4-changelog.rst @@ -0,0 +1,47 @@ + +Contributors +============ + +A total of 12 people contributed to this release. People with a "+" by their +names contributed a patch for the first time. + +* Alexander Shadchin +* Bas van Beek +* Charles Harris +* Hood Chatham +* Jarrod Millman +* John-Mark Gurney + +* Junyan Ou + +* Mariusz Felisiak + +* Ross Barnowski +* Sebastian Berg +* Serge Guelton +* Stefan van der Walt + +Pull requests merged +==================== + +A total of 22 pull requests were merged for this release. + +* `#21191 `__: TYP, BUG: Fix ``np.lib.stride_tricks`` re-exported under the... +* `#21192 `__: TST: Bump mypy from 0.931 to 0.940 +* `#21243 `__: MAINT: Explicitly re-export the types in ``numpy._typing`` +* `#21245 `__: MAINT: Specify sphinx, numpydoc versions for CI doc builds +* `#21275 `__: BUG: Fix typos +* `#21277 `__: ENH, BLD: Fix math feature detection for wasm +* `#21350 `__: MAINT: Fix failing simd and cygwin tests. +* `#21438 `__: MAINT: Fix failing Python 3.8 32-bit Windows test. +* `#21444 `__: BUG: add linux guard per #21386 +* `#21445 `__: BUG: Allow legacy dtypes to cast to datetime again +* `#21446 `__: BUG: Make mmap handling safer in frombuffer +* `#21447 `__: BUG: Stop using PyBytesObject.ob_shash deprecated in Python 3.11. +* `#21448 `__: ENH: Introduce numpy.core.setup_common.NPY_CXX_FLAGS +* `#21472 `__: BUG: Ensure compile errors are raised correclty +* `#21473 `__: BUG: Fix segmentation fault +* `#21474 `__: MAINT: Update doc requirements +* `#21475 `__: MAINT: Mark ``npy_memchr`` with ``no_sanitize("alignment")`` on clang +* `#21512 `__: DOC: Proposal - make the doc landing page cards more similar... +* `#21525 `__: MAINT: Update Cython version to 0.29.30. +* `#21536 `__: BUG: Fix GCC error during build configuration +* `#21541 `__: REL: Prepare for the NumPy 1.22.4 release. +* `#21547 `__: MAINT: Skip tests that fail on PyPy. diff --git a/doc/changelog/1.23.0-changelog.rst b/doc/changelog/1.23.0-changelog.rst new file mode 100644 index 000000000000..3ff0dcfd5bb3 --- /dev/null +++ b/doc/changelog/1.23.0-changelog.rst @@ -0,0 +1,660 @@ + +Contributors +============ + +A total of 151 people contributed to this release. People with a "+" by their +names contributed a patch for the first time. + +* @DWesl +* @GalaxySnail + +* @code-review-doctor + +* @h-vetinari +* Aaron Meurer +* Alexander Shadchin +* Alexandre de Siqueira +* Allan Haldane +* Amrit Krishnan +* Andrei Batomunkuev +* Andrew J. Hesford + +* Andrew Murray + +* Andrey Andreyevich Bienkowski + +* André Elimelek de Weber + +* Andy Wharton + +* Arryan Singh +* Arushi Sharma +* Bas van Beek +* Bharat Raghunathan +* Bhavuk Kalra + +* Brigitta Sipőcz +* Brénainn Woodsend + +* Burlen Loring + +* Caio Agiani + +* Charles Harris +* Chiara Marmo +* Cornelius Roemer + +* Dahyun Kim + +* Damien Caliste +* David Prosin + +* Denis Laxalde +* Developer-Ecosystem-Engineering +* Devin Shanahan + +* Diego Wang + +* Dimitri Papadopoulos Orfanos +* Ding Liu + +* Diwakar Gupta + +* Don Kirkby + +* Emma Simon + +* Eric Wieser +* Evan Miller + +* Evgeni Burovski +* Evgeny Posenitskiy + +* Ewout ter Hoeven + +* Felix Divo +* Francesco Andreuzzi + +* Ganesh Kathiresan +* Gaëtan de Menten +* Geoffrey Gunter + +* Hans Meine +* Harsh Mishra + +* Henry Schreiner +* Hood Chatham + +* I-Shen Leong +* Ilhan Polat +* Inessa Pawson +* Isuru Fernando +* Ivan Gonzalez + +* Ivan Meleshko + +* Ivan Yashchuk + +* Janus Heide + +* Jarrod Millman +* Jason Thai + +* Jeremy Volkman + +* Jesús Carrete Montaña + +* Jhong-Ken Chen (陳仲肯) + +* John Kirkham +* John-Mark Gurney + +* Jonathan Deng + +* Joseph Fox-Rabinovitz +* Jouke Witteveen + +* Junyan Ou + +* Jérôme Richard + +* Kassian Sun + +* Kazuki Sakamoto + +* Kenichi Maehashi +* Kevin Sheppard +* Kilian Lieret + +* Kushal Beniwal + +* Leo Singer +* Logan Thomas + +* Lorenzo Mammana + +* Margret Pax +* Mariusz Felisiak + +* Markus Mohrhard + +* Mars Lee +* Marten van Kerkwijk +* Masamichi Hosoda + +* Matthew Barber +* Matthew Brett +* Matthias Bussonnier +* Matthieu Darbois +* Matti Picus +* Melissa Weber Mendonça +* Michael Burkhart + +* Morteza Mirzai + +* Motahhar Mokf + +* Muataz Attaia + +* Muhammad Motawe + +* Mukulika Pahari +* Márton Gunyhó + +* Namami Shanker + +* Nihaal Sangha + +* Niyas Sait +* Omid Rajaei + +* Oscar Gustafsson + +* Ovee Jawdekar + +* P. L. Lim + +* Pamphile Roy + +* Pantelis Antonoudiou + +* Pearu Peterson +* Peter Andreas Entschev +* Peter Hawkins +* Pierre de Buyl +* Pieter Eendebak + +* Pradipta Ghosh + +* Rafael Cardoso Fernandes Sousa + +* Raghuveer Devulapalli +* Ralf Gommers +* Raphael Kruse +* Raúl Montón Pinillos +* Robert Kern +* Rohit Goswami +* Ross Barnowski +* Ruben Garcia + +* Sadie Louise Bartholomew + +* Saswat Das + +* Sayed Adel +* Sebastian Berg +* Serge Guelton +* Simon Surland Andersen + +* Siyabend Ürün + +* Somasree Majumder + +* Soumya + +* Stefan van der Walt +* Stefano Miccoli + +* Stephan Hoyer +* Stephen Worsley + +* Tania Allard +* Thomas Duvernay + +* Thomas Green + +* Thomas J. Fan +* Thomas Li + +* Tim Hoffmann +* Ting Sun + +* Tirth Patel +* Toshiki Kataoka +* Tyler Reddy +* Warren Weckesser +* Yang Hau +* Yoon, Jee Seok + + +Pull requests merged +==================== + +A total of 494 pull requests were merged for this release. + +* `#15006 `__: ENH: add support for operator() in crackfortran. +* `#15844 `__: ENH: add inline definition of access rights for Fortran types +* `#16810 `__: MAINT: Remove subclass paths from scalar_value +* `#16830 `__: MAINT: more python <3.6 cleanup +* `#16895 `__: MAINT: extend delete single value optimization +* `#17709 `__: BUG: Fix norm type promotion +* `#18343 `__: DOC: document how to skip CI jobs +* `#18846 `__: DOC: Improve documentation of default int type on windows +* `#19226 `__: API: Fix structured dtype cast-safety, promotion, and comparison +* `#19345 `__: ENH: Move ``ensure_dtype_nbo`` onto the DType as ``ensure_canonical`` +* `#19346 `__: API: Fix ``np.result_type(structured_dtype)`` to "canonicalize" +* `#19581 `__: DOC: Improve SIMD documentation(1/4) +* `#19756 `__: DOC: Update front page of documentation with Sphinx-Panels +* `#19898 `__: DOC: Fixed Refguide errors +* `#20020 `__: ENH: add ndenumerate specialization for masked arrays +* `#20093 `__: DOC: Created an indexing how-to +* `#20131 `__: BUG: min/max is slow, re-implement using NEON (#17989) +* `#20133 `__: ENH: Vectorize quicksort for 32-bit dtype using AVX-512 +* `#20140 `__: DOC: Fix some target not found sphinx warnings. +* `#20147 `__: DOC: updated docstring for binary file object +* `#20175 `__: ENH: Optimize ``np.empty`` for scalar arguments +* `#20176 `__: MAINT: Use intp output param viewable casts/methods +* `#20185 `__: DOC: Added explanation document on interoperability +* `#20244 `__: DOC: Clarify behavior of ``np.lib.scimath.sqrt`` apropos -0.0 +* `#20246 `__: DOC: Merge doc strings of divide and true_divide. +* `#20285 `__: ENH, SIMD: add new universal intrinsics for floor/rint +* `#20288 `__: DOC: make some doctests in user,reference pass pytest +* `#20311 `__: DOC: Windows and F2PY +* `#20363 `__: SIMD: Replace SVML/ASM of tanh(f32, f64) with universal intrinsics +* `#20368 `__: MAINT: Fix METH_NOARGS function signatures +* `#20380 `__: DOC: random: Fix a comment and example in the multivariate_normal... +* `#20383 `__: BLD: Try making 64-bit Windows wheels +* `#20387 `__: REL: Prepare main for NumPy 1.23.0 development +* `#20388 `__: Update ARM cpu_asimdfhm.c check +* `#20389 `__: MAINT: Raise different type of errors +* `#20393 `__: CI: CircleCI: Install numpy after processing doc_requirements.txt +* `#20394 `__: DEP: remove allocation_tracking, deprecate PyDataMem_SetEventHook +* `#20395 `__: ENH: provide a convenience function to replace npy_load_module +* `#20396 `__: DOC: np.fromfunction documentation not clear +* `#20397 `__: SIMD: replace raw AVX512 of floor/trunc/rint with universal intrinsics +* `#20398 `__: BLD: Fix Macos Builds [wheel build] +* `#20399 `__: DOC: Docstring improvements in the context of np.shape +* `#20403 `__: CI: CircleCI: Install numpy after processing doc_requirements.txt +* `#20404 `__: BUG: Clear errors correctly in F2PY conversions +* `#20405 `__: BUG, SIMD: Fix ``exp`` FP stack overflow when ``AVX512_SKX`` is enabled +* `#20407 `__: DOC: Update axis parameter for np.ma.{min,max} +* `#20409 `__: MAINT: import setuptools before distutils in one ``np.random``... +* `#20412 `__: MAINT: Fix METH_NOARGS function signatures (#20368) +* `#20413 `__: DOC: correct the versionadded number for ``f2py.get_include`` +* `#20414 `__: DEP: remove deprecated ``alen`` and ``asscalar`` functions +* `#20416 `__: ENH: Add ARM Compiler with ARM Performance Library support +* `#20417 `__: BLD: Add macOS arm64 wheels [wheel build] +* `#20422 `__: BUG: Restore support for i386 and PowerPC (OS X) +* `#20427 `__: MAINT: Fix longdouble precision check in test_umath.py +* `#20432 `__: ENH: Add annotations for ``np.emath`` +* `#20433 `__: BUG: Fix an incorrect protocol used in ``np.lib.shape_base`` +* `#20435 `__: DOC: nicer CMake example in the f2py docs +* `#20437 `__: DOC: Fix a typo in docstring of MT19937 +* `#20443 `__: DOC: get scikit-build example working +* `#20446 `__: BUG: Fixed output variable overriding in numpy.info() +* `#20447 `__: DOC: use FindPython instead of FindPython3 +* `#20452 `__: MAINT: Update the required setuptools version. +* `#20457 `__: TST: remove obsolete TestF77Mismatch +* `#20468 `__: BUG: Fix two overload-related problems +* `#20470 `__: ENH: Add dtype-typing support to ``np.core.function_base`` +* `#20471 `__: Rename _operand_flag_tests.c.src into numpy/core/src/umath/_operand_f… +* `#20478 `__: TST,MAINT: F2PY test typo +* `#20479 `__: TST,STY: Clean up F2PY tests for pathlib.Path +* `#20482 `__: BUG: Fix tensorsolve for 0-sized input +* `#20484 `__: BUG: Fix reduce promotion with out argument +* `#20486 `__: MAINT: update wheel to version that supports python3.10 +* `#20489 `__: MAINT: Translate binsearch.c.src to C++ using templates. +* `#20490 `__: BUG: Protect divide by 0 in multinomial distribution. +* `#20491 `__: TEST: use pypy3.8-v7.3.7 final versions +* `#20499 `__: BUG: Fix the .T attribute in the array_api namespace +* `#20500 `__: ENH: add ndmin to ``genfromtxt`` behaving the same as ``loadtxt`` +* `#20505 `__: BUG: fix ``ma.average`` not working well with ``nan`` weights +* `#20509 `__: DOC: Adds valgrind to the test command +* `#20515 `__: ENH: Generate the docstrings of umath into a separate C header +* `#20516 `__: DOC: Add more details on F2PY output conditions +* `#20517 `__: MAINT,TST: Refactor F2PY testsuite +* `#20518 `__: PERF: Fix performance bug in ufunc dispatching cache +* `#20521 `__: MAINT: Pin OS versions when building wheels [wheel build] +* `#20524 `__: CI: make sure CI stays on VS2019 unless changed explicitly +* `#20527 `__: ENH: Add __array__ to the array_api Array object +* `#20528 `__: BLD: Add PyPy wheels [wheel build] +* `#20533 `__: BUG: Fix handling of the dtype parameter to numpy.array_api.prod() +* `#20547 `__: REV: Revert adding a default ufunc promoter +* `#20552 `__: ENH: Extending CPU feature detection framework to support IBM... +* `#20553 `__: BLD: Use the new hypotl on Cygwin, rather than defaulting to... +* `#20556 `__: DOC: Update links to mailing list on python.org +* `#20558 `__: TST: move get_glibc_version to np.testing; skip 2 more tests... +* `#20559 `__: DOC: Refactoring f2py user guide +* `#20563 `__: BUG: Fix small issues found using valgrind +* `#20565 `__: REF: Clean up wheels workflow [wheel build] +* `#20569 `__: BUG: Fix sorting of int8/int16 +* `#20571 `__: DOC: fix typo +* `#20572 `__: DOC: Adds link to NEP 43 from NEP 41 +* `#20580 `__: ENH: Move ``loadtxt`` to C for much better speed +* `#20583 `__: BUG: Fix issues (mainly) found using pytest-leaks +* `#20587 `__: MAINT: Fix two minor typing-related problems +* `#20588 `__: BUG, DIST: fix normalize IBMZ features flags +* `#20589 `__: DEP: remove NPY_ARRAY_UPDATEIFCOPY, deprecated in 1.14 +* `#20590 `__: BUG: Fix leaks found using pytest-leaks +* `#20591 `__: removed two redundant '\\' typos +* `#20592 `__: BUG: Reject buffers with suboffsets +* `#20593 `__: MAINT: Check for buffer interface support rather than try/except +* `#20594 `__: BUG: Fix setstate logic for empty arrays +* `#20595 `__: BUG: Fix PyInit__umath_linalg type +* `#20604 `__: DEV: add a warningfilter to fix pytest workflow. +* `#20607 `__: BUG: Protect kahan_sum from empty arrays +* `#20611 `__: TST: Bump mypy: 0.910 -> 0.920 +* `#20616 `__: MAINT: Help boost::python libraries at least not crash +* `#20621 `__: BUG: random: Check 'writeable' flag in 'shuffle' and 'permuted'. +* `#20622 `__: BLD: Add Windows 32-bit wheels +* `#20624 `__: BUILD: pin to cython 0.29.24 to hide PyPy3.8 bug +* `#20628 `__: REL: Update main after 1.21.5 release. +* `#20629 `__: DOC: Refer to NumPy, not pandas, in main page +* `#20630 `__: BUG: f2py: Simplify creation of an exception message. +* `#20640 `__: BUG: Support env argument in CCompiler.spawn +* `#20641 `__: PERF: Speed up check_constraint checks +* `#20643 `__: PERF: Optimize array check for bounded 0,1 values +* `#20646 `__: DOC: add np.iterable to reference guide +* `#20647 `__: DOC: Add PyArray_FailUnlessWriteable to the online C-API docs. +* `#20648 `__: DOC: Modify SVGs to be visible on Chrome +* `#20652 `__: STY: Use PEP 585 and 604 syntaxes throughout the .pyi stub files +* `#20653 `__: DEV: Add ``TYP``, a standard acronym for static typing +* `#20654 `__: CI: Find cygwin test failures +* `#20660 `__: MAINT: update OpenBLAS to 0.3.19 +* `#20663 `__: TYP,TST: Bump mypy to 0.930 +* `#20666 `__: DOC: Add help string for F2PY +* `#20668 `__: TST: Initialize f2py2e tests of the F2PY CLI +* `#20669 `__: CI, TST: Run Cygwin CI with Netlib reference BLAS and re-enable... +* `#20672 `__: DOC: add hypothesis test dependency in README and PyPI long-description +* `#20674 `__: BUG: array interface PyCapsule reference +* `#20678 `__: BUG: Remove trailing dec point in dragon4positional +* `#20683 `__: DOC: Updated pointer spacing for consistency. +* `#20689 `__: BUG: Added check for NULL data in ufuncs +* `#20691 `__: DOC, ENH: Added pngs for svgs for pdf build +* `#20693 `__: DOC: Replaced svgs with pngs in the Broadcasting doc +* `#20695 `__: BLD: Add NPY_DISABLE_SVML env var to opt out of SVML +* `#20697 `__: REL: Update main after 1.22.0 release. +* `#20698 `__: DOC:Fixed the link on user-guide landing page +* `#20701 `__: MAINT, DOC: Post 1.22.0 release fixes. +* `#20708 `__: DOC: fix broken documentation references in mtrand.pyx +* `#20710 `__: TYP: Allow ``ndindex`` to accept integer tuples +* `#20712 `__: BUG: Restore vc141 support +* `#20713 `__: DOC: Add Code of Conduct to README.md +* `#20719 `__: TYP: change type annotation for ``__array_namespace__`` to ModuleType +* `#20720 `__: TYP: add a few type annotations to ``numpy.array_api.Array`` +* `#20721 `__: BUG: Fix array dimensions solver for multidimensional arguments... +* `#20722 `__: ENH: Removed requirement for C-contiguity when changing to dtype... +* `#20727 `__: DOC: Update README.md mainly to include link to website +* `#20729 `__: BUG: Relax dtype identity check in reductions +* `#20730 `__: DOC: Document that dtype, strides, shape attributes should not... +* `#20731 `__: DOC: fix OpenBLAS version in release note +* `#20732 `__: MAINT: Translate timsort.c.src to C++ using templates. +* `#20738 `__: ENH: fix a typo in the example trigger for wheels +* `#20740 `__: Update teams URL +* `#20741 `__: DOC: add instructions for cross compilation +* `#20745 `__: ENH: add hook and test for PyInstaller. +* `#20747 `__: BLD: Upload wheel artifacts separately [wheel build] +* `#20750 `__: TYP: Allow time manipulation functions to accept ``date`` and ``timedelta``... +* `#20754 `__: MAINT: Relax asserts to match relaxed reducelike resolution behaviour +* `#20758 `__: DOC: Capitalization and missing word in docs +* `#20759 `__: MAINT: Raise RuntimeError if setuptools version is too recent. +* `#20762 `__: BUG: Allow integer inputs for pow-related functions in ``array_api`` +* `#20766 `__: ENH: Make ndarray.__array_finalize__ a callable no-op +* `#20773 `__: BUG: method without self argument should be static +* `#20774 `__: DOC: explicitly define numpy.datetime64 semantics +* `#20776 `__: DOC: fix remaining "easy" doctests errors +* `#20779 `__: MAINT: removed duplicate 'int' type in ScalarType +* `#20783 `__: DOC: Update Copyright to 2022 [License] +* `#20784 `__: MAINT, DOC: fix new typos detected by codespell +* `#20786 `__: BUG, DOC: Fixes SciPy docs build warnings +* `#20788 `__: BUG: ``array_api.argsort(descending=True)`` respects relative... +* `#20789 `__: DOC: git:// protocol deprecated by github. +* `#20791 `__: BUG: Return correctly shaped inverse indices in ``array_api`` set... +* `#20792 `__: TST: Bump mypy to 0.931 +* `#20793 `__: BUG: Fix that reduce-likes honor out always (and live in the... +* `#20794 `__: TYP: Type the NEP 35 ``like`` parameter via a ``__array_function__``... +* `#20810 `__: DOC: Restore MaskedArray.hardmask documentation +* `#20811 `__: MAINT, DOC: discard repeated words +* `#20813 `__: MAINT: fix typo +* `#20816 `__: DOC: discard repeated words in NEPs +* `#20818 `__: BUG: Fix build of third-party extensions with Py_LIMITED_API +* `#20821 `__: ENH: Add CPU feature detection for POWER10 (VSX4) +* `#20823 `__: REL: Update main after 1.22.1 release. +* `#20827 `__: TYP: Fix pyright being unable to infer the ``real`` and ``imag``... +* `#20828 `__: MAINT: Translate heapsort.c.src to C++ using templates +* `#20829 `__: MAINT: Translate mergesort.c.src to C++ using templates. +* `#20831 `__: BUG: Avoid importing numpy.distutils on import numpy.testing +* `#20833 `__: BUG: Fix comparator function signatures +* `#20834 `__: DOC: Update ndarray.argmax + argmin documentation with keepdims... +* `#20835 `__: DEP: Removed deprecated error clearing +* `#20840 `__: MAINT: Translate selection.c.src to C++ using templates. +* `#20846 `__: ENH, SIMD: improve argmax/argmin performance +* `#20847 `__: MAINT: remove outdated mingw32 fseek support +* `#20851 `__: DOC: Fix typo in meshgrid example +* `#20852 `__: MAINT: Fix a typo in numpy/f2py/capi_maps.py +* `#20854 `__: DEV: Update dependencies and Docker image +* `#20857 `__: BUG: Fix pre-builds in Gitpod +* `#20858 `__: TYP: Relax the return-type of ``np.vectorize`` +* `#20861 `__: DOC: fix formatting of mean example +* `#20862 `__: Fix typo in numpy/lib/polynomial.py +* `#20865 `__: MAINT: Fix inconsistent PyPI casing +* `#20866 `__: ENH: Add changes that allow NumPy to compile with clang-cl +* `#20867 `__: DOC: Cosmetic docstring fix for numpydoc. +* `#20868 `__: BUG: Gitpod Remove lock file --unshallow +* `#20869 `__: DOC: random: Fix spelling of 'precision'. +* `#20872 `__: BUG: Loss of precision in longdouble min +* `#20874 `__: BUG: mtrand cannot be imported on Cygwin +* `#20875 `__: DEP: deprecate ``numpy.distutils``, and add a migration guide +* `#20876 `__: MAINT, DOC: Fixes minor formatting issue related to nested inline... +* `#20878 `__: DOC,TST: Fix Pandas code example +* `#20881 `__: BUG: fix f2py's define for threading when building with Mingw +* `#20883 `__: BUG: Fix ``np.array_api.can_cast()`` by not relying on ``np.can_cast()`` +* `#20884 `__: MAINT: Minor cleanup to F2PY +* `#20885 `__: TYP,ENH: Improve typing with the help of ``ParamSpec`` +* `#20886 `__: BUG: distutils: fix building mixed C/Fortran extensions +* `#20887 `__: TYP,MAINT: Add aliases for commonly used unions +* `#20890 `__: BUILD: Upload wheels to anaconda,org +* `#20897 `__: MAINT: Translate quicksort.c.src to C++ using templates. +* `#20900 `__: TYP,ENH: Add annotations for ``np.lib.mixins`` +* `#20902 `__: TYP,ENH: Add dtype-typing support to ``np.core.fromnumeric`` (part... +* `#20904 `__: ENH,BUG: Expand the experimental DType API and fix small exposed... +* `#20911 `__: BUG: Fix the return type of random_float_fill +* `#20916 `__: TYP, MAINT: Add annotations for ``flatiter.__setitem__`` +* `#20917 `__: DOC: fix np.ma.flatnotmasked_contiguous docstring +* `#20918 `__: MAINT, TYP: Added missing where typehints in fromnumeric.pyi +* `#20920 `__: DEP: Deprecate use of ``axis=MAXDIMS`` instead of ``axis=None`` +* `#20927 `__: DOC: lib/io.py was renamed to lib/npyio.py +* `#20931 `__: BUG: Fix missing intrinsics for windows/arm64 target +* `#20934 `__: BUG: Fix build_ext interaction with non-numpy extensions +* `#20940 `__: MAINT: f2py: don't generate code that triggers ``-Wsometimes-uninitialized`` +* `#20944 `__: DOC: improper doc syntax (markdown and imbalanced ticks). +* `#20946 `__: MAINT: Fix typo in setup.py +* `#20948 `__: MAINT, DOC: NEP link update +* `#20950 `__: Fix broken link in nep-0046-sponsorship-guidelines.rst +* `#20955 `__: BUG: Fix incorrect return type in reduce without initial value +* `#20956 `__: DOC: Improve NEP page layout with nested toctrees +* `#20960 `__: ENH: review return values for PyArray_DescrNew +* `#20963 `__: MAINT: be more tolerant of setuptools>=60 +* `#20966 `__: DOC: update python minimal version to build from source +* `#20967 `__: MAINT: Update to numpydoc v1.2 +* `#20968 `__: MAINT: Translate npy_partition.h.src to C++ using templates. +* `#20972 `__: DOC: Add warning about differences between range and arange +* `#20973 `__: DOC: switch Python intersphinx link from dev to stable. +* `#20974 `__: DOC: Include special case in ``hsplit`` doc +* `#20975 `__: MAINT: refactor NonNull in API functions +* `#20976 `__: ENH,BENCH: Optimize floor_divide for VSX4/Power10 +* `#20987 `__: BLD: Try adding aarch64 wheels [wheel build] +* `#20990 `__: MAINT: Further small return value validation fixes +* `#20991 `__: ENH: Use SVML for f64 exp and log +* `#20993 `__: ENH: Allow object and subarray dtypes in fromiter +* `#20994 `__: REL: Update main after 1.22.2 release. +* `#20996 `__: MAINT: use brackets in github action syntax +* `#20999 `__: DOC: Remove mention of deleted subpackages in numpy docstring +* `#21000 `__: MAINT: Replace LooseVersion by _pep440. +* `#21001 `__: ENH: help compilers to auto-vectorize reduction operators +* `#21003 `__: ENH: Suppress over-/underflow RuntimeWarning in assert_array_equal +* `#21005 `__: BUG: Add parameter check to negative_binomial +* `#21010 `__: MAINT: Fix warning message for deprecated keyword +* `#21015 `__: DOC: Added note about possible arange signatures +* `#21016 `__: MAINT, DOC: Fix SciPy intersphinx link +* `#21020 `__: DOC: imbalanced backticks +* `#21021 `__: TYP,ENH: Add dtype-typing support to ``fromnumeric`` (part 2) +* `#21024 `__: API: Disallow strings in logical ufuncs +* `#21025 `__: MAINT: Use C++ for tokenizer unicode-kind templating +* `#21027 `__: BUG: use ``concurrent.futures.ThreadPoolExecutor`` in distutils... +* `#21029 `__: DEP: Remove support for non-tuple nd-indices. +* `#21030 `__: DOC: change fill_value of full_like from scalar to array_like +* `#21031 `__: MAINT, STY: Style fixes to quicksort.cpp +* `#21032 `__: DOC: fix sphinx errors due to np.emath references +* `#21035 `__: BUILD: remove condition on upload step +* `#21037 `__: DOC: Consistency of :: syntax. +* `#21039 `__: MAINT: Remove the RELAXED_STRIDES_CHECKING env variable +* `#21040 `__: DOC: "See Also" should not have backticks. +* `#21042 `__: MAINT, STY: Style fixups. +* `#21043 `__: BUILD: simplify upload step +* `#21045 `__: BUILD: change syntax to use env variable +* `#21046 `__: MAINT: Use "3.10" instead of "3.10-dev" on travis. +* `#21049 `__: use repo secrets for uploading +* `#21050 `__: BUILD: tweak upload to use python3, less verbose +* `#21053 `__: BUILD: make sure a python3 is on the path +* `#21054 `__: BUG: (loadtxt) Ignore last empty field when ``delimiter=None`` +* `#21060 `__: TYP: Add dtype-typing support to ``fromnumeric`` part 3 +* `#21061 `__: BLD,ENH: Add vsx3 and vsx4 as targets when building cos/sin and... +* `#21064 `__: DOC: Update arctan2 docstring based on doctest output +* `#21067 `__: BUG: Fix unpickling an empty ndarray with a non-zero dimension +* `#21068 `__: DOC: Fix spelling and grammar in documentation for quantile(). +* `#21071 `__: BUG: Ensure equality/identity comparison with ``__array_function__`` +* `#21074 `__: BUG: Replace ``ssize_t`` with ``size_t`` in tokenize.cpp +* `#21077 `__: TYP,MAINT: Remove inconsistencies between ``fromnumeric`` functions... +* `#21082 `__: DOC: clarify the return value of linalg.cholesky +* `#21085 `__: MAINT: point to html docs on distutils migration in deprecation... +* `#21086 `__: DEV: fix ``python runtests.py --bench-compare`` +* `#21087 `__: DOC: update docs in site.cfg.example +* `#21088 `__: DEV: add distutils deprecation warning filter to pytest conf +* `#21089 `__: BUILD: if travis build is triggered manually, then upload wheels +* `#21090 `__: BUILD: change cibuildwheel output directory on travis [ci skip] +* `#21095 `__: BLD: Make a sdist [wheel build] +* `#21097 `__: MAINT: update cython, pypy for cython0.29.28 and pypy v7.3.8... +* `#21099 `__: MAINT: Translate x86-qsort.dispatch.c.src to C++ using templates. +* `#21100 `__: BLD: Comment out broken macOS PyPy build [wheel build] +* `#21102 `__: TYP,MAINT: Explicitly allow sequences of array-likes in ``np.concatenate`` +* `#21107 `__: BLD: Run wheel builders on labeled pull requests +* `#21108 `__: TYP, ENH: Mark non-subclassable classes as ``final`` +* `#21109 `__: MAINT: Fix incorrect signature in readtext header file +* `#21110 `__: CI: Improve concurrency to cancel running jobs on PR update +* `#21111 `__: TYP, MAINT: Relax the ``obj`` type in ``__array_finalize__`` +* `#21113 `__: BUG: Fix numba DUFuncs added loops getting picked up +* `#21118 `__: DOC: improve documentation of singular value decomposition +* `#21119 `__: BUG, ENH: np._from_dlpack: export correct device information +* `#21121 `__: MAINT,TST: np._from_dlpack: add more test + small memory optimization +* `#21124 `__: ENH,SIMD: Vectorize modulo/divide using the universal intrinsics... +* `#21125 `__: BLD: bump cibuildwheel 2.3.0 → 2.3.1 on GHA [wheel build] +* `#21127 `__: BLD,DOC: skip broken ipython 8.1.0 +* `#21128 `__: BLD: move cibuildwheel configuration to ``pyproject.toml`` +* `#21130 `__: ENH: improve the speed of numpy.where using a branchless code +* `#21132 `__: BUG,ENH: np._from_dlpack: export arrays with any-strided size-1... +* `#21133 `__: DOC: Note interop from "subclassing" docs and explain when to... +* `#21144 `__: DOC: Change recommendation away from pinning numpy+3 +* `#21145 `__: MAINT, DOC: make np._from_dlpack public +* `#21146 `__: BUG: assign all tuple items before using it for PyPy +* `#21149 `__: DOC: Update linalg.qr docstring with numerically stable example +* `#21150 `__: DOC: Fix syntax highlighting for numpy.flatnonzero +* `#21151 `__: ENH: Add 'ulong' to sctypeDict +* `#21154 `__: ENH, BLD: Fix math feature detection for wasm +* `#21155 `__: DOC: document uploads to ananconda.org +* `#21157 `__: DOC: fix documentation for typedescr argument of PyArray_AsCArray +* `#21167 `__: DOC: Add "pip install -r test_requirements.txt" +* `#21170 `__: REL: Update main after 1.22.3 release. +* `#21178 `__: MAINT: Move can-cast table to a custom header file +* `#21180 `__: TST: Bump mypy from 0.931 to 0.940 +* `#21185 `__: TYP, BUG: Fix ``np.lib.stride_tricks`` re-exported under wrong... +* `#21186 `__: MAINT: update NEP 29 +* `#21187 `__: ENH: F2PY build output determinism +* `#21188 `__: MAINT,ENH: Rewrite scalar math logic +* `#21189 `__: DEV: Remove deprecated "python.pythonPath" +* `#21193 `__: DOC: Remove the confusing "unless not" in numpy/core/fromnumeric.py +* `#21201 `__: DOC: typo corrected in numpy.argpartition +* `#21202 `__: DOC: fix outdated description of unicode +* `#21205 `__: BUG: f2py cannot read in customised f2cmap file; fix #21204 +* `#21206 `__: MAINT: fix typo in NEP 29 +* `#21207 `__: MAINT: remove maint from triggering wheel build, add env to sdist +* `#21216 `__: MAINT: Split ``numpy.typing`` into a public and private component +* `#21218 `__: BUG: Use -0. as initial value for summation (internal only) +* `#21226 `__: DOC: misc fixes +* `#21227 `__: MAINT: Translate numpy/linalg/umath_linalg.c.src to C++ using... +* `#21231 `__: BUG: Catch error if array-priority is not float compatible +* `#21232 `__: BUG: Fixes ``ValueError`` in ``np.kron`` +* `#21238 `__: BLD: Fix upload script +* `#21241 `__: MAINT: use doc_requirements.txt in azure build +* `#21244 `__: TST: Bump mypy from 0.940 to 0.942 +* `#21247 `__: DOC: directive fix (single instead of double backticks). +* `#21250 `__: DEV: Fixed Un-responsive live-preview in gitpod. +* `#21251 `__: DOC: fix data type of parameter shape +* `#21253 `__: DOC: fix code sample for leg2poly +* `#21254 `__: DOC: document automatic wheel building for a release +* `#21255 `__: DOC: mention Gitpod as alternative to build numpy +* `#21256 `__: BUG,ENH: Fix negative bounds for F2PY +* `#21260 `__: DOC: Enumerate the differences between numpy and numpy.array_api +* `#21262 `__: ENH: Masked Array support for ``np.kron`` +* `#21269 `__: DOC: Improve "random.generator.shuffle" docs page +* `#21272 `__: BUG: Fix typos +* `#21285 `__: BLD: Bump cibuildwheel and enable more PyPy +* `#21286 `__: DOC: double backticks and links +* `#21287 `__: MAINT: Use C++ inline and include files in C++ files. +* `#21290 `__: DOC: Improve documentation formatting +* `#21291 `__: DOC: Add space after argument name +* `#21295 `__: MAINT: Clean-up includes of auto-generated umath code +* `#21297 `__: MAINT: Rename source files that were not using any template-preprocessing +* `#21303 `__: MAINT: Edit logo size and logo position in README.md +* `#21306 `__: ENH: Introduce numpy.core.setup_common.NPY_CXX_FLAGS +* `#21307 `__: MAINT: bump versions in Github actions configuration to v3. +* `#21314 `__: DOC: various spell checks and typo fixes +* `#21315 `__: DOC: minor typo fix in numpy.random API docs +* `#21321 `__: BUG: Stop using PyBytesObject.ob_shash deprecated in Python 3.11. +* `#21324 `__: BUG: Make mmap handling safer in frombuffer +* `#21327 `__: Small updates to the array_api docs +* `#21330 `__: DOC: Add F2PY tests documentation +* `#21331 `__: REL: Update main after 1.21.6 release. +* `#21345 `__: TYP: Let ``ndarray`` fancy indexing always return an ``ndarray`` +* `#21347 `__: MAINT: Fix failing simd and cygwin tests. +* `#21348 `__: DEV: reverted misplaced install of "esbonio". +* `#21349 `__: MAINT: Update setup-cygwin to v3 again. +* `#21352 `__: Doc: Philox.jumped correct the formula +* `#21354 `__: ENH: Improve ``np.kron`` performance +* `#21355 `__: MAINT: Remove the reference to the “good first issue” label +* `#21356 `__: DOC: Fix a typo in docstring of MT19937 +* `#21360 `__: MAINT: Add compile flag to disable voltbl on MSVC 142 +* `#21366 `__: BUG: fix compilation error for VS 141 and earlier +* `#21367 `__: MAINT: Translate ieee754.c.src to C++ using templates. +* `#21368 `__: MAINT: Fix failing Python 3.8 32-bit Windows test. +* `#21372 `__: BUG: Allow legacy dtypes to cast to datetime again +* `#21377 `__: API: Allow newaxis indexing for ``array_api`` arrays +* `#21381 `__: DOC: Typesetting of math for np.correlate and np.convolve +* `#21382 `__: DOC: non-orphan page, and casing. +* `#21384 `__: BUG: Missing ``f`` prefix on f-strings fix +* `#21388 `__: MAINT: be sure to match base and docker images +* `#21392 `__: BUG: add linux guard per #21386 +* `#21394 `__: PERF: Reduce overhead of np.linalg.norm for small arrays +* `#21400 `__: DOC: Add missing entries in ``numpy.testing`` documentation +* `#21407 `__: MAINT: Reduce f2py verbiage for valid parameters +* `#21410 `__: DOC: Update set of allowed f2cmap types +* `#21411 `__: MAINT: Remove ``f2py.f2py_testing`` without replacement +* `#21413 `__: DOC: Secure PR template URLs [ci skip] +* `#21415 `__: BUG: Fix handling of skip-empty-wrappers +* `#21417 `__: MAINT: Update doc requirements +* `#21421 `__: MAINT: Remove FPE helper code that is unnecessary on C99/C++11 +* `#21423 `__: PERF: Improve performance of special attribute lookups +* `#21425 `__: TEST: on PyPy, skip hanging slow test [wheel build] +* `#21426 `__: DOC: Add version switcher to the documentation +* `#21430 `__: TYP: Bump mypy to 0.950 +* `#21436 `__: BUG: Fix segmentation fault +* `#21442 `__: BUG: Ensure compile errors are raised correctly +* `#21450 `__: PERF: Statically allocate unicode strings of memhandler +* `#21451 `__: DOC: Style version switcher button +* `#21452 `__: TST: Remove most prints from the test suit run +* `#21453 `__: [road-to-cxx] npy_cpu_features moved to pure C +* `#21456 `__: DOC: style main page card +* `#21463 `__: BENCH: Add benchmarks targeted at small arrays +* `#21464 `__: PERF: Fast check on equivalent arrays in PyArray_EQUIVALENTLY_ITERABLE_OVERLAP_OK +* `#21465 `__: PERF: Use python integer on _count_reduce_items +* `#21466 `__: DEV: Pin setuptools in the asv config +* `#21467 `__: MAINT: Mark ``npy_memchr`` with ``no_sanitize("alignment")`` on clang +* `#21470 `__: PERF: Skip probing ``__array_ufunc__`` for NumPy builtin scalars +* `#21477 `__: MAINT: Reduce allocation size of empty (0 size) arrays to 1 byte +* `#21479 `__: TYP,ENH: Add annotations for new numpy 1.23 features +* `#21485 `__: ENH: Add 'keepdims' to 'average()' and 'ma.average()'. +* `#21490 `__: TYP: Add typing for the keepdims param. of 'average' and 'ma.average' +* `#21491 `__: DOC: Proposal - make the doc landing page cards more similar... +* `#21492 `__: BUG: lib: Allow type uint64 for eye() arguments. +* `#21498 `__: ENH: Add ``_get_madvise_hugepage`` function +* `#21499 `__: ENH: avoid looping when dimensions[0] == 0 or array.size == 0 +* `#21500 `__: TST: Fix uninitialized value in masked ndenumerate test +* `#21502 `__: DEV: Fix Warnings/Errors on Gitpod +* `#21503 `__: TYP: Add basic ``np.number`` overloads for ``ndarray`` dunders +* `#21514 `__: MAINT: Update to Cython 0.29.29. +* `#21517 `__: MAINT: Update .mailmap +* `#21518 `__: BUG: Fix complex+longdouble and broken subclass handling +* `#21530 `__: MAINT: Update to Cython 0.29.30. +* `#21534 `__: BUG: Fix GCC error during build configuration +* `#21540 `__: BUILD: update OpenBLAS to v0.3.20 +* `#21542 `__: DOC: improve the docstring of numpy.sinc to explain behavior... +* `#21543 `__: TST,TYP: Fix a python 3.11 failure for the ``GenericAlias`` tests +* `#21545 `__: Tests/Docs: Update tests to Cython 0.29.30, mention in docs +* `#21552 `__: BLD: Sort svml objects to keep builds reproducible +* `#21553 `__: PERF: Faster MyPyFloat_AsDouble +* `#21558 `__: MAINT: Python <3.8 related cleanups +* `#21562 `__: REL: Update main after 1.22.4 release. +* `#21565 `__: DOC: add explanation to makefile error +* `#21566 `__: DOC: Fix docstring and examples for rfn.get_names* +* `#21568 `__: DOC:linalg: Remove ref to scipy.linalg.pinv2 +* `#21569 `__: MAINT: loosen Cython pin in environment.yml +* `#21570 `__: CI: fix Gitpod image build +* `#21574 `__: BUG: refguide-check: respect the verbosity +* `#21577 `__: MAINT: update PyPy to 7.3.9 and remove unused script +* `#21580 `__: MAINT: Update the cversion hash. +* `#21589 `__: REL: Prepare for the NumPy 1.23.0rc1 release. +* `#21604 `__: BUILD: fix tag name for travis: it is v1.23.0rc1 +* `#21606 `__: DOC: add missing links for two NEPs +* `#21607 `__: TYP, MAINT: Allow unsigned integer inplace-ops to accept signed... +* `#21610 `__: REL: Prepare for 1.23.0rc1 release, second version. +* `#21619 `__: MAINT, STY: Make download-wheels download source files. +* `#21634 `__: MAINT: back out conversion of npymath component to c++ +* `#21635 `__: TST: Skip F2PY tests without Fortran compilers +* `#21636 `__: API: Retain ``arr.base`` more strictly in ``np.frombuffer`` +* `#21637 `__: REL: Prepare for the NumPy 1.23.0rc2 release. +* `#21646 `__: ENH: Add equals_nan kwarg to np.unique +* `#21649 `__: MAINT: Start testing with Python 3.11. +* `#21656 `__: TYP, ENH: Add annotations for the ``equal_nan`` keyword to ``np.unique`` +* `#21660 `__: MAINT: Adapt npt._GenericAlias to Python 3.11 types.GenericAlias +* `#21684 `__: MAINT: Point documentation version switcher at the docs homepage +* `#21688 `__: DEP: Deprecate (rather than remove) the int-via-float parsing... +* `#21697 `__: BUG: Fix a refactor leftover bug +* `#21698 `__: BUG: Prevent attempted broadcasting of 0-D output operands in... +* `#21710 `__: TST: Fixup loadtxt int-via-float tests when in release mode +* `#21716 `__: ENH: Implement string comparison ufuncs (or almost) +* `#21718 `__: BUG: use explicit einsum_path whenever it is given +* `#21719 `__: BUG: Small fixupes found using valgrind +* `#21720 `__: BUG: Enable fortran preprocessing for ifort on Windows +* `#21721 `__: BLD, SIMD: Fix detect armhf and hardened the Neon/ASIMD compile-time... +* `#21722 `__: BUG: .f2py_f2cmap doesn't map long_long and other options +* `#21729 `__: REL: Prepare for the NumPy 1.23.0rc3 release. +* `#21754 `__: BUG, SIMD: Fix detecting NEON/ASIMD on aarch64 +* `#21757 `__: BUG: Do not skip value-based promotion path for large Python... +* `#21761 `__: BUG: Fix small reference leaks found with pytest-leaks +* `#21777 `__: REV: Revert "ENH: Implement string comparison ufuncs (or almost)... +* `#21809 `__: MAINT: Add a check of the return value of PyMem_Calloc(). +* `#21810 `__: BUG: lib: A loadtxt error message had two values reversed. +* `#21811 `__: REL: Prepare for the NumPy 1.23.0 release +* `#21824 `__: MAINT: Try fixing broken Anaconda uploads + + diff --git a/doc/changelog/1.23.1-changelog.rst b/doc/changelog/1.23.1-changelog.rst new file mode 100644 index 000000000000..9618bae72464 --- /dev/null +++ b/doc/changelog/1.23.1-changelog.rst @@ -0,0 +1,28 @@ + +Contributors +============ + +A total of 7 people contributed to this release. People with a "+" by their +names contributed a patch for the first time. + +* Charles Harris +* Matthias Koeppe + +* Pranab Das + +* Rohit Goswami +* Sebastian Berg +* Serge Guelton +* Srimukh Sripada + + +Pull requests merged +==================== + +A total of 8 pull requests were merged for this release. + +* `#21866 `__: BUG: Fix discovered MachAr (still used within valgrind) +* `#21867 `__: BUG: Handle NaNs correctly for float16 during sorting +* `#21868 `__: BUG: Use ``keepdims`` during normalization in ``np.average`` and... +* `#21869 `__: DOC: mention changes to ``max_rows`` behaviour in ``np.loadtxt`` +* `#21870 `__: BUG: Reject non integer array-likes with size 1 in delete +* `#21949 `__: BLD: Make can_link_svml return False for 32bit builds on x86_64 +* `#21951 `__: BUG: Reorder extern "C" to only apply to function declarations... +* `#21952 `__: BUG: Fix KeyError in crackfortran operator support diff --git a/doc/changelog/1.23.2-changelog.rst b/doc/changelog/1.23.2-changelog.rst new file mode 100644 index 000000000000..964d0a07e0ec --- /dev/null +++ b/doc/changelog/1.23.2-changelog.rst @@ -0,0 +1,37 @@ + +Contributors +============ + +A total of 9 people contributed to this release. People with a "+" by their +names contributed a patch for the first time. + +* Alexander Grund + +* Bas van Beek +* Charles Harris +* Jon Cusick + +* Matti Picus +* Michael Osthege + +* Pal Barta + +* Ross Barnowski +* Sebastian Berg + +Pull requests merged +==================== + +A total of 15 pull requests were merged for this release. + +* `#22030 `__: ENH: Add ``__array_ufunc__`` typing support to the ``nin=1`` ufuncs +* `#22031 `__: MAINT, TYP: Fix ``np.angle`` dtype-overloads +* `#22032 `__: MAINT: Do not let ``_GenericAlias`` wrap the underlying classes'... +* `#22033 `__: TYP,MAINT: Allow ``einsum`` subscripts to be passed via integer... +* `#22034 `__: MAINT,TYP: Add object-overloads for the ``np.generic`` rich comparisons +* `#22035 `__: MAINT,TYP: Allow the ``squeeze`` and ``transpose`` method to... +* `#22036 `__: BUG: Fix subarray to object cast ownership details +* `#22037 `__: BUG: Use ``Popen`` to silently invoke f77 -v +* `#22038 `__: BUG: Avoid errors on NULL during deepcopy +* `#22039 `__: DOC: Add versionchanged for converter callable behavior. +* `#22057 `__: MAINT: Quiet the anaconda uploads. +* `#22078 `__: ENH: reorder includes for testing on top of system installations... +* `#22106 `__: TST: fix test_linear_interpolation_formula_symmetric +* `#22107 `__: BUG: Fix skip condition for test_loss_of_precision[complex256] +* `#22115 `__: BLD: Build python3.11.0rc1 wheels. diff --git a/doc/changelog/1.23.3-changelog.rst b/doc/changelog/1.23.3-changelog.rst new file mode 100644 index 000000000000..c29a83805f9b --- /dev/null +++ b/doc/changelog/1.23.3-changelog.rst @@ -0,0 +1,43 @@ + +Contributors +============ + +A total of 16 people contributed to this release. People with a "+" by their +names contributed a patch for the first time. + +* Aaron Meurer +* Bas van Beek +* Charles Harris +* Ganesh Kathiresan +* Gavin Zhang + +* Iantra Solari+ +* Jyn Spring 琴春 + +* Matti Picus +* Rafael Cardoso Fernandes Sousa +* Rafael Sousa + +* Ralf Gommers +* Rin Cat (鈴猫) + +* Saransh Chopra + +* Sayed Adel +* Sebastian Berg +* Serge Guelton + +Pull requests merged +==================== + +A total of 14 pull requests were merged for this release. + +* `#22136 `__: BLD: Add Python 3.11 wheels to aarch64 build +* `#22148 `__: MAINT: Update setup.py for Python 3.11. +* `#22155 `__: CI: Test NumPy build against old versions of GCC(6, 7, 8) +* `#22156 `__: MAINT: support IBM i system +* `#22195 `__: BUG: Fix circleci build +* `#22214 `__: BUG: Expose heapsort algorithms in a shared header +* `#22215 `__: BUG: Support using libunwind for backtrack +* `#22216 `__: MAINT: fix an incorrect pointer type usage in f2py +* `#22220 `__: BUG: change overloads to play nice with pyright. +* `#22221 `__: TST,BUG: Use fork context to fix MacOS savez test +* `#22222 `__: TYP,BUG: Reduce argument validation in C-based ``__class_getitem__`` +* `#22223 `__: TST: ensure ``np.equal.reduce`` raises a ``TypeError`` +* `#22224 `__: BUG: Fix the implementation of numpy.array_api.vecdot +* `#22230 `__: BUG: Better report integer division overflow (backport) diff --git a/doc/changelog/1.23.4-changelog.rst b/doc/changelog/1.23.4-changelog.rst new file mode 100644 index 000000000000..8fec435a01b6 --- /dev/null +++ b/doc/changelog/1.23.4-changelog.rst @@ -0,0 +1,34 @@ + +Contributors +============ + +A total of 8 people contributed to this release. People with a "+" by their +names contributed a patch for the first time. + +* Bas van Beek +* Charles Harris +* Matthew Barber +* Matti Picus +* Ralf Gommers +* Ross Barnowski +* Sebastian Berg +* Sicheng Zeng + + +Pull requests merged +==================== + +A total of 13 pull requests were merged for this release. + +* `#22368 `__: BUG: Add ``__array_api_version__`` to ``numpy.array_api`` namespace +* `#22370 `__: MAINT: update sde toolkit to 9.0, fix download link +* `#22382 `__: BLD: use macos-11 image on azure, macos-1015 is deprecated +* `#22383 `__: MAINT: random: remove ``get_info`` from "extending with Cython"... +* `#22384 `__: BUG: Fix complex vector dot with more than NPY_CBLAS_CHUNK elements +* `#22387 `__: REV: Loosen ``lookfor``'s import try/except again +* `#22388 `__: TYP,ENH: Mark ``numpy.typing`` protocols as runtime checkable +* `#22389 `__: TYP,MAINT: Change more overloads to play nice with pyright +* `#22390 `__: TST,TYP: Bump mypy to 0.981 +* `#22391 `__: DOC: Update delimiter param description. +* `#22392 `__: BUG: Memory leaks in numpy.nested_iters +* `#22413 `__: REL: Prepare for the NumPy 1.23.4 release. +* `#22424 `__: TST: Fix failing aarch64 wheel builds. diff --git a/doc/changelog/1.23.5-changelog.rst b/doc/changelog/1.23.5-changelog.rst new file mode 100644 index 000000000000..e24a291e47be --- /dev/null +++ b/doc/changelog/1.23.5-changelog.rst @@ -0,0 +1,30 @@ + +Contributors +============ + +A total of 7 people contributed to this release. People with a "+" by their +names contributed a patch for the first time. + +* @DWesl +* Aayush Agrawal + +* Adam Knapp + +* Charles Harris +* Navpreet Singh + +* Sebastian Berg +* Tania Allard + +Pull requests merged +==================== + +A total of 10 pull requests were merged for this release. + +* `#22489 `__: TST, MAINT: Replace most setup with setup_method (also teardown) +* `#22490 `__: MAINT, CI: Switch to cygwin/cygwin-install-action@v2 +* `#22494 `__: TST: Make test_partial_iteration_cleanup robust but require leak... +* `#22592 `__: MAINT: Ensure graceful handling of large header sizes +* `#22593 `__: TYP: Spelling alignment for array flag literal +* `#22594 `__: BUG: Fix bounds checking for ``random.logseries`` +* `#22595 `__: DEV: Update GH actions and Dockerfile for Gitpod +* `#22596 `__: CI: Only fetch in actions/checkout +* `#22597 `__: BUG: Decrement ref count in gentype_reduce if allocated memory... +* `#22625 `__: BUG: Histogramdd breaks on big arrays in Windows diff --git a/doc/changelog/1.24.0-changelog.rst b/doc/changelog/1.24.0-changelog.rst new file mode 100644 index 000000000000..7ae8cd4c967c --- /dev/null +++ b/doc/changelog/1.24.0-changelog.rst @@ -0,0 +1,634 @@ + +Contributors +============ + +A total of 177 people contributed to this release. People with a "+" by their +names contributed a patch for the first time. + +* @DWesl +* @amagicmuffin + +* @dg3192 + +* @h-vetinari +* @juztamau5 + +* @swagatip + +* Aaron Meurer +* Aayush Agrawal + +* Adam Knapp + +* Adarsh Singh + +* Al-Baraa El-Hag +* Alban Desmaison + +* Ales Crocaro + +* Alex Low + +* Alexander Grund + +* Alexander Kanavin + +* Andras Deak +* Andrew Nelson +* Angéllica Araujo + +* Anselm Hahn + +* Ari Cooper Davis + +* Axel Huebl + +* Bas van Beek +* Bhavuk Kalra +* Bram Ton + +* Brent Tan + +* Brigitta Sipőcz +* Callum O'Riley + +* Charles Harris +* Chiara Marmo +* Christoph Reiter +* Damien Caliste +* Dan Schult + +* Daniel da Silva +* DanielHabenicht + +* Dave Goel + +* David Gilbertson + +* Developer-Ecosystem-Engineering +* Digya Acharya + +* Dimitri Papadopoulos Orfanos +* Eric-Shang + +* Evgeni Burovski +* Ewout ter Hoeven +* Felix Hirwa Nshuti + +* Frazer McLean + +* Ganesh Kathiresan +* Gavin Zhang + +* Gaëtan de Menten +* Greg Lucas +* Greg Sadetsky + +* Gregory P. Smith [Google LLC] + +* Hameer Abbasi +* Hannah Aizenman + +* Hood Chatham +* I-Shen Leong +* Iantra Solari + +* Ikko Ashimine + +* Inessa Pawson +* Jake Bowhay + +* Jake Close + +* Jarrod Millman +* Jason Thai +* JessePires + +* Jessé Pires + +* Jhonatan Cunha + +* Jingxuan He + +* Johnathon Cusick + +* Jon Morris +* Jordy Williams + +* Josh Wilson +* João Fontes Gonçalves + +* Juan Luis Cano Rodríguez +* Jyn Spring 琴春 + +* KIU Shueng Chuan +* Karl Otness + +* Kevin Sheppard +* Kinshuk Dua + +* Leo Fang +* Leona Taric + +* Lev Maximov + +* Lillian Zha + +* Loïc Estève +* M. Eric Irrgang + +* Mariusz Felisiak +* Mark Harfouche +* Martin Zacho + +* Matheus Santana Patriarca + +* Matt Williams + +* Matteo Raso + +* Matthew Barber +* Matthew Brett +* Matthew Sterrett + +* Matthias Bussonnier +* Matthias Koeppe + +* Matti Picus +* Meekail Zain + +* Melissa Weber Mendonça +* Michael Osthege + +* Michael Siebert + +* Mike Toews +* Miki Watanabe + +* Miles Cranmer + +* Monika Kubek + +* Muhammad Jarir Kanji + +* Mukulika Pahari +* Namami Shanker +* Nathan Goldbaum + +* Nathan Rooy + +* Navpreet Singh + +* Noritada Kobayashi + +* Oleksiy Kononenko + +* Omar Ali + +* Pal Barta + +* Pamphile Roy +* Patrick Hoefler + +* Pearu Peterson +* Pedro Nacht + +* Petar Mlinarić + +* Peter Hawkins +* Pey Lian Lim +* Pieter Eendebak +* Pradipta Ghosh +* Pranab Das + +* Precision Wordcraft LLC + +* PrecisionWordcraft + +* Rafael CF Sousa + +* Rafael Cardoso Fernandes Sousa +* Rafael Sousa + +* Raghuveer Devulapalli +* Ralf Gommers +* Rin Cat (鈴猫) + +* Robert Kern +* Rohit Davas + +* Rohit Goswami +* Ross Barnowski +* Roy Smart + +* Ruth Comer + +* Sabiha Tahsin Soha + +* Sachin Krishnan T V + +* Sanjana M Moodbagil + +* Sanya Sinha + +* Sarah Coffland + +* Saransh Chopra + +* Satish Kumar Mishra + +* Satish Mishra + +* Sayed Adel +* Schrijvers Luc + +* Sebastian Berg +* Serge Guelton +* Seva Lotoshnikov + +* Shashank Gupta + +* Shoban Chiddarth + +* Shreya Singh + +* Shreyas Joshi + +* Sicheng Zeng + +* Simran Makandar + +* Shuangchi He + +* Srimukh Sripada + +* Stefan van der Walt +* Stefanie Molin + +* Stuart Archibald +* Tania Allard +* Thomas A Caswell +* Thomas Kastl + +* Thomas Mansencal + +* Tony Newton / Teng Liu + +* Toshiki Kataoka +* Tyler Reddy +* Vardhaman Kalloli + +* Warren Weckesser +* Will Ayd + +* William Stein + +* XinRu Lin + +* Yin Li + +* Yunika Bajracharya + +* Zachary Blackwood + +* 渡邉 美希 + + +Pull requests merged +==================== + +A total of 444 pull requests were merged for this release. + +* `#12065 `__: API: Optimize np.isin and np.in1d for integer arrays and add... +* `#15782 `__: ENH: complete the 'vars' list of a module +* `#16022 `__: ENH: Adding __array_ufunc__ capability to MaskedArrays +* `#16154 `__: ENH: Add support for symbol to polynomial package +* `#16507 `__: BUG: Do not allow nditer to reduce the mask +* `#16971 `__: BUG: Fix three ``complex``- & ``float128``-related issues with ``nd_grid`` +* `#19388 `__: ENH: Support character and character string arrays +* `#20321 `__: ENH: allow NumPy created .npy files to be appended in-place +* `#20659 `__: BUG: cross product. Added dtype conversions of inputs. See. #19138 +* `#20913 `__: ENH, SIMD: Extend universal intrinsics to support IBMZ +* `#20914 `__: BUG: change ``ma.mean`` dtype to be consistent with ``np.mean`` +* `#20924 `__: MAINT: Simplify element setting and use it for filling +* `#20949 `__: MAINT: Rename INSTALL.rst.txt to INSTALL.rst +* `#21041 `__: ENH: Implement string comparison ufuncs (or almost) +* `#21084 `__: MAINT: Fix computation of numpy.array_api.linalg.vector_norm +* `#21098 `__: DOC: Fix axis naming in ``argpartition`` docs +* `#21103 `__: NEP: Add NEP 50 draft about fixing scalar promotion rules +* `#21152 `__: DOC: verifying bug existence and fixes - replacement for PR 17851 +* `#21248 `__: DOC: improve description of the ``data`` entry in ``__array_interface__`` +* `#21308 `__: MAINT: Start testing with Python 3.11. +* `#21403 `__: MAINT: remove some names from main numpy namespace +* `#21437 `__: ENH: Add floating point error checking to (almost) all casts +* `#21468 `__: ENH: Use ``threadpoolctl`` in ``show_runtime`` (a new function) +* `#21471 `__: DOC: adding docstring to TooHardError class +* `#21483 `__: SIMD: Use universal intrinsics to implement comparison functions +* `#21501 `__: DOC: improve ``ascontiguousarray()`` and ``asfortranarray()`` examples +* `#21504 `__: MAINT: Fix some typos. +* `#21507 `__: BUG: Better report integer division overflow +* `#21527 `__: PERF: Fast path for dtype lookup of float and long +* `#21537 `__: DOC: Add a policy about inactive PRs. +* `#21564 `__: TST: Enable doctests in IO Howto with testsetup and testcleanup +* `#21567 `__: BUG: Adding the default pytest doctest instead of the ValueError +* `#21572 `__: MAINT: allow absolute module names in refguide-check +* `#21579 `__: DOC: Improve docstring of numpy.testing.assert_allclose +* `#21581 `__: REL: Prepare main for NumPy 1.24.0 development +* `#21582 `__: MAINT: Fix some small refcounting and similar issues +* `#21583 `__: Add ``CODEOWNER`` for the ``array_api`` module +* `#21587 `__: DOC: update logarithm docs as per theory. +* `#21591 `__: BUG, STY: Fix doctest failure in EXAMPLE_DOCSTRING. +* `#21595 `__: ENH: Add strict parameter to assert_array_equal. Fixes #9542 +* `#21596 `__: TYP,MAINT: Allow unsigned integer inplace-ops to accept signed... +* `#21600 `__: DOC: Add missing links for NEP36 and NEP49 +* `#21601 `__: DOC: update NEP29 to address PEP0602 +* `#21602 `__: BUILD: fix tag name for travis: it is v1.23.0rc1 +* `#21605 `__: MAINT: Adapt npt._GenericAlias to Python 3.11 types.GenericAlias... +* `#21609 `__: MAINT: Fix some API versions. +* `#21611 `__: MAINT: make MismatchCAPIWarnining into MismatchCAPIError +* `#21615 `__: MAINT: Remove compatibility shims for old versions of PyPy +* `#21616 `__: DOC: Describe the changed Python release cadence better +* `#21617 `__: MAINT, STY: Make download-wheels download source files. +* `#21620 `__: MAINT: Fortify masked in-place ops against promotion warnings +* `#21622 `__: TST: Skip F2PY tests without Fortran compilers +* `#21623 `__: ENH: Add equals_nans kwarg to np.unique +* `#21624 `__: DOC: move ``import_array`` and ``import_umath`` above ``PyModule_Create`` +* `#21626 `__: API: Introduce optional (and partial) NEP 50 weak scalar logic +* `#21627 `__: ENH: adding casting option to numpy.stack. +* `#21630 `__: MAINT: back out conversion of npymath component to c++ +* `#21632 `__: API: Retain ``arr.base`` more strictly in ``np.frombuffer`` +* `#21639 `__: BUG: use explicit einsum_path whenever it is given +* `#21641 `__: DOC: Note version-switcher update in the release walkthrough +* `#21644 `__: MAINT: Fixup ``unique``'s ``equal_nan`` kwarg to match ``np.array_equal`` +* `#21645 `__: DEP: Remove ``normed=`` keyword argument from histograms +* `#21648 `__: ENH: issue overflow warning when using ``abs`` on ``np.int8(-128)`` +* `#21651 `__: MAINT: Remove unused/not useful CODEOWNERS file again +* `#21654 `__: MAINT: limit the number of decimals in Polynomial representation +* `#21658 `__: MAINT: improved overflow check to avoid undefined behavior +* `#21659 `__: BUG: Fix a bug left after f2py2e refactor +* `#21661 `__: TYP, ENH: Add annotations for the ``equal_nan`` keyword to ``np.unique`` +* `#21662 `__: DOC: ``np`` in double backticks. +* `#21663 `__: DEP: Deprecate (rather than remove) the int-via-float parsing... +* `#21664 `__: DOC: Misc RST reformatting. +* `#21666 `__: MAINT: Change array API unique_*() functions to not compare nans... +* `#21675 `__: DOC: Add note about broadcasting support for ``random.Generator.multinomial`` +* `#21677 `__: DOC: RST Titles Underline reordering +* `#21681 `__: MAINT: Point documentation version switcher at the docs homepage +* `#21687 `__: BUG: switch _CMP_NEQ_OQ to _CMP_NEQ_UQ for npyv_cmpneq_f[32,64] +* `#21689 `__: DOC: Fix broadcasting documentation. +* `#21690 `__: BUG: Prevent attempted broadcasting of 0-D output operands in... +* `#21691 `__: BUG: Small fixupes found using valgrind +* `#21692 `__: MAINT: Renamed doc/records.rst.txt to doc/records.rst +* `#21701 `__: BUG: Enable fortran preprocessing for ifort on Windows +* `#21704 `__: DOC: Mention positional-only arguments in the array API compatibility... +* `#21705 `__: BLD, SIMD: Fix detect armhf and hardened the Neon/ASIMD compile-time... +* `#21707 `__: MAINT: generate_umath.py: do not write full path into output... +* `#21709 `__: TST: Fixup loadtxt int-via-float tests when in release mode +* `#21712 `__: BUG: ``.f2py_f2cmap`` doesn't map ``long_long`` and other options +* `#21715 `__: DOC: Tell people to use only-binary option +* `#21723 `__: DOC: Update sphinx, numpydoc, and pydata-sphinx-theme +* `#21727 `__: MAINT, SIMD: Handle overflow gracefully in integer division +* `#21731 `__: ENH: Ensure dispatcher TypeErrors report original name +* `#21732 `__: ENH: Add support for platforms with missing fenv flags +* `#21733 `__: ENH: Fix pointer size determination for cross build +* `#21734 `__: ENH: Check that we are targeting x86 or x64 architecture before... +* `#21735 `__: ENH: cross compilation: use sysconfig to determine if x86_64... +* `#21745 `__: MAINT: Remove FPE helper code that is unnecessary on C99/C++11 +* `#21748 `__: BUG: Fix for npyv_orc_b8 and npyv_xnor_b8 for s390x (z13) +* `#21749 `__: BUG, SIMD: Fix detecting NEON/ASIMD on aarch64 +* `#21750 `__: CI: Fix CI SIMD build on s390x +* `#21755 `__: BUG: Do not skip value-based promotion path for large Python... +* `#21759 `__: BUG: Fix small reference leaks found with pytest-leaks +* `#21763 `__: MAINT: use f-string format in test_abc.py +* `#21764 `__: BUG: Fix a potential variable misuse bug +* `#21766 `__: CI: Guard compile-time CPU features tests +* `#21771 `__: MAINT: Add a check of the return value of PyMem_Calloc(). +* `#21773 `__: MAINT: fix typo in string_ufuncs.cpp +* `#21776 `__: CI: add workflow for non-optimized builds +* `#21778 `__: MAINT, SIMD: remove orphan path vsx/conversion.h +* `#21779 `__: MAINT: random: Disallow complex inputs in multivariate_normal +* `#21786 `__: MAINT: fix up use of ``NPY_NO_DEPRECATED_API`` usage in f2py +* `#21789 `__: ENH: Change f2c declarations with void return type to int +* `#21790 `__: ENH: add overflow handling for scalar ``negative`` operation +* `#21793 `__: ENH: Add overflow handling for negative integers scalar multiplication +* `#21794 `__: BUG: lib: A loadtxt error message had two values reversed. +* `#21795 `__: ENH: Ensure that assertion of unsigned dtypes does not return... +* `#21796 `__: BUG: Fix comparison for empty structured arrays +* `#21797 `__: MAINT: Reduce object construction in np.require +* `#21798 `__: MAINT: use PyErr_SetString in _import_array where possible +* `#21807 `__: ENH: Handle the value attribute in F2Py wrappers +* `#21812 `__: BUG: Define ``<``, ``<=``, ``>``, ``>=`` for masked arrays +* `#21815 `__: BUG: Fix discovered MachAr (still used within valgrind) +* `#21817 `__: ENH: Always fill object fields with None rather than NULL +* `#21823 `__: MAINT: Try fixing broken Anaconda uploads. +* `#21828 `__: MAINT: Update main after 1.23.0 release. +* `#21830 `__: DOC: Change substract to subtract in comment +* `#21832 `__: PERF: Micro optimize np.linspace +* `#21835 `__: TST: Add f2py CLI tests +* `#21836 `__: DOC: F2PY documentation improvements +* `#21837 `__: DOC: Document expectation for object array initialization +* `#21842 `__: BUG: Fix in1d for empty integer array as input +* `#21844 `__: DOC: Rephrase dimensionality, size in broadcasting.rst +* `#21848 `__: BUG: Handle NaNs correctly for float16 during sorting +* `#21849 `__: MAINT: Update the documentation Makefile +* `#21851 `__: BUG: Use ``keepdims`` during normalization in ``np.average`` and... +* `#21853 `__: DOC: Update the docstring for np.around +* `#21854 `__: DOC: mention changes to ``max_rows`` behaviour in ``np.loadtxt`` +* `#21855 `__: DOC: Replace the mathematical notation N(...) with text. +* `#21856 `__: DOC: Mention uniform in the np.random.Generator.random function. +* `#21857 `__: BUG: Reject non integer array-likes with size 1 in delete +* `#21860 `__: BUG: Fix numpy.isin for timedelta dtype +* `#21861 `__: DOC: clarify loadtxt input cols requirement +* `#21863 `__: ENH,MAINT: Improve and simplify scalar floating point warnings +* `#21872 `__: CI: tools: Remove a long but obsolete comment from travis-test.sh +* `#21875 `__: ENH: Implement correct scalar and integer overflow errors for... +* `#21876 `__: DOC: Fixed minor typo in reference +* `#21877 `__: DOC: dark theme css rules +* `#21879 `__: CI: skip azp and circleCI logic +* `#21881 `__: MAINT: Disable checks for Win workaround for GCC +* `#21884 `__: MAINT: Fix non-void function does not return a value warning +* `#21885 `__: DOC: Link to PEP-484 in the typing docs +* `#21886 `__: Fix lib flags for librandom +* `#21887 `__: BLD: Allow GCC compile on mingw-w64-based systems +* `#21890 `__: BUG: Fix KeyError in crackfortran operator support +* `#21894 `__: BUG: Fix datetime_to_timedelta_resolve_descriptors signature +* `#21895 `__: ENH, CI: Add Emscripten to CI +* `#21896 `__: BLD: Make can_link_svml return False for 32bit builds on x86_64 +* `#21904 `__: DOC: Add usage example to np.char.center docstring +* `#21905 `__: DOC: Fix the interpolation formulae for quantile and percentile +* `#21909 `__: DOC: fix typo in ``numpy._typing._NestedSequence`` docstring example +* `#21921 `__: DOC: Fix typo on Byte-swapping page +* `#21922 `__: DOC: fix typo on custom array containers page +* `#21924 `__: CI: Use OpenBLAS again on Cygwin +* `#21925 `__: BUG: Fix subarray to object cast ownership details +* `#21926 `__: MAINT: random: Annotate default_rng with cython.embedsignature +* `#21927 `__: DOC: Add a note about security and NumPy to the documentation +* `#21928 `__: BUG: Fix the implementation of numpy.array_api.vecdot +* `#21943 `__: DOC, MAINT: Document the C-API incompatibility error and point... +* `#21945 `__: MAINT, DOC: Update release guide +* `#21946 `__: BUG: Reorder extern "C" to only apply to function declarations... +* `#21948 `__: [DOC] Double backticks in lagfit. +* `#21954 `__: TST: Add tests for FP16 umath functions +* `#21955 `__: ENH: Vectorize FP16 umath functions using AVX512 +* `#21956 `__: MAINT: Update main after 1.23.1 release. +* `#21957 `__: TYP,ENH: Mark all unhashable classes as such +* `#21959 `__: BUG: Use ``Popen`` to silently invoke f77 -v +* `#21960 `__: Revert "ENH: Adding __array_ufunc__ capability to MaskedArrays" +* `#21963 `__: BLD: remove outdated pin for ``packaging`` on macOS arm64 +* `#21965 `__: Added priority in bug-report issue-template +* `#21968 `__: ENH: Add ``__array_ufunc__`` typing support to the ``nin=1`` ufuncs +* `#21973 `__: DOC: correct docstring for numpy.correlate() +* `#21974 `__: MAINT, TYP: Fix ``np.angle`` dtype-overloads +* `#21976 `__: ENH: Add the capability to swap the singleton bit generator +* `#21977 `__: ENH: Adding __array_ufunc__ capability to MaskedArrays +* `#21979 `__: BUG: Fix experimental dtype slot numbers +* `#21981 `__: TST: ensure ``np.equal.reduce`` raises a ``TypeError`` +* `#21982 `__: MAINT: Do not let ``_GenericAlias`` wrap the underlying classes'... +* `#21983 `__: TYP,MAINT: Allow ``einsum`` subscripts to be passed via integer... +* `#21984 `__: MAINT,TYP: Add object-overloads for the ``np.generic`` rich comparisons +* `#21986 `__: MAINT: Remove two unused imports +* `#21991 `__: MAINT: rm old warning +* `#21992 `__: DOC: cross-reference descriptions of frombuffer and ndarray.tobytes +* `#21993 `__: BUG: fix ma.minimum.reduce with axis keyword +* `#21995 `__: BUG: Distinguish exact vs. equivalent dtype for C type aliases. +* `#21996 `__: BUG: Avoid errors on NULL during deepcopy +* `#21997 `__: DOC: unify ``np.transpose``, ``np.ndarray.transpose``, and ``np.ndarray.T`` +* `#21999 `__: BUG: Fix masked median bug +* `#22000 `__: DOC: some improvements in the NumPy/MATLAB comparison +* `#22002 `__: DOC: add links to ``linalg`` in docs of ``dot`` and ``matmul`` +* `#22004 `__: DEP: Finalize ragged array creation deprecation +* `#22008 `__: MAINT: remove unneeded ``__future__`` imports +* `#22009 `__: BUG: fix np.average for Fraction elements +* `#22010 `__: DOC: Add versionchanged for converter callable behavior. +* `#22013 `__: DOC: updated masked_print_option and added explanation +* `#22014 `__: BUG/ENH: Allow bit generators to supply their own constructor +* `#22016 `__: BUG: Revert using __array_ufunc__ for MaskedArray +* `#22017 `__: ENH: reorder includes for testing on top of system installations... +* `#22022 `__: MAINT,TYP: Allow the ``squeeze`` and ``transpose`` method to... +* `#22024 `__: BUG: Expose string_heapsort algorithm in a shared header +* `#22043 `__: BLD: use macos-11 image on azure, macos-1015 is deprecated +* `#22045 `__: ENH: allow importlib.LazyLoader to work with numpy and add test... +* `#22046 `__: BUG: Make ``mask_invalid`` consistent with ``mask_where`` if ``copy``... +* `#22053 `__: MAINT: Quiet the anaconda uploads. +* `#22060 `__: PERF: Improve import time of numpy +* `#22071 `__: MAINT: fix typo in test_array_object.py +* `#22081 `__: PERF: Remove numpy.compat._pep440 from default imports +* `#22083 `__: BUG: Fix skip condition for test_loss_of_precision[complex256] +* `#22087 `__: ENH: raise TypeError when arange() is called with string dtype +* `#22090 `__: MAINT: Simplify npymath +* `#22096 `__: PERF: Improve intrinsics for tobits and pack on Apple silicon +* `#22099 `__: TST: Remove workaround for gh-9968 from ``test_scalar_methods.test_roundtrip`` +* `#22102 `__: BLD: Try building python3.11 wheels. +* `#22105 `__: TST: fix test_linear_interpolation_formula_symmetric +* `#22110 `__: BUG: Address failures in aarch64 gcc builds due to #22096 +* `#22111 `__: BUG: Missed a case in the diff merge for #22110 +* `#22112 `__: MAINT: remove redundant reversal of eigenvalues order in svd... +* `#22116 `__: MAINT,DOC: Remove sphinx-panels in favor of sphinx-design +* `#22117 `__: DOC: Reorganize user guide outline +* `#22118 `__: DOC: Fix documentation for percentile and quantile +* `#22120 `__: DOC: Explain spawn_key a little more. +* `#22122 `__: DOC: Explain how to use sequences of integers as seeds. +* `#22124 `__: MAINT: support IBM i system +* `#22127 `__: BLD: Add Python 3.11 wheels to aarch64 build +* `#22130 `__: MAINT: Update main after 1.23.2 release. +* `#22132 `__: DOC: Add a release note for bit generator reduce changes +* `#22139 `__: DEP: drop support for msvc<=1900 and Interix +* `#22142 `__: MAINT: Update setup.py for Python 3.11. +* `#22143 `__: MAINT: Update the RELEASE_WALKTHROUGH file. +* `#22144 `__: DOC: Add missing word +* `#22147 `__: DOC: fix linalg.tensorsolve docstring +* `#22149 `__: DOC: Copy-edit the 'partition' docstring. +* `#22150 `__: CI: Test NumPy build against old versions of GCC(6, 7, 8) +* `#22152 `__: BUG: Support using libunwind for backtrack +* `#22154 `__: DOC: add more prominent warnings to pin setuptools +* `#22159 `__: DEP: drop older cygwin compatibility shims +* `#22161 `__: MAINT: simplify complex math function handling in npymath +* `#22163 `__: PERF: Eliminate slow check for pypy during numpy import +* `#22164 `__: ENH: Improve tanh for architectures without efficient gather/scatter... +* `#22168 `__: ENH: Remove AVX related functions from non x86 based builds +* `#22169 `__: MAINT: fix defines for universal2 python builds of NumPy +* `#22171 `__: DOC: Note symmetry requirement in ``multivariate_normal`` error +* `#22179 `__: TST: Implemented an unused test for np.random.randint +* `#22189 `__: MAINT: fix an incorrect pointer type usage in f2py +* `#22193 `__: BUG: change overloads to play nice with pyright. +* `#22194 `__: BUG: Fix circleci build +* `#22199 `__: MAINT: Unpin towncrier +* `#22204 `__: TST,BUG: Use fork context to fix MacOS savez test +* `#22205 `__: DOC: Clarify that ``like`` is not passed to ``function`` +* `#22206 `__: DOC: Fix typo disutils -> distutils in numpy.distutils migration... +* `#22210 `__: DOC: Fix typos in cast warning release note +* `#22212 `__: TYP,BUG: Reduce argument validation in C-based ``__class_getitem__`` +* `#22227 `__: DOC: fix up release note +* `#22228 `__: MAINT: Remove long deprecated functionality from np.ma +* `#22235 `__: Remove incorrect comment about checking generated C files in +* `#22236 `__: BUG: Fix incorrect refcounting in new ``asarray`` path +* `#22239 `__: MAINT: Update main after 1.23.3 release. +* `#22240 `__: ENH: Use SVML for fp32 and fp64 power and arctan2 +* `#22242 `__: BLD: add back stdlib.h include in pcg64.h +* `#22245 `__: MAINT: random: remove ``get_info`` from "extending with Cython"... +* `#22251 `__: TST: Move new ``asarray`` test to a more appropriate place. +* `#22253 `__: DOC: Update concatenate exception message. +* `#22254 `__: DOC: Improve ``converters`` parameter description for loadtxt +* `#22256 `__: DOC: Add C API example for NPY_ITER_MULTI_INDEX +* `#22259 `__: DOC: Better report integer division overflow (#21506) +* `#22261 `__: NEP: Make NEP 51 to propose changing the scalar representation +* `#22263 `__: DOC: Clarified how finfo works with complex numbers (#22260) +* `#22272 `__: MAINT, Haiku defines neither __STDC_NO_THREADS__ nor __GLIBC__ +* `#22276 `__: DOC: Update for return value of np.ptp() +* `#22279 `__: DOC: Add example to msort docstring +* `#22280 `__: DOC: updated the description for array-like type in histogramdd... +* `#22282 `__: DOC: Add example for find +* `#22285 `__: DOC: Add ``isupper`` examples +* `#22291 `__: DOC: Add examples for isdigit and str_len +* `#22292 `__: DOC: Add copyto example +* `#22294 `__: DOC: add examples to np.char.multiply +* `#22295 `__: DOC: Added an example for isupper() function +* `#22296 `__: BUG: Memory leaks in numpy.nested_iters +* `#22297 `__: DOC: Add example to np.prod +* `#22298 `__: DOC: add example for ma.unique function +* `#22299 `__: DOC: Add examples for join and index +* `#22300 `__: DOC: examples for ``np.char.isdecimal`` and ``np.char.isnumeric`` +* `#22302 `__: DOC: Change in the documentation for chebpts2 method +* `#22304 `__: DOC: default_rng cleanup +* `#22306 `__: ENH: Implement essential intrinsics required by the upcoming... +* `#22308 `__: DOC: add examples to numpy.char.replace +* `#22309 `__: DOC: Correct usage example for np.char.decode docstring +* `#22312 `__: MAINT: Shorten test output on travis builds +* `#22313 `__: DEP: Deprecate fastCopyAndTranspose +* `#22314 `__: MAINT: Shorten wheel test output on travis builds +* `#22316 `__: ENH: Allow creating structured void scalars by passing dtype +* `#22319 `__: TST: add functional tests for kron +* `#22321 `__: MAINT: core: Fix a typo in a datetime error message. +* `#22324 `__: MAINT: update function's __module__ attribute in deprecate +* `#22325 `__: SIMD: Improve the performance of NEON vector initializer +* `#22326 `__: CI, SIMD: Test and build without the support of AVX2 and AVX512 +* `#22327 `__: BUG: Fix complex vector dot with more than NPY_CBLAS_CHUNK elements +* `#22331 `__: DOC: Adding examples to ``ma.max`` function +* `#22332 `__: DOC: Minor typo in docs +* `#22334 `__: DOC: Added missing dtype attribute to ``iinfo`` and ``finfo`` docstring +* `#22336 `__: MAINT: Rm numpydoc remnant example docstring. +* `#22342 `__: MAINT: update sde toolkit to 9.0, fix download link +* `#22343 `__: DOC: fixed two more typos in docstrings +* `#22344 `__: DOC: fixed minor typo in percentile docstring +* `#22354 `__: MAINT: switch sponsor link from numfocus to opencollective +* `#22356 `__: REV: Loosen ``lookfor``'s import try/except again +* `#22357 `__: TYP,ENH: Mark ``numpy.typing`` protocols as runtime checkable +* `#22358 `__: ENH,TYP: Add special casing for ``ndarray``-based indexing +* `#22359 `__: TYP,MAINT: Change more overloads to play nice with pyright +* `#22360 `__: TST,TYP: Bump mypy to 0.981 +* `#22362 `__: DOC: Updated amin/amax output dimensions for tuple axis +* `#22363 `__: DOC: Added examples to ``maa.min`` function +* `#22365 `__: BUG: Add ``__array_api_version__`` to ``numpy.array_api`` namespace +* `#22367 `__: BUILD: add permissions to github actions +* `#22371 `__: MAINT: remove permission restrictions for PR labeler [skip ci] +* `#22372 `__: DOC: Update delimiter param description. +* `#22373 `__: DOC, MAINT: Remove unused files +* `#22374 `__: DOC: typo additional colon in beginners tutorial +* `#22375 `__: DOC: How to partition domains +* `#22379 `__: ENH: allow explicit ``like=None`` in all array creation functions +* `#22385 `__: DEP: Deprecate conversion of out-of-bound Python integers +* `#22393 `__: MAINT: Ensure graceful handling of large header sizes +* `#22398 `__: DOC: Update broken link to diataxis framework. +* `#22399 `__: MAINT: Fix typos found by codespell +* `#22401 `__: MAINT: fix obsolete code comment +* `#22404 `__: DOC: added ``ma.round`` and ``ma.round_`` examples +* `#22406 `__: DOC: Add changelog for ``masked_invalid`` change. +* `#22407 `__: DOC: Fix title level for release note improvements +* `#22409 `__: DOC: Adopt a harmonic color scheme with the dark mode of pydata-sphinx-theme +* `#22411 `__: DOC: Remove documentation specific to Python 2 +* `#22418 `__: TST, BLD: Fix failing aarch64 wheel builds. +* `#22419 `__: MAINT: Remove PyCObject from the SWIG interface +* `#22421 `__: DOC: Replace CObject with Capsule consistently +* `#22422 `__: ENH: Expose ``ufunc.resolve_dtypes`` and strided loop access +* `#22430 `__: MAINT: Update main after 1.23.4 release. +* `#22432 `__: MAINT: always use sys.base_prefix, never use sys.real_prefix +* `#22433 `__: DOC: remove reference to Python 2 +* `#22436 `__: DOC: Clarify docstring of ``masked_equal`` and ``masked_values`` +* `#22438 `__: MAINT: Update versioneer 0.19 → 0.26 +* `#22440 `__: MAINT: fix typo in f2c_lapack.c +* `#22441 `__: MAINT,DOC: Revert "MAINT: fix typo in f2c_lapack.c" +* `#22442 `__: ENH: unstructured_to_structured converts dtype argument +* `#22447 `__: TYP: Spelling alignment for array flag literal +* `#22450 `__: BUG: Fix bounds checking for random.logseries +* `#22452 `__: DEV: Update GH actions and Dockerfile for Gitpod +* `#22453 `__: DOC: Update NEP 50 text since integer conversion errors now exist. +* `#22456 `__: DEP: Proposal to deprecate the ``msort`` convenience function +* `#22458 `__: ENH: Allow all allocated operands in nditer/NpyIter +* `#22462 `__: MAINT: refactor mandatory npymath functions to #define macros +* `#22463 `__: DOC: remove mention of ``ipython -p numpy``. +* `#22466 `__: MAINT: Ensure that fmin loops do not show up multiple times +* `#22475 `__: MAINT: remove code specific to Python 2 +* `#22478 `__: BUG: -unsigned_int(0) no overflow warning +* `#22479 `__: MAINT: remove u-prefix for former Unicode strings +* `#22480 `__: DOC: fix typo in advanced_debugging.rst [skip ci] +* `#22481 `__: GitHub Workflows security hardening +* `#22482 `__: ENH: Add OpenSSF Scorecard GitHub Action +* `#22483 `__: MAINT: change subprocess arguments from Python>=3.7 +* `#22485 `__: TST: Make test_partial_iteration_cleanup robust but require leak... +* `#22487 `__: TST, MAINT: Replace most setup with setup_method (also teardown) +* `#22488 `__: MAINT, CI: Switch to cygwin/cygwin-install-action@v2 +* `#22491 `__: CI: Make cygwin build run for branches. +* `#22496 `__: MAINT: Use SPDX license expression in project metadata +* `#22498 `__: REL: readme in PyPI plus test +* `#22500 `__: DOC: added example in char +* `#22503 `__: CI: Only fetch in actions/checkout +* `#22504 `__: DOC: Add code-formatting on install instructions +* `#22505 `__: DOC: fixed minor typo in f2py docs +* `#22510 `__: MAINT: Ensure raw dlpack deleter works when called without the... +* `#22519 `__: DOC: fixed pad_width description in numpy.pad +* `#22521 `__: DOC: Remove "current" from byte-order note and expand it slightly +* `#22524 `__: MAINT, BLD: Wheel CI: Update cibuildwheel to 2.11.2 +* `#22525 `__: BLD: update OpenBLAS to 0.3.21 and clean up openblas download... +* `#22531 `__: BLD, CI: Update setup-python +* `#22538 `__: DOC: update libnpymath docs on its status and how to consume... +* `#22540 `__: DEP: Expire deprecation of dtype/signature allowing instances +* `#22541 `__: DEP: Expire deprecation to ignore bad dtype= in logical ufuncs +* `#22542 `__: API: Always use BufferError when dlpack export fails +* `#22543 `__: DOC: Add instruction to initialize git submodules +* `#22548 `__: MAINT: Fix designator order not matching declaration order +* `#22550 `__: MAINT: Fix Fortran order flag use (using bool rather than enum) +* `#22552 `__: MAINT: Do not use temporary struct construct +* `#22554 `__: MAINT: Match arguments of constant in ``isless()`` +* `#22557 `__: BUG: Decrement ref count in gentype_reduce if allocated memory... +* `#22561 `__: BUG: Histogramdd breaks on big arrays in Windows +* `#22566 `__: BUG: Fix use and errorchecking of ObjectType use +* `#22567 `__: CI: Add PR write permissions to artifact redirector. +* `#22571 `__: DOC: Mention numpy types in ``isnat`` error message +* `#22576 `__: BUG: fix issue with broken assert statement in ``templ_common.h.src`` +* `#22578 `__: BLD: fix issue with header includes in dlpack.c +* `#22579 `__: MAINT: remove ``NPY_RESTRICT`` in favor of C99 ``restrict`` +* `#22580 `__: BLD: remove unused ``ncola`` variables from lapack-lite +* `#22583 `__: MAINT: Patch to remove ncola variable from f2c_blas.c +* `#22586 `__: MAINT: Rm meaningless checks in determining typeless data +* `#22587 `__: TYP: Update type annotations for new 1.24 features +* `#22588 `__: DOC: Clarify relationship between row_stack and vstack. +* `#22589 `__: DOC: expand docs on debugging with gdb +* `#22598 `__: MAINT, CI: Update Ubuntu 18.04 to Ubuntu 20.04 +* `#22601 `__: MAINT: Use C99 flexible struct construct for ``NpyIter_InternalOnly`` +* `#22605 `__: MAINT: (array-coercion) Silence invalid read warning in some... +* `#22607 `__: DEP: Next step in scalar type alias deprecations/futurewarnings +* `#22608 `__: MAINT, CI: Enable coverage checking. +* `#22612 `__: BLD: update wheel builds on macos to macos-12 image +* `#22614 `__: MAINT: remove macOS specific long double handling in numpyconfig.h +* `#22615 `__: DOC: Rm ``round_`` from the autosummary for rounding +* `#22616 `__: TST: Rename setup to setup_method in _locales +* `#22620 `__: DOC: testing: Fix typo: nulps -> nulp +* `#22628 `__: DOC: Add example for np.ma.power +* `#22629 `__: MAINT: Update main after 1.23.5 release. +* `#22630 `__: BLD: Use cibuildwheel 2.9.0 for Python 3.8 aarch64 builds +* `#22634 `__: CI: Increase travis timeout to 20 minutes. +* `#22636 `__: CI: Increase travis timeout to 30 minutes (2). +* `#22639 `__: DOC: Remove traces of interrupt handling utilities +* `#22662 `__: rel: prepare for the numpy 1.24.0rc1 release. +* `#22665 `__: MAINT: Fix 1.24.0 release note markup. +* `#22697 `__: MAINT: Rename symbols in textreading/ that may clash when statically... +* `#22698 `__: MAINT: check user-defined dtype has an ensure_canonical implementation +* `#22699 `__: BUG: Ensure string aliases "int0", etc. remain valid for now +* `#22700 `__: BLD: revert function() -> #define for 3 npymath functions +* `#22702 `__: MAINT: pin ubuntu and python for emscripten +* `#22716 `__: BLD, CI: Use cirrus for building aarch64 wheels +* `#22717 `__: TST: Skip when numba/numpy compat issues cause SystemError +* `#22719 `__: CI: Make benchmark asv run quick to only check that benchmarks... +* `#22729 `__: REL: Prepare for the NumPy 1.24.0rc2 release. +* `#22743 `__: DOC: Fix release note link to out-of-bounds integer deprecation +* `#22746 `__: BUG: Fix some valgrind errors (and probably harmless warnings) +* `#22748 `__: BUG: ``keepdims=True`` is ignored if ``out`` is not ``None``... +* `#22749 `__: MAINT: check if PyArrayDTypeMeta_Spec->casts is set +* `#22757 `__: CI: fix CIRRUS_TAG check when tagging. Closes #22730. +* `#22758 `__: DOC: Some updates to the array_api compat document (#22747) +* `#22759 `__: BUG, SIMD: Fix rounding large numbers >= 2^52 on SSE2 +* `#22760 `__: CI, SIMD: Add workflow to test default baseline features only +* `#22761 `__: BUG: Fix deepcopy cleanup on error +* `#22793 `__: BUG: Fix infinite recursion in longdouble/large integer scalar... +* `#22795 `__: BUG: Ensure arguments to ``npy_floatstatus_..._barrier()`` can... +* `#22805 `__: REV: revert change to ``numpyconfig.h`` for sizeof(type) hardcoding... +* `#22815 `__: BLD: use newer version of delocate diff --git a/doc/changelog/1.24.1-changelog.rst b/doc/changelog/1.24.1-changelog.rst new file mode 100644 index 000000000000..5650438b6c41 --- /dev/null +++ b/doc/changelog/1.24.1-changelog.rst @@ -0,0 +1,43 @@ + +Contributors +============ + +A total of 12 people contributed to this release. People with a "+" by their +names contributed a patch for the first time. + +* Andrew Nelson +* Ben Greiner + +* Charles Harris +* Clément Robert +* Matteo Raso +* Matti Picus +* Melissa Weber Mendonça +* Miles Cranmer +* Ralf Gommers +* Rohit Goswami +* Sayed Adel +* Sebastian Berg + +Pull requests merged +==================== + +A total of 18 pull requests were merged for this release. + +* `#22820 `__: BLD: add workaround in setup.py for newer setuptools +* `#22830 `__: BLD: CIRRUS_TAG redux +* `#22831 `__: DOC: fix a couple typos in 1.23 notes +* `#22832 `__: BUG: Fix refcounting errors found using pytest-leaks +* `#22834 `__: BUG, SIMD: Fix invalid value encountered in several ufuncs +* `#22837 `__: TST: ignore more np.distutils.log imports +* `#22839 `__: BUG: Do not use getdata() in np.ma.masked_invalid +* `#22847 `__: BUG: Ensure correct behavior for rows ending in delimiter in... +* `#22848 `__: BUG, SIMD: Fix the bitmask of the boolean comparison +* `#22857 `__: BLD: Help raspian arm + clang 13 about __builtin_mul_overflow +* `#22858 `__: API: Ensure a full mask is returned for masked_invalid +* `#22866 `__: BUG: Polynomials now copy properly (#22669) +* `#22867 `__: BUG, SIMD: Fix memory overlap in ufunc comparison loops +* `#22868 `__: BUG: Fortify string casts against floating point warnings +* `#22875 `__: TST: Ignore nan-warnings in randomized out tests +* `#22883 `__: MAINT: restore npymath implementations needed for freebsd +* `#22884 `__: BUG: Fix integer overflow in in1d for mixed integer dtypes #22877 +* `#22887 `__: BUG: Use whole file for encoding checks with ``charset_normalizer``. diff --git a/doc/changelog/1.24.2-changelog.rst b/doc/changelog/1.24.2-changelog.rst new file mode 100644 index 000000000000..399092eb0ef4 --- /dev/null +++ b/doc/changelog/1.24.2-changelog.rst @@ -0,0 +1,44 @@ + +Contributors +============ + +A total of 14 people contributed to this release. People with a "+" by their +names contributed a patch for the first time. + +* Bas van Beek +* Charles Harris +* Khem Raj + +* Mark Harfouche +* Matti Picus +* Panagiotis Zestanakis + +* Peter Hawkins +* Pradipta Ghosh +* Ross Barnowski +* Sayed Adel +* Sebastian Berg +* Syam Gadde + +* dmbelov + +* pkubaj + + +Pull requests merged +==================== + +A total of 17 pull requests were merged for this release. + +* `#22965 `__: MAINT: Update python 3.11-dev to 3.11. +* `#22966 `__: DOC: Remove dangling deprecation warning +* `#22967 `__: ENH: Detect CPU features on FreeBSD/powerpc64* +* `#22968 `__: BUG: np.loadtxt cannot load text file with quoted fields separated... +* `#22969 `__: TST: Add fixture to avoid issue with randomizing test order. +* `#22970 `__: BUG: Fix fill violating read-only flag. (#22959) +* `#22971 `__: MAINT: Add additional information to missing scalar AttributeError +* `#22972 `__: MAINT: Move export for scipy arm64 helper into main module +* `#22976 `__: BUG, SIMD: Fix spurious invalid exception for sin/cos on arm64/clang +* `#22989 `__: BUG: Ensure correct loop order in sin, cos, and arctan2 +* `#23030 `__: DOC: Add version added information for the strict parameter in... +* `#23031 `__: BUG: use ``_Alignof`` rather than ``offsetof()`` on most compilers +* `#23147 `__: BUG: Fix for npyv__trunc_s32_f32 (VXE) +* `#23148 `__: BUG: Fix integer / float scalar promotion +* `#23149 `__: BUG: Add missing header. +* `#23150 `__: TYP, MAINT: Add a missing explicit ``Any`` parameter to the ``npt.ArrayLike``... +* `#23161 `__: BLD: remove redundant definition of npy_nextafter [wheel build] diff --git a/doc/changelog/1.24.3-changelog.rst b/doc/changelog/1.24.3-changelog.rst new file mode 100644 index 000000000000..b86bd25e4fab --- /dev/null +++ b/doc/changelog/1.24.3-changelog.rst @@ -0,0 +1,42 @@ + +Contributors +============ + +A total of 12 people contributed to this release. People with a "+" by their +names contributed a patch for the first time. + +* Aleksei Nikiforov + +* Alexander Heger +* Bas van Beek +* Bob Eldering +* Brock Mendel +* Charles Harris +* Kyle Sunden +* Peter Hawkins +* Rohit Goswami +* Sebastian Berg +* Warren Weckesser +* dependabot[bot] + +Pull requests merged +==================== + +A total of 17 pull requests were merged for this release. + +* `#23206 `__: BUG: fix for f2py string scalars (#23194) +* `#23207 `__: BUG: datetime64/timedelta64 comparisons return NotImplemented +* `#23208 `__: MAINT: Pin matplotlib to version 3.6.3 for refguide checks +* `#23221 `__: DOC: Fix matplotlib error in documentation +* `#23226 `__: CI: Ensure submodules are initialized in gitpod. +* `#23341 `__: TYP: Replace duplicate reduce in ufunc type signature with reduceat. +* `#23342 `__: TYP: Remove duplicate CLIP/WRAP/RAISE in __init__.pyi. +* `#23343 `__: TYP: Mark ``d`` argument to fftfreq and rfftfreq as optional... +* `#23344 `__: TYP: Add type annotations for comparison operators to MaskedArray. +* `#23345 `__: TYP: Remove some stray type-check-only imports of ``msort`` +* `#23370 `__: BUG: Ensure like is only stripped for `like=` dispatched functions +* `#23543 `__: BUG: fix loading and storing big arrays on s390x +* `#23544 `__: MAINT: Bump larsoner/circleci-artifacts-redirector-action +* `#23634 `__: BUG: Ignore invalid and overflow warnings in masked setitem +* `#23635 `__: BUG: Fix masked array raveling when `order="A"` or `order="K"` +* `#23636 `__: MAINT: Update conftest for newer hypothesis versions +* `#23637 `__: BUG: Fix bug in parsing F77 style string arrays. diff --git a/doc/conftest.py b/doc/conftest.py new file mode 100644 index 000000000000..5e00b1e127fe --- /dev/null +++ b/doc/conftest.py @@ -0,0 +1,32 @@ +""" +Pytest configuration and fixtures for the Numpy test suite. +""" +import pytest +import numpy +import matplotlib +import doctest + +matplotlib.use('agg', force=True) + +# Ignore matplotlib output such as ``. doctest monkeypatching inspired by +# https://github.com/wooyek/pytest-doctest-ellipsis-markers (MIT license) +OutputChecker = doctest.OutputChecker + +empty_line_markers = ['>> a = [1, 2, 3] - >>> print([x + 3 for x in a]) - [4, 5, 6] - >>> print("a\n\nb") - a - b - - """ - - pass diff --git a/doc/neps/.gitignore b/doc/neps/.gitignore index 04163f7079c8..e5d89d1b2eab 100644 --- a/doc/neps/.gitignore +++ b/doc/neps/.gitignore @@ -1 +1,7 @@ -index.rst +accepted.rst +deferred.rst +finished.rst +meta.rst +open.rst +provisional.rst +rejected.rst diff --git a/doc/neps/_static/nep-0050-promotion-no-fonts.svg b/doc/neps/_static/nep-0050-promotion-no-fonts.svg new file mode 100644 index 000000000000..579480132b3d --- /dev/null +++ b/doc/neps/_static/nep-0050-promotion-no-fonts.svg @@ -0,0 +1,1471 @@ + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/doc/neps/_static/nep-0050-promotion.svg b/doc/neps/_static/nep-0050-promotion.svg new file mode 100644 index 000000000000..87abf9b7e5b8 --- /dev/null +++ b/doc/neps/_static/nep-0050-promotion.svg @@ -0,0 +1,685 @@ + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + complex64 + + + + Python complex + + + + Python float + + + + Python int + + + clongdouble + + complex128 + + longdouble + + float64 + + float32 + + + float16 + + + int64 + + + int32 + + + int16 + int8 + + uint64 + + uint32 + + uint16 + uint8 + DType “kind” + DType precision + + + + + Promotionpaths + + + + Minimum Python scalarprecision when other is integral/boolean + + + + Python scalars + + + integral + inexact + + + + diff --git a/doc/neps/accepted.rst.tmpl b/doc/neps/accepted.rst.tmpl new file mode 100644 index 000000000000..8e1ce333a1fe --- /dev/null +++ b/doc/neps/accepted.rst.tmpl @@ -0,0 +1,9 @@ +Accepted NEPs (implementation in progress) +------------------------------------------ + +.. toctree:: + :maxdepth: 1 + +{% for nep, tags in neps.items() if tags['Status'] == 'Accepted' %} + {{ tags['Title'] }} <{{ tags['Filename'] }}> +{% endfor %} diff --git a/doc/neps/conf.py b/doc/neps/conf.py index 68805e50faf0..10644a190466 100644 --- a/doc/neps/conf.py +++ b/doc/neps/conf.py @@ -47,18 +47,19 @@ master_doc = 'content' # General information about the project. -project = u'NumPy Enhancement Proposals' -copyright = u'2017-2018, NumPy Developers' -author = u'NumPy Developers' +project = 'NumPy Enhancement Proposals' +copyright = '2017-2018, NumPy Developers' +author = 'NumPy Developers' +title = 'NumPy Enhancement Proposals Documentation' # The version info for the project you're documenting, acts as replacement for # |version| and |release|, also used in various other places throughout the # built documents. # # The short X.Y version. -version = u'' +version = '' # The full version, including alpha/beta/rc tags. -release = u'' +release = '' # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. @@ -86,6 +87,8 @@ html_logo = '../source/_static/numpylogo.svg' +html_favicon = '../source/_static/favicon/favicon.ico' + html_theme_options = { "github_url": "https://github.com/numpy/numpy", "twitter_url": "https://twitter.com/numpy_team", @@ -106,8 +109,6 @@ html_domain_indices = False html_file_suffix = '.html' -htmlhelp_basename = 'numpy' - if 'sphinx.ext.pngmath' in extensions: pngmath_use_preview = True pngmath_dvipng_args = ['-gamma', '1.5', '-D', '96', '-bg', 'Transparent'] @@ -147,8 +148,8 @@ # (source start file, target name, title, # author, documentclass [howto, manual, or own class]). latex_documents = [ - (master_doc, 'NumPyEnhancementProposals.tex', u'NumPy Enhancement Proposals Documentation', - u'NumPy Developers', 'manual'), + (master_doc, 'NumPyEnhancementProposals.tex', title, + 'NumPy Developers', 'manual'), ] @@ -157,7 +158,7 @@ # One entry per manual page. List of tuples # (source start file, name, description, authors, manual section). man_pages = [ - (master_doc, 'numpyenhancementproposals', u'NumPy Enhancement Proposals Documentation', + (master_doc, 'numpyenhancementproposals', title, [author], 1) ] @@ -168,7 +169,7 @@ # (source start file, target name, title, author, # dir menu entry, description, category) texinfo_documents = [ - (master_doc, 'NumPyEnhancementProposals', u'NumPy Enhancement Proposals Documentation', + (master_doc, 'NumPyEnhancementProposals', title, author, 'NumPyEnhancementProposals', 'One line description of project.', 'Miscellaneous'), ] diff --git a/doc/neps/deferred.rst.tmpl b/doc/neps/deferred.rst.tmpl new file mode 100644 index 000000000000..55074bf07ef8 --- /dev/null +++ b/doc/neps/deferred.rst.tmpl @@ -0,0 +1,9 @@ +Deferred and Superseded NEPs +---------------------------- + +.. toctree:: + :maxdepth: 1 + +{% for nep, tags in neps.items() if tags['Status'] in ('Deferred', 'Superseded') %} + {{ tags['Title'] }} <{{ tags['Filename'] }}> +{% endfor %} diff --git a/doc/neps/finished.rst.tmpl b/doc/neps/finished.rst.tmpl new file mode 100644 index 000000000000..0b9ba8a4aded --- /dev/null +++ b/doc/neps/finished.rst.tmpl @@ -0,0 +1,9 @@ +Finished NEPs +------------- + +.. toctree:: + :maxdepth: 1 + +{% for nep, tags in neps.items() if tags['Status'] == 'Final' %} + {{ tags['Title'] }} <{{ tags['Filename'] }}> +{% endfor %} diff --git a/doc/neps/index.rst b/doc/neps/index.rst new file mode 100644 index 000000000000..0530308525d1 --- /dev/null +++ b/doc/neps/index.rst @@ -0,0 +1,32 @@ +===================================== +Roadmap & NumPy Enhancement Proposals +===================================== + +This page provides an overview of development priorities for NumPy. +Specifically, it contains a roadmap with a higher-level overview, as +well as NumPy Enhancement Proposals (NEPs)—suggested changes +to the library—in various stages of discussion or completion (see `NEP +0 `__). + +Roadmap +------- +.. toctree:: + :maxdepth: 1 + + The Scope of NumPy + Current roadmap + Wish list + +NumPy Enhancement Proposals (NEPs) +---------------------------------- + +.. toctree:: + :maxdepth: 2 + + meta + provisional + accepted + open + finished + deferred + rejected diff --git a/doc/neps/index.rst.tmpl b/doc/neps/index.rst.tmpl deleted file mode 100644 index 0299f8671f10..000000000000 --- a/doc/neps/index.rst.tmpl +++ /dev/null @@ -1,100 +0,0 @@ -===================================== -Roadmap & NumPy Enhancement Proposals -===================================== - -This page provides an overview of development priorities for NumPy. -Specifically, it contains a roadmap with a higher-level overview, as -well as NumPy Enhancement Proposals (NEPs)—suggested changes -to the library—in various stages of discussion or completion (see `NEP -0 `__). - -Roadmap -------- -.. toctree:: - :maxdepth: 1 - - The Scope of NumPy - Current roadmap - Wish list - -Meta-NEPs (NEPs about NEPs or Processes) ----------------------------------------- - -.. toctree:: - :maxdepth: 1 - -{% for nep, tags in neps.items() if tags['Status'] == 'Active' %} - {{ tags['Title'] }} <{{ tags['Filename'] }}> -{% endfor %} - - nep-template - - -{% if has_provisional %} - -Provisional NEPs (provisionally accepted; interface may change) ---------------------------------------------------------------- - -.. toctree:: - :maxdepth: 1 - -{% for nep, tags in neps.items() if tags['Status'] == 'Provisional' %} - {{ tags['Title'] }} <{{ tags['Filename'] }}> -{% endfor %} - -{% endif %} - - -Accepted NEPs (implementation in progress) ------------------------------------------- - -.. toctree:: - :maxdepth: 1 - -{% for nep, tags in neps.items() if tags['Status'] == 'Accepted' %} - {{ tags['Title'] }} <{{ tags['Filename'] }}> -{% endfor %} - - -Open NEPs (under consideration) -------------------------------- - -.. toctree:: - :maxdepth: 1 - -{% for nep, tags in neps.items() if tags['Status'] == 'Draft' %} - {{ tags['Title'] }} <{{ tags['Filename'] }}> -{% endfor %} - - - -Finished NEPs ----------------- - -.. toctree:: - :maxdepth: 1 - -{% for nep, tags in neps.items() if tags['Status'] == 'Final' %} - {{ tags['Title'] }} <{{ tags['Filename'] }}> -{% endfor %} - -Deferred and Superseded NEPs ----------------------------- - -.. toctree:: - :maxdepth: 1 - -{% for nep, tags in neps.items() if tags['Status'] in ('Deferred', 'Superseded') %} - {{ tags['Title'] }} <{{ tags['Filename'] }}> -{% endfor %} - -Rejected and Withdrawn NEPs ---------------------------- - -.. toctree:: - :maxdepth: 1 - -{% for nep, tags in neps.items() if tags['Status'] in ('Rejected', 'Withdrawn') %} - {{ tags['Title'] }} <{{ tags['Filename'] }}> -{% endfor %} - diff --git a/doc/neps/meta.rst.tmpl b/doc/neps/meta.rst.tmpl new file mode 100644 index 000000000000..a74311e43ee8 --- /dev/null +++ b/doc/neps/meta.rst.tmpl @@ -0,0 +1,11 @@ +Meta-NEPs (NEPs about NEPs or Processes) +---------------------------------------- + +.. toctree:: + :maxdepth: 1 + +{% for nep, tags in neps.items() if tags['Status'] == 'Active' %} + {{ tags['Title'] }} <{{ tags['Filename'] }}> +{% endfor %} + + nep-template diff --git a/doc/neps/nep-0002-warnfix.rst b/doc/neps/nep-0002-warnfix.rst index a1138b2f1b83..1608998a652d 100644 --- a/doc/neps/nep-0002-warnfix.rst +++ b/doc/neps/nep-0002-warnfix.rst @@ -76,7 +76,7 @@ expanded to:: int foo(int * __NPY_UNUSED_TAGGEDdummy __COMP_NPY_UNUSED) Thus avoiding any accidental use of the variable. The mangling is pure C, and -thuse portable. The per-variable warning disabling is compiler specific. +thus portable. The per-variable warning disabling is compiler specific. signed/unsigned comparison -------------------------- diff --git a/doc/neps/nep-0005-generalized-ufuncs.rst b/doc/neps/nep-0005-generalized-ufuncs.rst index 43459a555a58..8ef6f345368b 100644 --- a/doc/neps/nep-0005-generalized-ufuncs.rst +++ b/doc/neps/nep-0005-generalized-ufuncs.rst @@ -45,7 +45,7 @@ determines how the dimensions of each input/output object are split into core and loop dimensions: #. While an input array has a smaller dimensionality than the corresponding - number of core dimensions, 1's are pre-pended to its shape. + number of core dimensions, 1's are prepended to its shape. #. The core dimensions are removed from all inputs and the remaining dimensions are broadcasted; defining the loop dimensions. #. The output is given by the loop dimensions plus the output core dimensions. diff --git a/doc/neps/nep-0009-structured_array_extensions.rst b/doc/neps/nep-0009-structured_array_extensions.rst index cd6c3f6c380c..5912b268ba04 100644 --- a/doc/neps/nep-0009-structured_array_extensions.rst +++ b/doc/neps/nep-0009-structured_array_extensions.rst @@ -9,7 +9,7 @@ NEP 9 — Structured array extensions 1. Create with-style context that makes "named-columns" available as names in the namespace. with np.columns(array): - price = unit * quantityt + price = unit * quantity 2. Allow structured arrays to be sliced by their column (i.e. one additional indexing option for structured arrays) so that a[:4, 'foo':'bar'] would be allowed. diff --git a/doc/neps/nep-0012-missing-data.rst b/doc/neps/nep-0012-missing-data.rst index 4775ea18bc1e..c896c6b6a238 100644 --- a/doc/neps/nep-0012-missing-data.rst +++ b/doc/neps/nep-0012-missing-data.rst @@ -428,7 +428,7 @@ New functions added to the ndarray are:: arr.copy(..., replacena=np.NA) Modification to the copy function which replaces NA values, either masked or with the NA bitpattern, with the 'replacena=' - parameter suppled. When 'replacena' isn't NA, the copied + parameter supplied. When 'replacena' isn't NA, the copied array is unmasked and has the 'NA' part stripped from the parameterized dtype ('NA[f8]' becomes just 'f8'). diff --git a/doc/neps/nep-0017-split-out-maskedarray.rst b/doc/neps/nep-0017-split-out-maskedarray.rst index 5cb1c0c399e5..fac05e256d86 100644 --- a/doc/neps/nep-0017-split-out-maskedarray.rst +++ b/doc/neps/nep-0017-split-out-maskedarray.rst @@ -69,7 +69,7 @@ how to modify code to use `maskedarray`. After two releases, `np.ma` will be removed entirely. In order to obtain `np.ma`, a user will install it via `pip install` or via their package manager. Subsequently, `importing maskedarray` on a version of NumPy that -includes it intgrally will raise an `ImportError`. +includes it integrally will raise an `ImportError`. Documentation ````````````` @@ -123,7 +123,7 @@ References and Footnotes .. [1] Subclassing ndarray, https://docs.scipy.org/doc/numpy/user/basics.subclassing.html -.. [2] PyPi: maskedarray, https://pypi.org/project/maskedarray/ +.. [2] PyPI: maskedarray, https://pypi.org/project/maskedarray/ Copyright --------- diff --git a/doc/neps/nep-0022-ndarray-duck-typing-overview.rst b/doc/neps/nep-0022-ndarray-duck-typing-overview.rst index 47b81d9e76ec..8f3e09995e10 100644 --- a/doc/neps/nep-0022-ndarray-duck-typing-overview.rst +++ b/doc/neps/nep-0022-ndarray-duck-typing-overview.rst @@ -97,7 +97,7 @@ partial duck arrays. We've been guilty of this ourself. At this point though, we think the best general strategy is to focus our efforts primarily on supporting full duck arrays, and only worry -about partial duck arrays as much as we need to to make sure we don't +about partial duck arrays as much as we need to make sure we don't accidentally rule them out for no reason. Why focus on full duck arrays? Several reasons: diff --git a/doc/neps/nep-0023-backwards-compatibility.rst b/doc/neps/nep-0023-backwards-compatibility.rst index 8b6f4cd1186a..a056e7074716 100644 --- a/doc/neps/nep-0023-backwards-compatibility.rst +++ b/doc/neps/nep-0023-backwards-compatibility.rst @@ -327,7 +327,7 @@ Discussion - `Mailing list discussion on the first version of this NEP in 2018 `__ - `Mailing list discussion on the Dec 2020 update of this NEP `__ -- `PR with review comments on the the Dec 2020 update of this NEP `__ +- `PR with review comments on the Dec 2020 update of this NEP `__ References and Footnotes diff --git a/doc/neps/nep-0024-missing-data-2.rst b/doc/neps/nep-0024-missing-data-2.rst index c0e2d2ce7771..ef6e628b5f8f 100644 --- a/doc/neps/nep-0024-missing-data-2.rst +++ b/doc/neps/nep-0024-missing-data-2.rst @@ -193,7 +193,7 @@ is obvious in the NA case:: >>> na_arr array([1., 2., NA], dtype='NA[>> masked_array = np.array([1.0, 2.0, 7.0], masked=True) diff --git a/doc/neps/nep-0027-zero-rank-arrarys.rst b/doc/neps/nep-0027-zero-rank-arrarys.rst index eef4bcacc4cd..ed51f3a13caf 100644 --- a/doc/neps/nep-0027-zero-rank-arrarys.rst +++ b/doc/neps/nep-0027-zero-rank-arrarys.rst @@ -105,7 +105,7 @@ arrays to scalars were summarized as follows: - This results in a special-case checking that is not pleasant. Fundamentally it lets the user believe that - somehow multidimensional homoegeneous arrays + somehow multidimensional homogeneous arrays are something like Python lists (which except for Object arrays they are not). @@ -166,7 +166,7 @@ Alexander started a `Jan 2006 discussion`_ on scipy-dev with the following proposal: ... it may be reasonable to allow ``a[...]``. This way - ellipsis can be interpereted as any number of ``:`` s including zero. + ellipsis can be interpreted as any number of ``:`` s including zero. Another subscript operation that makes sense for scalars would be ``a[...,newaxis]`` or even ``a[{newaxis, }* ..., {newaxis,}*]``, where ``{newaxis,}*`` stands for any number of comma-separated newaxis tokens. diff --git a/doc/neps/nep-0029-deprecation_policy.rst b/doc/neps/nep-0029-deprecation_policy.rst index a50afcb98f9d..4eb2aa50f279 100644 --- a/doc/neps/nep-0029-deprecation_policy.rst +++ b/doc/neps/nep-0029-deprecation_policy.rst @@ -74,11 +74,19 @@ a project with a major or minor version released in December 2019 should support Python 3.6 and newer, and a project with a major or minor version release in November 2020 should support Python 3.7 and newer. -The current Python release cadence is 18 months so a 42 month window -ensures that there will always be at least two minor versions of Python -in the window. The window is extended 6 months beyond the anticipated two-release -interval for Python to provide resilience against small fluctuations / -delays in its release schedule. +When this NEP was drafted the Python release cadence was 18 months so a 42 +month window ensured that there would always be at least two minor versions of +Python in the window. The window was extended 6 months beyond the anticipated +two-release interval for Python to provide resilience against small +fluctuations / delays in its release schedule. + +The Python release cadence increased in `PEP 0602 `__, +with releases now every 12 months, so there will be 3-4 +Python releases in the support window at any time. However, PEP 0602 does not +decrease the support window of Python (18 months of regular full bug-fix +releases and 42 months of as-needed source-only releases). Thus, we do not +expect our users to upgrade Python faster, and our 42 month support window will +cover the same portion of the upstream support of any given Python release. Because Python minor version support is based only on historical release dates, a 42 month time window, and a planned project release @@ -114,7 +122,12 @@ Jul 26, 2021 3.7+ 1.18+ Dec 22, 2021 3.7+ 1.19+ Dec 26, 2021 3.8+ 1.19+ Jun 21, 2022 3.8+ 1.20+ -Apr 14, 2023 3.9+ 1.20+ +Jan 31, 2023 3.8+ 1.21+ +Apr 14, 2023 3.9+ 1.21+ +Jun 23, 2023 3.9+ 1.22+ +Jan 01, 2024 3.9+ 1.23+ +Apr 05, 2024 3.10+ 1.23+ +Apr 04, 2025 3.11+ 1.23+ ============ ====== ===== @@ -132,7 +145,12 @@ Drop Schedule On Dec 22, 2021 drop support for NumPy 1.18 (initially released on Dec 22, 2019) On Dec 26, 2021 drop support for Python 3.7 (initially released on Jun 27, 2018) On Jun 21, 2022 drop support for NumPy 1.19 (initially released on Jun 20, 2020) + On Jan 31, 2023 drop support for NumPy 1.20 (initially released on Jan 31, 2021) On Apr 14, 2023 drop support for Python 3.8 (initially released on Oct 14, 2019) + On Jun 23, 2023 drop support for NumPy 1.21 (initially released on Jun 22, 2021) + On Jan 01, 2024 drop support for NumPy 1.22 (initially released on Dec 31, 2021) + On Apr 05, 2024 drop support for Python 3.9 (initially released on Oct 05, 2020) + On Apr 04, 2025 drop support for Python 3.10 (initially released on Oct 04, 2021) Implementation @@ -261,6 +279,11 @@ Code to generate support and drop schedule tables :: Oct 14, 2019: Python 3.8 Dec 22, 2019: NumPy 1.18 Jun 20, 2020: NumPy 1.19 + Oct 05, 2020: Python 3.9 + Jan 30, 2021: NumPy 1.20 + Jun 22, 2021: NumPy 1.21 + Oct 04, 2021: Python 3.10 + Dec 31, 2021: NumPy 1.22 """ releases = [] diff --git a/doc/neps/nep-0031-uarray.rst b/doc/neps/nep-0031-uarray.rst index b4ec94077f80..bda35d426b31 100644 --- a/doc/neps/nep-0031-uarray.rst +++ b/doc/neps/nep-0031-uarray.rst @@ -102,7 +102,7 @@ Usage and Impact This NEP allows for global and context-local overrides, as well as automatic overrides a-la ``__array_function__``. -Here are some use-cases this NEP would enable, besides the +Here are some use-cases this NEP would enable, besides the first one stated in the motivation section: The first is allowing alternate dtypes to return their @@ -114,7 +114,7 @@ respective arrays. x = unp.ones((5, 5), dtype=xnd_dtype) # Or torch dtype The second is allowing overrides for parts of the API. -This is to allow alternate and/or optimised implementations +This is to allow alternate and/or optimized implementations for ``np.linalg``, BLAS, and ``np.random``. .. code:: python @@ -126,7 +126,7 @@ for ``np.linalg``, BLAS, and ``np.random``. np.set_global_backend(pyfftw) # Uses pyfftw without monkeypatching - np.fft.fft(numpy_array) + np.fft.fft(numpy_array) with np.set_backend(pyfftw) # Or mkl_fft, or numpy # Uses the backend you specified @@ -200,10 +200,10 @@ GitHub workflow. There are a few reasons for this: The reason for this is that there may exist functions in the in these submodules that need backends, even for ``numpy.ndarray`` inputs. -Advantanges of ``unumpy`` over other solutions +Advantages of ``unumpy`` over other solutions ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -``unumpy`` offers a number of advantanges over the approach of defining a new +``unumpy`` offers a number of advantages over the approach of defining a new protocol for every problem encountered: Whenever there is something requiring an override, ``unumpy`` will be able to offer a unified API with very minor changes. For example: @@ -302,7 +302,7 @@ This is different from monkeypatching in a few different ways: so there is at least the loose sense of an API contract. Monkeypatching does not provide this ability. * There is the ability of locally switching the backend. -* It has been `suggested `_ +* It has been `suggested `_ that the reason that 1.17 hasn't landed in the Anaconda defaults channel is due to the incompatibility between monkeypatching and ``__array_function__``, as monkeypatching would bypass the protocol completely. @@ -313,7 +313,7 @@ This is different from monkeypatching in a few different ways: All this isn't possible at all with ``__array_function__`` or ``__array_ufunc__``. -It has been formally realised (at least in part) that a backend system is +It has been formally realized (at least in part) that a backend system is needed for this, in the `NumPy roadmap `_. For ``numpy.random``, it's still necessary to make the C-API fit the one @@ -347,7 +347,7 @@ dispatchable. The need for an opt-in module ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -The need for an opt-in module is realised because of a few reasons: +The need for an opt-in module is realized because of a few reasons: * There are parts of the API (like `numpy.asarray`) that simply cannot be overridden due to incompatibility concerns with C/Cython extensions, however, @@ -356,7 +356,7 @@ The need for an opt-in module is realised because of a few reasons: as those mentioned above. NEP 18 notes that this may require maintenance of two separate APIs. However, -this burden may be lessened by, for example, parametrizing all tests over +this burden may be lessened by, for example, parameterizing all tests over ``numpy.overridable`` separately via a fixture. This also has the side-effect of thoroughly testing it, unlike ``__array_function__``. We also feel that it provides an opportunity to separate the NumPy API contract properly from the @@ -640,9 +640,9 @@ References and Footnotes .. [4] NEP 13 — A Mechanism for Overriding Ufuncs: https://numpy.org/neps/nep-0013-ufunc-overrides.html -.. [5] Reply to Adding to the non-dispatched implementation of NumPy methods: http://numpy-discussion.10968.n7.nabble.com/Adding-to-the-non-dispatched-implementation-of-NumPy-methods-tp46816p46874.html +.. [5] Reply to Adding to the non-dispatched implementation of NumPy methods: https://mail.python.org/archives/list/numpy-discussion@python.org/thread/5GUDMALWDIRHITG5YUOCV343J66QSX3U/#5GUDMALWDIRHITG5YUOCV343J66QSX3U -.. [6] Custom Dtype/Units discussion: http://numpy-discussion.10968.n7.nabble.com/Custom-Dtype-Units-discussion-td43262.html +.. [6] Custom Dtype/Units discussion: https://mail.python.org/archives/list/numpy-discussion@python.org/thread/RZYCVT6C3F7UDV6NA6FEV4MC5FKS6RDA/#RZYCVT6C3F7UDV6NA6FEV4MC5FKS6RDA .. [7] The epic dtype cleanup plan: https://github.com/numpy/numpy/issues/2899 diff --git a/doc/neps/nep-0034-infer-dtype-is-object.rst b/doc/neps/nep-0034-infer-dtype-is-object.rst index a424ab4a38af..fd8a1f4479d9 100644 --- a/doc/neps/nep-0034-infer-dtype-is-object.rst +++ b/doc/neps/nep-0034-infer-dtype-is-object.rst @@ -5,7 +5,7 @@ NEP 34 — Disallow inferring ``dtype=object`` from sequences =========================================================== :Author: Matti Picus -:Status: Accepted +:Status: Final :Type: Standards Track :Created: 2019-10-10 :Resolution: https://mail.python.org/pipermail/numpy-discussion/2019-October/080200.html diff --git a/doc/neps/nep-0036-fair-play.rst b/doc/neps/nep-0036-fair-play.rst index 2acdcc70459a..96dfa61d8d85 100644 --- a/doc/neps/nep-0036-fair-play.rst +++ b/doc/neps/nep-0036-fair-play.rst @@ -1,3 +1,5 @@ +.. _NEP36: + ================== NEP 36 — Fair play ================== diff --git a/doc/neps/nep-0038-SIMD-optimizations.rst b/doc/neps/nep-0038-SIMD-optimizations.rst index 9272284474a6..c7d9ce9d9197 100644 --- a/doc/neps/nep-0038-SIMD-optimizations.rst +++ b/doc/neps/nep-0038-SIMD-optimizations.rst @@ -8,7 +8,7 @@ NEP 38 — Using SIMD optimization instructions for performance :Status: Accepted :Type: Standards :Created: 2019-11-25 -:Resolution: http://numpy-discussion.10968.n7.nabble.com/NEP-38-Universal-SIMD-intrinsics-td47854.html +:Resolution: https://mail.python.org/archives/list/numpy-discussion@python.org/thread/PVWJ74UVBRZ5ZWF6MDU7EUSJXVNILAQB/#PVWJ74UVBRZ5ZWF6MDU7EUSJXVNILAQB Abstract @@ -26,9 +26,9 @@ function that matches the run-time CPU info `is chosen`_ from the candidates.Thi NEP proposes a mechanism to build on that for many more features and architectures. The steps proposed are to: -- Establish a set of well-defined, architecture-agnostic, universal intrisics +- Establish a set of well-defined, architecture-agnostic, universal intrinsics which capture features available across architectures. -- Capture these universal intrisics in a set of C macros and use the macros +- Capture these universal intrinsics in a set of C macros and use the macros to build code paths for sets of features from the baseline up to the maximum set of features available on that architecture. Offer these as a limited number of compiled alternative code paths. @@ -43,7 +43,7 @@ Traditionally NumPy has depended on compilers to generate optimal code specifically for the target architecture. However few users today compile NumPy locally for their machines. Most use the binary packages which must provide run-time support for the lowest-common -denominator CPU architecture. Thus NumPy cannot take advantage of +denominator CPU architecture. Thus NumPy cannot take advantage of more advanced features of their CPU processors, since they may not be available on all users' systems. @@ -124,7 +124,7 @@ Therefore, such code should only be added if it yields a significant performance benefit. Assessing this performance benefit can be nontrivial. To aid with this, the implementation for this NEP will add a way to select which instruction sets can be used at *runtime* via environment variables. -(name TBD). This ablility is critical for CI code verification. +(name TBD). This ability is critical for CI code verification. Diagnostics @@ -153,7 +153,7 @@ SIMD loops for many ufuncs. These would likely be the first candidates to be ported to universal intrinsics. The expectation is that the new implementation may cause a regression in benchmarks, but not increase the size of the binary. If the regression is not minimal, we may choose to keep -the X86-specific code for that platform and use the universal intrisic code +the X86-specific code for that platform and use the universal intrinsic code for other platforms. Any new PRs to implement ufuncs using intrinsics will be expected to use the @@ -208,12 +208,12 @@ There should be no impact on backwards compatibility. Detailed description -------------------- -The CPU-specific are mapped to unversal intrinsics which are +The CPU-specific are mapped to universal intrinsics which are similar for all x86 SIMD variants, ARM SIMD variants etc. For example, the NumPy universal intrinsic ``npyv_load_u32`` maps to: * ``vld1q_u32`` for ARM based NEON -* ``_mm256_loadu_si256`` for x86 based AVX2 +* ``_mm256_loadu_si256`` for x86 based AVX2 * ``_mm512_loadu_si512`` for x86 based AVX-512 Anyone writing a SIMD loop will use the ``npyv_load_u32`` macro instead of the @@ -271,7 +271,7 @@ Current PRs: The compile-time and runtime code infrastructure are supplied by the first PR. The second adds a demonstration of use of the infrastructure for a loop. Once -the NEP is approved, more work is needed to write loops using the machnisms +the NEP is approved, more work is needed to write loops using the mechanisms provided by the NEP. Alternatives diff --git a/doc/neps/nep-0040-legacy-datatype-impl.rst b/doc/neps/nep-0040-legacy-datatype-impl.rst index a6e74d7a0c1f..a8d20ac4181a 100644 --- a/doc/neps/nep-0040-legacy-datatype-impl.rst +++ b/doc/neps/nep-0040-legacy-datatype-impl.rst @@ -21,7 +21,7 @@ NEP 40 — Legacy datatype implementation in NumPy - :ref:`NEP 42 ` describes the new design's datatype-related APIs. - - NEP 43 describes the new design's API for universal functions. + - :ref:`NEP 43 ` describes the new design's API for universal functions. diff --git a/doc/neps/nep-0041-improved-dtype-support.rst b/doc/neps/nep-0041-improved-dtype-support.rst index 2fb907073b7f..fcde39780d3c 100644 --- a/doc/neps/nep-0041-improved-dtype-support.rst +++ b/doc/neps/nep-0041-improved-dtype-support.rst @@ -23,7 +23,7 @@ NEP 41 — First step towards a new datatype system - :ref:`NEP 42 ` describes the new design's datatype-related APIs. - - NEP 43 describes the new design's API for universal functions. + - :ref:`NEP 43 ` describes the new design's API for universal functions. Abstract @@ -74,7 +74,7 @@ cannot describe casting for such parametric datatypes implemented outside of Num This additional functionality for supporting parametric datatypes introduces increased complexity within NumPy itself, and furthermore is not available to external user-defined datatypes. -In general the concerns of different datatypes are not well well-encapsulated. +In general the concerns of different datatypes are not well-encapsulated. This burden is exacerbated by the exposure of internal C structures, limiting the addition of new fields (for example to support new sorting methods [new_sort]_). diff --git a/doc/neps/nep-0042-new-dtypes.rst b/doc/neps/nep-0042-new-dtypes.rst index c29172a281c5..3d30d54f4b14 100644 --- a/doc/neps/nep-0042-new-dtypes.rst +++ b/doc/neps/nep-0042-new-dtypes.rst @@ -17,13 +17,13 @@ NEP 42 — New and extensible DTypes This NEP is third in a series: - - :ref:`NEP40` explains the shortcomings of NumPy's dtype implementation. + - :ref:`NEP 40 ` explains the shortcomings of NumPy's dtype implementation. - - :ref:`NEP41` gives an overview of our proposed replacement. + - :ref:`NEP 41 ` gives an overview of our proposed replacement. - NEP 42 (this document) describes the new design's datatype-related APIs. - - :ref:`NEP43` describes the new design's API for universal functions. + - :ref:`NEP 43 ` describes the new design's API for universal functions. ****************************************************************************** @@ -302,7 +302,7 @@ user-defined DType:: class UserDtype(dtype): ... one can do ``np.ndarray[UserDtype]``, keeping annotations concise in -that case without introducing boilerplate in NumPy itself. For a user +that case without introducing boilerplate in NumPy itself. For a user-defined scalar type:: class UserScalar(generic): ... diff --git a/doc/neps/nep-0043-extensible-ufuncs.rst b/doc/neps/nep-0043-extensible-ufuncs.rst index 3312eb12cc89..abc19ccf3315 100644 --- a/doc/neps/nep-0043-extensible-ufuncs.rst +++ b/doc/neps/nep-0043-extensible-ufuncs.rst @@ -804,7 +804,7 @@ the inner-loop operates on. This is necessary information for parametric dtypes since for example comparing two strings requires knowing the length of both strings. The ``Context`` can also hold potentially useful information such as the -the original ``ufunc``, which can be helpful when reporting errors. +original ``ufunc``, which can be helpful when reporting errors. In principle passing in Context is not necessary, as all information could be included in ``innerloop_data`` and set up in the ``get_loop`` function. @@ -948,7 +948,7 @@ This wrapped ``ArrayMethod`` will have two additional methods: convert this to ``float64 + float64``. * ``wrap_outputs(Tuple[DType]: input_descr) -> Tuple[DType]`` replacing the - resolved descriptors with with the desired actual loop descriptors. + resolved descriptors with the desired actual loop descriptors. The original ``resolve_descriptors`` function will be called between these two calls, so that the output descriptors may not be set in the first call. In the above example it will use the ``float64`` as returned (which might @@ -987,8 +987,8 @@ A different use-case is that of a ``Unit(float64, "m")`` DType, where the numerical type is part of the DType parameter. This approach is possible, but will require a custom ``ArrayMethod`` which wraps existing loops. -It must also always require require two steps of dispatching -(one to the ``Unit`` DType and a second one for the numerical type). +It must also always require two steps of dispatching (one to the ``Unit`` +DType and a second one for the numerical type). Furthermore, the efficient implementation will require the ability to fetch and reuse the inner-loop function from another ``ArrayMethod``. @@ -1296,7 +1296,7 @@ of the current ufunc machinery (as well as casting). The implementation unfortunately will require large maintenance of the UFunc machinery, since both the actual UFunc loop calls, as well as the -the initial dispatching steps have to be modified. +initial dispatching steps have to be modified. In general, the correct ``ArrayMethod``, also those returned by a promoter, will be cached (or stored) inside a hashtable for efficient lookup. diff --git a/doc/neps/nep-0044-restructuring-numpy-docs.rst b/doc/neps/nep-0044-restructuring-numpy-docs.rst index fd41e0c2a41b..3fd703455073 100644 --- a/doc/neps/nep-0044-restructuring-numpy-docs.rst +++ b/doc/neps/nep-0044-restructuring-numpy-docs.rst @@ -233,7 +233,7 @@ Discussion around this NEP can be found on the NumPy mailing list: References and Footnotes ======================== -.. [1] `What nobody tells you about documentation `_ +.. [1] `Diátaxis - A systematic framework for technical documentation authoring `_ .. [2] `Preparing to Teach `_ (from the `Software Carpentry `_ Instructor Training materials) diff --git a/doc/neps/nep-0045-c_style_guide.rst b/doc/neps/nep-0045-c_style_guide.rst index 9a6323873300..03c0320f14b8 100644 --- a/doc/neps/nep-0045-c_style_guide.rst +++ b/doc/neps/nep-0045-c_style_guide.rst @@ -256,7 +256,7 @@ Discussion ---------- https://github.com/numpy/numpy/issues/11911 -recommended that this proposal, which originated as ``doc/C_STYLE_GUIDE.rst.txt``, +recommended that this proposal, which originated as ``doc/C_STYLE_GUIDE.rst``, be turned into an NEP. diff --git a/doc/neps/nep-0046-sponsorship-guidelines.rst b/doc/neps/nep-0046-sponsorship-guidelines.rst index 8535cb554703..ed54c21d55d0 100644 --- a/doc/neps/nep-0046-sponsorship-guidelines.rst +++ b/doc/neps/nep-0046-sponsorship-guidelines.rst @@ -219,8 +219,9 @@ https://scikit-learn.org/stable/about.html#funding. Plus a separate section https://jupyter.org/about. Some subprojects have separate approaches, for example sponsors are listed (by using the `all-contributors `__ bot) in the README for -`jupyterlab-git `__. For a recent -discussion on that, see `here `_. +`jupyterlab-git `__. +For a discussion from Jan 2020 on that, see +`here `_. *NumFOCUS* has a large banner with sponsor logos on its front page at https://numfocus.org, and a full page with sponsors at different sponsorship diff --git a/doc/neps/nep-0047-array-api-standard.rst b/doc/neps/nep-0047-array-api-standard.rst index 53b8e35b001f..a94b3b42345b 100644 --- a/doc/neps/nep-0047-array-api-standard.rst +++ b/doc/neps/nep-0047-array-api-standard.rst @@ -340,7 +340,7 @@ Adding support for DLPack to NumPy entails: - Adding a ``ndarray.__dlpack__()`` method which returns a ``dlpack`` C structure wrapped in a ``PyCapsule``. -- Adding a ``np._from_dlpack(obj)`` function, where ``obj`` supports +- Adding a ``np.from_dlpack(obj)`` function, where ``obj`` supports ``__dlpack__()``, and returns an ``ndarray``. DLPack is currently a ~200 LoC header, and is meant to be included directly, so diff --git a/doc/neps/nep-0049.rst b/doc/neps/nep-0049.rst index 3bd1d102c62d..8bc88a68b1e0 100644 --- a/doc/neps/nep-0049.rst +++ b/doc/neps/nep-0049.rst @@ -1,3 +1,5 @@ +.. _NEP49: + =================================== NEP 49 — Data allocation strategies =================================== @@ -55,8 +57,8 @@ is to create a flexible enough interface without burdening normative users. .. _`issue 5312`: https://github.com/numpy/numpy/issues/5312 .. _`from 2017`: https://github.com/numpy/numpy/issues/5312#issuecomment-315234656 .. _`in 2005`: https://numpy-discussion.scipy.narkive.com/MvmMkJcK/numpy-arrays-data-allocation-and-simd-alignement -.. _`here`: http://numpy-discussion.10968.n7.nabble.com/Aligned-configurable-memory-allocation-td39712.html -.. _`and here`: http://numpy-discussion.10968.n7.nabble.com/Numpy-s-policy-for-releasing-memory-td1533.html +.. _`here`: https://mail.python.org/archives/list/numpy-discussion@python.org/thread/YPC5BGPUMKT2MLBP6O3FMPC35LFM2CCH/#YPC5BGPUMKT2MLBP6O3FMPC35LFM2CCH +.. _`and here`: https://mail.python.org/archives/list/numpy-discussion@python.org/thread/IQK3EPIIRE3V4BPNAMJ2ZST3NUG2MK2A/#IQK3EPIIRE3V4BPNAMJ2ZST3NUG2MK2A .. _`issue 14177`: https://github.com/numpy/numpy/issues/14177 .. _`filprofiler`: https://github.com/pythonspeed/filprofiler/blob/master/design/allocator-overrides.md .. _`electric fence`: https://github.com/boundarydevices/efence diff --git a/doc/neps/nep-0050-scalar-promotion.rst b/doc/neps/nep-0050-scalar-promotion.rst new file mode 100644 index 000000000000..f553224eab75 --- /dev/null +++ b/doc/neps/nep-0050-scalar-promotion.rst @@ -0,0 +1,798 @@ +.. _NEP50: + +=========================================== +NEP 50 — Promotion rules for Python scalars +=========================================== +:Author: Sebastian Berg +:Status: Draft +:Type: Standards Track +:Created: 2021-05-25 + + +Abstract +======== + +Since NumPy 1.7, promotion rules use so-called "safe casting" +which relies on inspection of the values involved. +This helped identify a number of edge cases for users, but was +complex to implement and also made behavior hard to predict. + +There are two kinds of confusing results: + +1. Value-based promotion means that the value, for example of a Python integer, + can determine output type as found by ``np.result_type``:: + + np.result_type(np.int8, 1) == np.int8 + np.result_type(np.int8, 255) == np.int16 + + This logic arises because ``1`` can be represented by a ``uint8`` or + ``int8`` while ``255`` cannot be represented by an ``int8`` but only by + by a ``uint8`` or ``int16``. + + This also holds when working with 0-D arrays (so-called "scalar arrays"):: + + int64_0d_array = np.array(1, dtype=np.int64) + np.result_type(np.int8, int64_0d_array) == np.int8 + + Where the fact that ``int64_0d_array`` has an ``int64`` dtype has no + influence on the resulting dtype. The ``dtype=np.int64`` is effectively + ignored in this example since only its value matters. + +2. For a Python ``int``, ``float``, or ``complex`` the value is inspected as + previously shown. But surprisingly *not* when the NumPy object is a 0-D array + or NumPy scalar:: + + np.result_type(np.array(1, dtype=np.uint8), 1) == np.int64 + np.result_type(np.int8(1), 1) == np.int64 + + The reason is that value-based promotion is disabled when all + objects are scalars or 0-D arrays. + NumPy thus returns the same type as ``np.array(1)``, which is usually + an ``int64`` (this depends on the system). + +Note that the examples apply also to operations like multiplication, +addition, comparisons, and their corresponding functions like ``np.multiply``. + +This NEP proposes to refactor the behaviour around two guiding principles: + +1. Values must never influence result type. +2. NumPy scalars and 0-D arrays should behave consistently with their + N-D counterparts. + +We propose to remove all value-based logic and add special handling for +Python scalars to preserve some convenient behaviors. +Python scalars will be considered "weakly" typed. +When a NumPy array/scalar is combined with a Python scalar, it will +be converted to the NumPy dtype, such that:: + + np.array([1, 2, 3], dtype=np.uint8) + 1 # returns a uint8 array + np.array([1, 2, 3], dtype=np.float32) + 2. # returns a float32 array + +There will be no dependence on the Python value itself. + +The proposed changes also apply to ``np.can_cast(100, np.int8)``, however, +we expect that the behaviour in functions (promotion) will, in practice, be far +more important than the casting change itself. + + +.. note:: + + As of the early NumPy 1.24 development branch, NumPy has preliminary and + limited support to test this proposal. To try it, you can use the + development wheels from: https://anaconda.org/scipy-wheels-nightly/numpy + + It is further necessary to set the following environment variable:: + + export NPY_PROMOTION_STATE=weak + + Valid values are ``weak``, ``weak_and_warn``, and ``legacy``. Note that + ``weak_and_warn`` implements the optional warnings proposed in this NEP + and is expected to be *very* noisy. + We recommend starting using the ``weak`` option and use ``weak_and_warn`` + mainly to understand a specific observed change in behaviour. + + The following additional API exists: + + * ``np._set_promotion_state()`` and ``np._get_promotion_state()`` which is + equivalent to the environment variable. (Not thread/context safe.) + * ``with np._no_nep50_warning():`` allows to suppress warnings when + ``weak_and_warn`` promotion is used. (Thread and context safe.) + + At this time overflow warnings on integer power are missing. + Further, ``np.can_cast`` fails to give warnings in the + ``weak_and_warn`` mode. Its behavior with respect to Python scalar input + may still be in flux (this should affect very few users). + + +Schema of the new proposed promotion rules +------------------------------------------ + +After the change, the promotions in NumPy will follow the schema below. +Promotion always occurs along the green lines: +from left to right within their kind and to a higher kind only when +necessary. +The result kind is always the largest kind of the inputs. +Note that ``float32`` has a lower precision than ``int32`` or ``uint32`` and +is thus sorted slightly to the left in the schematic. This is because +``float32`` cannot represent all ``int32`` values exactly. +However, for practical reasons, NumPy allows promoting ``int64`` to ``float64`` +effectively considering them to have the same precision. + +The Python scalars are inserted at the very left of each "kind" and the +Python integer does not distinguish signed and unsigned. NumPy promotion +thus uses the following, ordered, kind categories: + +* `boolean` +* `integral`: signed or unsigned integers +* `inexact`: floating point numbers and complex floating point numbers + +When promoting a Python scalar with a dtype of lower kind +category (`boolean < integral < inexact`) with a higher one, we use the +minimum/default precision: that is ``float64``, ``complex128`` or ``int64`` +(``int32`` is used on some systems, e.g. windows). + +.. figure:: _static/nep-0050-promotion-no-fonts.svg + :figclass: align-center + +See the next section for examples which clarify the proposed behavior. +Further examples with a comparison to the current behavior can be found +in the table below. + +Examples of new behaviour +------------------------- + +To make interpretation of above text and figure easier, we provide a few examples of the new behaviour. Below, the Python integer has no influence on the result type:: + + np.uint8(1) + 1 == np.uint8(2) + np.int16(2) + 2 == np.int16(4) + +In the following the Python ``float`` and ``complex`` are "inexact", but the +NumPy value is integral, so we use at least ``float64``/``complex128``:: + + np.uint16(3) + 3.0 == np.float64(6.0) + np.int16(4) + 4j == np.complex128(4+4j) + +But this does not happen for ``float`` to ``complex`` promotions, where +``float32`` and ``complex64`` have the same precision:: + + np.float32(5) + 5j == np.complex64(5+5j) + +Note that the schematic omits ``bool``. It is set below "integral", so that the +following hold:: + + np.bool_(True) + 1 == np.int64(2) + True + np.uint8(2) == np.uint8(3) + + +Table comparing new and old behaviour +------------------------------------- + +The following table lists relevant changes and unchanged behaviours. +Please see the `Old implementation`_ for a detailed explanation of the rules +that lead to the "Old result", and the following sections for the rules +detailing the new. +The backwards compatibility section discusses how these changes are likely +to impact users. + +Note the important distinction between a 0-D array like ``array(2)`` and +arrays that are not 0-D, such as ``array([2])``. + +.. list-table:: Table of changed behaviours + :widths: 20 12 12 + :header-rows: 1 + + * - Expression + - Old result + - New result + * - ``uint8(1) + 2`` + - ``int64(3)`` + - ``uint8(3)`` [T1]_ + * - ``array([1], uint8) + int64(1)`` or + + ``array([1], uint8) + array(1, int64)`` + - ``array([2], unit8)`` + - ``array([2], int64)`` [T2]_ + * - ``array([1.], float32) + float64(1.)`` or + + ``array([1.], float32) + array(1., float64)`` + - ``array([2.], float32)`` + - ``array([2.], float64)`` + * - ``array([1], uint8) + 1`` + - ``array([2], uint8)`` + - *unchanged* + * - ``array([1], uint8) + 200`` + - ``array([201], np.uint8)`` + - *unchanged* + * - ``array([100], uint8) + 200`` + - ``array([ 44], uint8)`` + - *unchanged* [T3]_ + * - ``array([1], uint8) + 300`` + - ``array([301], uint16)`` + - *Exception* [T4]_ + * - ``uint8(1) + 300`` + - ``int64(301)`` + - *Exception* [T5]_ + * - ``uint8(100) + 200`` + - ``int64(301)`` + - ``uint8(44)`` *and* ``RuntimeWarning`` [T6]_ + * - ``float32(1) + 3e100`` + - ``float64(3e100)`` + - ``float32(Inf)`` *and* ``RuntimeWarning`` [T7]_ + * - ``array([0.1], float32) == 0.1`` + - ``array([False])`` + - *unchanged* + * - ``array([0.1], float32) == float64(0.1)`` + - ``array([ True])`` + - ``array([False])`` [T8]_ + * - ``array([1.], float32) + 3`` + - ``array([4.], float32)`` + - *unchanged* + * - ``array([1.], float32) + int64(3)`` + - ``array([4.], float32)`` + - ``array([4.], float64)`` [T9]_ + +.. [T1] New behaviour honours the dtype of the ``uint8`` scalar. +.. [T2] Current NumPy ignores the precision of 0-D arrays or NumPy scalars + when combined with arrays. +.. [T3] Current NumPy ignores the precision of 0-D arrays or NumPy scalars + when combined with arrays. +.. [T4] Old behaviour uses ``uint16`` because ``300`` does not fit ``uint8``, + new behaviour raises an error for the same reason. +.. [T5] ``300`` cannot be converted to ``uint8``. +.. [T6] One of the most dangerous changes maybe. Retaining the type leads to + overflow. A ``RuntimeWarning`` indicating overflow is given for the + NumPy scalars. +.. [T7] ``np.float32(3e100)`` overflows to infinity with a warning. +.. [T8] ``0.1`` loses precision when cast to ``float32``, but old behaviour + casts the ``float64(0.1)`` and then matches. +.. [T9] NumPy promotes ``float32`` and ``int64`` to ``float64``. The old + behaviour ignored the ``int64`` here. + + +Motivation and Scope +==================== + +The motivation for changing the behaviour with respect to inspecting the value +of Python scalars and NumPy scalars/0-D arrays is three-fold: + +1. The special handling of NumPy scalars/0-D arrays as well as the value + inspection can be very surprising to users, +2. The value-inspection logic is much harder to explain and implement. + It is further harder to make it available to user-defined DTypes through + :ref:`NEP 42 `. + Currently, this leads to a dual implementation of a new and an old (value + sensitive) system. Fixing this will greatly simplify the internal logic + and make results more consistent. +3. It largely aligns with the choice of other projects like `JAX` and + `data-apis.org` (see also `Related Work`). + +We believe that the proposal of "weak" Python scalars will help users by +providing a clear mental model for which datatype an operation will +result in. +This model fits well with the preservation of array precisions that NumPy +currently often follows, and also uses for in-place operations:: + + arr += value + +Preserves precision as long as "kind" boundaries are not crossed (otherwise +an error is raised). + +While some users will potentially miss the value inspecting behavior, even for +those cases where it seems useful it quickly leads to surprises. This may be +expected:: + + np.array([100], dtype=np.uint8) + 1000 == np.array([1100], dtype=np.uint16) + +But the following will then be a surprise:: + + np.array([100], dtype=np.uint8) + 200 == np.array([44], dtype=np.uint8) + +Considering that the proposal aligns with the behavior of in-place operands +and avoids the surprising switch in behavior that only sometimes avoids +overflow in the result, +we believe that the proposal follows the "principle of least surprise". + + +Usage and Impact +================ + +This NEP is expected to be implemented with **no** transition period that warns +for all changes. Such a transition period would create many (often harmless) +warnings which would be difficult to silence. +We expect that most users will benefit long term from the clearer promotion +rules and that few are directly (negatively) impacted by the change. +However, certain usage patterns may lead to problematic changes, these are +detailed in the backwards compatibility section. + +The solution to this will be an *optional* warning mode capable of notifying +users of potential changes in behavior. +This mode is expected to generate many harmless warnings, but provide a way +to systematically vet code and track down changes if problems are observed. + + +Impact on ``can_cast`` +---------------------- + +`can_cast` will never inspect the value anymore. So that the following results +are expected to change from ``True`` to ``False``:: + + np.can_cast(np.int64(100), np.uint8) + np.can_cast(np.array(100, dtype=np.int64), np.uint8) + np.can_cast(100, np.uint8) + +We expect that the impact of this change will be small compared to that of +the following changes. + +.. note:: + + The last example where the input is a Python scalar _may_ be preserved + since ``100`` can be represented by a ``uint8``. + + +Impact on operators and functions involving NumPy arrays or scalars +------------------------------------------------------------------- + +The main impact on operations not involving Python scalars (``float``, ``int``, +``complex``) will be that operations on 0-D arrays and NumPy scalars will never +depend on their values. +This removes currently surprising cases. For example:: + + np.arange(10, dtype=np.uint8) + np.int64(1) + # and: + np.add(np.arange(10, dtype=np.uint8), np.int64(1)) + +Will return an ``int64`` array in the future because the type of +``np.int64(1)`` is strictly honoured. +Currently a ``uint8`` array is returned. + + +Impact on operators involving Python ``int``, ``float``, and ``complex`` +------------------------------------------------------------------------ + +This NEP attempts to preserve the convenience of the old behaviour +when working with literal values. +The current value-based logic had some nice properties when "untyped", +literal Python scalars are involved:: + + np.arange(10, dtype=np.int8) + 1 # returns an int8 array + np.array([1., 2.], dtype=np.float32) * 3.5 # returns a float32 array + +But led to surprises when it came to "unrepresentable" values:: + + np.arange(10, dtype=np.int8) + 256 # returns int16 + np.array([1., 2.], dtype=np.float32) * 1e200 # returns float64 + +The proposal is to preserve this behaviour for the most part. This is achieved +by considering Python ``int``, ``float``, and ``complex`` to be "weakly" typed +in operations. +However, to avoid surprises, we plan to make conversion to the new type +more strict: The results will be unchanged in the first two examples, +but in the second one, it will change the following way:: + + np.arange(10, dtype=np.int8) + 256 # raises a TypeError + np.array([1., 2.], dtype=np.float32) * 1e200 # warning and returns infinity + +The second one warns because ``np.float32(1e200)`` overflows to infinity. +It will then continue to do the calculation with ``inf`` as usual. + + +.. admonition:: Behaviour in other libraries + + Overflowing in the conversion rather than raising an error is a choice; + it is one that is the default in most C setups (similar to NumPy C can be + set up to raise an error due to the overflow, however). + It is also for example the behaviour of ``pytorch`` 1.10. + + + +Backward compatibility +====================== + +In general, code which only uses the default dtypes float64, or int32/int64 +or more precise ones should not be affected. + +However, the proposed changes will modify results in quite a few cases where +0-D or scalar values (with non-default dtypes) are mixed. +In many cases, these will be bug-fixes, however, there are certain changes +which may be problematic to the end-user. + +The most important possible failure is probably the following example:: + + arr = np.arange(100, dtype=np.uint8) # storage array with low precision + value = arr[10] + + # calculation continues with "value" without considering where it came from + value * 100 + +Where previously the ``value * 100`` would cause an up-cast to +``int32``/``int64`` (because value is a scalar). +The new behaviour will preserve the lower precision unless explicitly +dealt with (just as if ``value`` was an array). +This can lead to integer overflows and thus incorrect results beyond precision. +In many cases this may be silent, although NumPy usually gives warnings for the +scalar operators. + +Similarly, if the storage array is ``float32`` a calculation may retain the +lower ``float32`` precision rather than use the default ``float64``. + +Further issues can occur. For example: + +* Floating point comparisons, especially equality, may change when mixing + precisions:: + + np.float32(1/3) == 1/3 # was False, will be True. + +* Certain operations are expected to start failing:: + + np.array([1], np.uint8) * 1000 + np.array([1], np.uint8) == 1000 # possibly also + + to protect users in cases where previous value-based casting led to an + upcast. (Failures occur when converting ``1000`` to a ``uint8``.) + +* Floating point overflow may occur in odder cases:: + + np.float32(1e-30) * 1e50 # will return ``inf`` and a warning + + Because ``np.float32(1e50)`` returns ``inf``. Previously, this would return + a double precision result even if the ``1e50`` was not a 0-D array + +In other cases, increased precision may occur. For example:: + + np.multiple(float32_arr, 2.) + float32_arr * np.float64(2.) + +Will both return a float64 rather than ``float32``. This improves precision but +slightly changes results and uses double the memory. + + +Changes due to the integer "ladder of precision" +------------------------------------------------ + +When creating an array from a Python integer, NumPy will try the following +types in order, with the result depending on the value:: + + long (usually int64) → int64 → uint64 -> object + +which is subtly different from the promotion described above. + +This NEP currently does not include changing this ladder (although it may be +suggested in a separate document). +However, in mixed operations, this ladder will be ignored, since the value +will be ignored. This means, that operations will never silently use the +``object`` dtype:: + + np.array([3]) + 2**100 # Will error + +The user will have to write one of:: + + np.array([3]) + np.array(2**100) + np.array([3]) + np.array(2**100, dtype=object) + +As such implicit conversion to ``object`` should be rare and the work-around +is clear, we expect that the backwards compatibility concerns are fairly small. + + +Detailed description +==================== + +The following provides some additional details on the current "value based" +promotion logic, and then on the "weak scalar" promotion and how it is handled +internally. + +.. _Old implementation: + +Old implementation of "values based" promotion +---------------------------------------------- + +This section reviews how the current value-based logic works in practice, +please see the following section for examples on how it can be useful. + +When NumPy sees a "scalar" value, which can be a Python int, float, complex, +a NumPy scalar or an array:: + + 1000 # Python scalar + int32(1000) # NumPy scalar + np.array(1000, dtype=int64) # zero dimensional + +Or the float/complex equivalents, NumPy will ignore the precision of the dtype +and find the smallest possible dtype that can hold the value. +That is, it will try the following dtypes: + +* Integral: ``uint8``, ``int8``, ``uint16``, ``int16``, ``uint32``, ``int32``, + ``uint64``, ``int64``. +* Floating: ``float16``, ``float32``, ``float64``, ``longdouble``. +* Complex: ``complex64``, ``complex128``, ``clongdouble``. + +Note that e.g. for the integer value of ``10``, the smallest dtype can be +*either* ``uint8`` or ``int8``. + +NumPy never applied this rule when all arguments are scalar values: + + np.int64(1) + np.int32(2) == np.int64(3) + +For integers, whether a value fits is decided precisely by whether it can +be represented by the dtype. +For float and complex, the a dtype is considered sufficient if: + +* ``float16``: ``-65000 < value < 65000`` (or NaN/Inf) +* ``float32``: ``-3.4e38 < value < 3.4e38`` (or NaN/Inf) +* ``float64``: ``-1.7e308 < value < 1.7e308`` (or Nan/Inf) +* ``longdouble``: (largest range, so no limit) + +for complex these bounds were applied to the real and imaginary component. +These values roughly correspond to ``np.finfo(np.float32).max``. +(NumPy did never force the use of ``float64`` for a value of +``float32(3.402e38)`` though, but it will for a Python value of ``3.402e38``.) + + +State of the current "value based" promotion +--------------------------------------------- + +Before we can propose alternatives to the current datatype system, +it is helpful to review how "value based promotion" is used and can be useful. +Value based promotion allows for the following code to work:: + + # Create uint8 array, as this is sufficient: + uint8_arr = np.array([1, 2, 3], dtype=np.uint8) + result = uint8_arr + 4 + result.dtype == np.uint8 + + result = uint8_arr * (-1) + result.dtype == np.int16 # upcast as little as possible. + +Where especially the first part can be useful: The user knows that the input +is an integer array with a specific precision. Considering that plain ``+ 4`` +retaining the previous datatype is intuitive. +Replacing this example with ``np.float32`` is maybe even more clear, +as float will rarely have overflows. +Without this behaviour, the above example would require writing ``np.uint8(4)`` +and lack of the behaviour would make the following surprising:: + + result = np.array([1, 2, 3], dtype=np.float32) * 2. + result.dtype == np.float32 + +where lack of a special case would cause ``float64`` to be returned. + +It is important to note that the behaviour also applies to universal functions +and zero dimensional arrays:: + + # This logic is also used for ufuncs: + np.add(uint8_arr, 4).dtype == np.uint8 + # And even if the other array is explicitly typed: + np.add(uint8_arr, np.array(4, dtype=np.int64)).dtype == np.uint8 + +To review, if we replace ``4`` with ``[4]`` to make it one dimensional, the +result will be different:: + + # This logic is also used for ufuncs: + np.add(uint8_arr, [4]).dtype == np.int64 # platform dependent + # And even if the other array is explicitly typed: + np.add(uint8_arr, np.array([4], dtype=np.int64)).dtype == np.int64 + + +Proposed Weak Promotion +----------------------- + +This proposal uses a "weak scalar" logic. This means that Python ``int``, ``float``, +and ``complex`` are not assigned one of the typical dtypes, such as float64 or int64. +Rather, they are assigned a special abstract DType, similar to the "scalar" hierarchy +names: Integral, Floating, ComplexFloating. + +When promotion occurs (as it does for ufuncs if no exact loop matches), +the other DType is able to decide how to regard the Python +scalar. E.g. a ``UInt16`` promoting with an ``Integral`` will give ``UInt16``. + +.. note:: + + A default will most likely be provided in the future for user-defined DTypes. + Most likely this will end up being the default integer/float, but in principle + more complex schemes could be implemented. + +At no time is the value used to decide the result of this promotion. The value is only +considered when it is converted to the new dtype; this may raise an error. + + +Related Work +============ + +Different Python projects that fill a similar space to NumPy prefer the weakly +typed Python scalars as proposed in this NEP. Details of these may differ +or be unspecified though: + +* `JAX promotion`_ also uses the weak-scalar concept. However, it makes use + of it also for most functions. JAX further stores the "weak-type" information + on the array: ``jnp.array(1)`` remains weakly typed. + +* `data-apis.org`_ also suggests this weak-scalar logic for the Python scalars. + + +Implementation +============== + +Implementing this NEP requires some additional machinery to be added to all +binary operators (or ufuncs), so that they attempt to use the "weak" logic +if possible. +There are two possible approaches to this: + +1. The binary operator simply tries to call ``np.result_type()`` if this + situation arises and converts the Python scalar to the result-type (if + defined). +2. The binary operator indicates that an input was a Python scalar, and the + ufunc dispatching/promotion machinery is used for the rest (see + :ref:`NEP 42 `). This allows more flexibility, but requires some + additional logic in the ufunc machinery. + +.. note:: + As of now, it is not quite clear which approach is better, either will + give fairly equivalent results and 1. could be extended by 2. in the future + if necessary. + +It further requires removing all current special value-based code paths. + +Unintuitively, a larger step in the implementation may be to implement a +solution to allow an error to be raised in the following example:: + + np.arange(10, dtype=np.uint8) + 1000 + +Even though ``np.uint8(1000)`` returns the same value as ``np.uint8(232)``. + +.. note:: + + See alternatives, we may yet decide that this silent overflow is acceptable + or at least a separate issue. + + +Alternatives +============ + +There are several design axes where different choices are possible. +The below sections outline these. + +Use strongly-typed scalars or a mix of both +------------------------------------------- + +The simplest solution to the value-based promotion/casting issue would be to use +strongly typed Python scalars, i.e. Python floats are considered double precision +and Python integers are always considered the same as the default integer dtype. + +This would be the simplest solution, however, it would lead to many upcasts when +working with arrays of ``float32`` or ``int16``, etc. The solution for these cases +would be to rely on in-place operations. +We currently believe that while less dangerous, this change would affect many users +and would be surprising more often than not (although expectations differ widely). + +In principle, the weak vs. strong behaviour need not be uniform. It would also +be possible to make Python floats use the weak behaviour, but Python integers use the +strong one, since integer overflows are far more surprising. + + +Do not use weak scalar logic in functions +----------------------------------------- + +One alternative to this NEPs proposal is to narrow the use of weak types +to Python operators. + +This has advantages and disadvantages: + +* The main advantage is that limiting it to Python operators means that these + "weak" types/dtypes are clearly ephemeral to short Python statements. +* A disadvantage is that ``np.multiply`` and ``*`` are less interchangeable. +* Using "weak" promotion only for operators means that libraries do not have + to worry about whether they want to "remember" that an input was a Python + scalar initially. On the other hand, it would add a the need for slightly + different (or additional) logic for Python operators. + (Technically, probably as a flag to the ufunc dispatching mechanism to toggle + the weak logic.) +* ``__array_ufunc__`` is often used on its own to provide Python operator + support for array-likes implementing it. If operators are special, these + array-likes may need a mechanism to match NumPy (e.g. a kwarg to ufuncs to + enable weak promotion.) + + +NumPy scalars could be special +------------------------------ + +Many users expect that NumPy scalars should be different from NumPy +arrays, in that ``np.uint8(3) + 3`` should return an ``int64`` (or Python +integer), when ``uint8_arr + 3`` preserves the ``uint8`` dtype. + +This alternative would be very close to the current behaviour for NumPy scalars +but it would cement a distinction between arrays and scalars (NumPy arrays +are "stronger" than Python scalars, but NumPy scalars are not). + +Such a distinction is very much possible, however, at this time NumPy will +often (and silently) convert 0-D arrays to scalars. +It may thus make sense, to only consider this alternative if we also +change this silent conversion (sometimes referred to as "decay") behaviour. + + +Handling conversion of scalars when unsafe +------------------------------------------ + +Cases such as:: + + np.arange(10, dtype=np.uint8) + 1000 + +should raise an error as per this NEP. This could be relaxed to give a warning +or even ignore the "unsafe" conversion which (on all relevant hardware) would +lead to ``np.uint8(1000) == np.uint8(232)`` being used. + + +Allowing weakly typed arrays +---------------------------- + +One problem with having weakly typed Python scalars, but not weakly typed +arrays is that in many cases ``np.asarray()`` is called indiscriminately on +inputs. To solve this issue JAX will consider the result of ``np.asarray(1)`` +also to be weakly typed. +There are, however, two difficulties with this: + +1. JAX noticed that it can be confusing that:: + + np.broadcast_to(np.asarray(1), (100, 100)) + + is a non 0-D array that "inherits" the weak typing. [2]_ +2. Unlike JAX tensors, NumPy arrays are mutable, so assignment may need to + cause it to be strongly typed? + +A flag will likely be useful as an implementation detail (e.g. in ufuncs), +however, as of now we do not expect to have this as user API. +The main reason is that such a flag may be surprising for users if it is +passed out as a result from a function, rather than used only very localized. + + +.. admonition:: TODO + + Before accepting the NEP it may be good to discuss this issue further. + Libraries may need clearer patterns to "propagate" the "weak" type, this + could just be an ``np.asarray_or_literal()`` to preserve Python scalars, + or a pattern of calling ``np.result_type()`` before ``np.asarray()``. + + +Keep using value-based logic for Python scalars +----------------------------------------------- + +Some of the main issues with the current logic arise, because we apply it +to NumPy scalars and 0-D arrays, rather than the application to Python scalars. +We could thus consider to keep inspecting the value for Python scalars. + +We reject this idea on the grounds that it will not remove the surprises +given earlier:: + + np.uint8(100) + 1000 == np.uint16(1100) + np.uint8(100) + 200 == np.uint8(44) + +And adapting the precision based on the result value rather than the input +value might be possible for scalar operations, but is not feasible for array +operations. +This is because array operations need to allocate the result array before +performing the calculation. + + +Discussion +========== + +* https://github.com/numpy/numpy/issues/2878 +* https://mail.python.org/archives/list/numpy-discussion@python.org/thread/R7D65SNGJW4PD6V7N3CEI4NJUHU6QP2I/#RB3JLIYJITVO3BWUPGLN4FJUUIKWKZIW +* https://mail.python.org/archives/list/numpy-discussion@python.org/thread/NA3UBE3XAUTXFYBX6HPIOCNCTNF3PWSZ/#T5WAYQPRMI5UCK7PKPCE3LGK7AQ5WNGH +* Poll about the desired future behavior: https://discuss.scientific-python.org/t/poll-future-numpy-behavior-when-mixing-arrays-numpy-scalars-and-python-scalars/202 + +References and Footnotes +======================== + +.. [1] Each NEP must either be explicitly labeled as placed in the public domain (see + this NEP as an example) or licensed under the `Open Publication License`_. + +.. _Open Publication License: https://www.opencontent.org/openpub/ + +.. _JAX promotion: https://jax.readthedocs.io/en/latest/type_promotion.html + +.. _data-apis.org: https://data-apis.org/array-api/latest/API_specification/type_promotion.html + +.. [2] https://github.com/numpy/numpy/pull/21103/files#r814188019 + +Copyright +========= + +This document has been placed in the public domain. [1]_ diff --git a/doc/neps/nep-0051-scalar-representation.rst b/doc/neps/nep-0051-scalar-representation.rst new file mode 100644 index 000000000000..851f173deae3 --- /dev/null +++ b/doc/neps/nep-0051-scalar-representation.rst @@ -0,0 +1,337 @@ +.. _NEP51: + +===================================================== +NEP 51 — Changing the representation of NumPy scalars +===================================================== +:Author: Sebastian Berg +:Status: Draft +:Type: Standards Track +:Created: 2022-09-13 + + +Abstract +======== + +NumPy has scalar objects ("NumPy scalar") representing a single value +corresponding to a NumPy DType. The representation of these currently +matches that of the Python builtins, giving:: + + >>> np.float32(3.0) + 3.0 + +In this NEP we propose to change the representation to include the +NumPy scalar type information. Changing the above example to:: + + >>> np.float32(3.0) + np.float32(3.0) + +We expect that this change will help users distinguish the NumPy scalars +from the Python builtin types and clarify their behavior. + +The distinction between NumPy scalars and Python builtins will further become +more important for users once :ref:`NEP 50 ` is adopted. + +These changes do lead to smaller incompatible and infrastructure changes +related to array printing. + +Motivation and Scope +==================== + +This NEP proposes to change the representation of the following +NumPy scalars types to distinguish them from the Python scalars: + +* ``np.bool_`` +* ``np.uint8``, ``np.int8``, and all other integer scalars +* ``np.float16``, ``np.float32``, ``np.float64``, ``np.longdouble`` +* ``np.complex64``, ``np.complex128``, ``np.clongdouble`` +* ``np.str_``, ``np.bytes_`` +* ``np.void`` (structured dtypes) + +Additionally, the representation of the remaining NumPy scalars will be +adapted to print as ``np.`` rather than ``numpy.``: + +* ``np.datetime64`` and ``np.timedelta64`` +* ``np.void`` (unstructured version) + +The NEP does not propose to change how these scalars print – only +their representation (``__repr__``) will be changed. +Further, array representation will not be affected since it already +includes the ``dtype=`` when necessary. + +The main motivation behind the change is that the Python numerical types +behave differently from the NumPy scalars. +For example numbers with lower precision (e.g. ``uint8`` or ``float16``) +should be used with care and users should be aware when they are working +with them. All NumPy integers can experience overflow which Python integers +do not. +These differences will be exacerbated when adopting :ref:`NEP 50 ` +because the lower precision NumPy scalar will be preserved more often. +Even ``np.float64``, which is very similar to Python's ``float`` and inherits +from it, does behave differently for example when dividing by zero. + +Another common source of confusion are the NumPy booleans. Python programmers +somtimes write ``obj is True`` and will surprised when an object that shows +as ``True`` fails to pass the test. +It is much easier to understand this behavior when the value is +shown as ``np.True_``. + +Not only do we expect the change to help users better understand and be +reminded of the differences between NumPy and Python scalars, but we also +believe that the awareness will greatly help debugging. + +Usage and Impact +================ + +Most user code should not be impacted by the change, but users will now +often see NumPy values shown as:: + + np.True_ + np.float64(3.0) + np.int64(34) + +and so on. This will also mean that documentation and output in +Jupyter notebook cells will often show the type information intact. + +``np.longdouble`` and ``np.clongdouble`` will print with single quotes:: + + np.longdouble('3.0') + +to allow round-tripping. Addtionally to this change, ``float128`` will +now always be printed as ``longdouble`` since the old name gives a false +impression of precision. + +Backward compatibility +====================== + +We expect that most workflows will not be affected as only printing +changes. In general we believe that informing users about the type +they are working with outweighs the need for adapting printing in +some instances. + +The NumPy test suite includes code such as ``decimal.Decimal(repr(scalar))``. +This code needs to be modified to use the ``str()``. + +An exception to this are downstream libraries with documentation and +especially documentation testing. +Since the representation of many values will change, in many cases +the documentation will have to be updated. +This is expected to require larger documentation fixups in the mid-term. + +It may be necessary to adopt tools for doctest testing to +allow approximate value checking for the new representation. + +Changes to ``arr.tofile()`` +--------------------------- +``arr.tofile()`` currently stores values as ``repr(arr.item())`` when in text +mode. This is not always ideal since that may include a conversion to +Python. +One issue is that this would start saving longdouble as +``np.longdouble('3.1')`` which is clearly not desired. We expect that this +method is rarely used for object arrays. For string arrays, using the ``repr`` +also leads to storing ``"string"`` or ``b"string"`` which seems rarely desired. + +The proposal is to change the default (back) to use ``str`` rather than +``repr``. If ``repr`` is desired, users will have to pass ``fmt=%r``. + + +Detailed description +==================== + +This NEP proposes to change the represenatation for NumPy scalars to: + +* ``np.True_`` and ``np.False_`` for booleans (their singleton instances) +* ``np.scalar()``, i.e. ``np.float64(3.0)`` for all numerical dtypes. +* The value for ``np.longdouble`` and ``np.clongdouble`` will be given in quotes: + ``np.longdouble('3.0')``. This ensures that it can always roundtrip correctly + and matches the way that ``decimal.Decimal`` behaves. + For these two the size-based name such as ``float128`` will not be used + as the actual size is platform-dependent and therefore misleading. +* ``np.str_("string")`` and ``np.bytes_(b"byte_string")`` for string dtypes. +* ``np.void((3, 5), dtype=[('a', '>> np.longlong + numpy.longlong + >>> np.longlong(3) + np.int64(3) + +The proposal will lead to the ``longlong`` name for the type while +using the ``int64`` form for the scalar. +This choice is made since ``int64`` is generally the more useful +information for users, but the type name itself must be precise. + + +Related Work +============ + +A PR to only change the representation of booleans was previously +made `here `_. + +The implementation is (at the time of writing) largely finished and can be +found `here `_ + +Implementation +============== + +The new representations can be mostly implemented on the scalar types with +the largest changes needed in the test suite. + +The proposed changes for void scalars and masked ``fill_value`` makes it +necessary to expose the scalar representation without the type. + +We propose introducing the semi-public API:: + + np.core.arrayprint.get_formatter(*, + data=None, dtype=None, fmt=None, options=None) + +to replace the current internal ``_get_formatting_func``. This will allow +two things compared to the old function: + +* ``data`` may be ``None`` (if ``dtype`` is passed) allowing to not pass + multiple values that will be printed/formatted later. +* ``fmt=`` will allow passing on format strings to a DType-specific element + formatter in the future. For now, ``get_formatter()`` will accept + ``repr`` or ``str`` (the singletons not strings) to format the elements + without type information (``'3.1'`` rather than ``np.longdouble('3.1')``). + The implementation ensures that formatting matches except for the type + information. + + The empty format string will print identically to ``str()`` (with possibly + extra padding when data is passed). + +``get_formatter()`` is expected to query a user DType's method in the future +allowing customized formatting for all DTypes. + +Making ``get_formatter`` public allows it to be used for ``np.record`` and +masked arrays. +Currenlty, the formatters themselves seem semi-public; using a single +entry-point will hopefully provide a clear API for formatting NumPy values. + +The large part for the scalar representation changes had previously been done +by Ganesh Kathiresan in [2]_. + +Alternatives +============ + +Different representations can be considered: alternatives include spelling +``np.`` as ``numpy.`` or dropping the ``np.`` part from the numerical scalars. +We believe that using ``np.`` is sufficiently clear, concise, and does allow +copy pasting the representation. +Using only ``float64(3.0)`` without the ``np.`` prefix is more concise but +contexts may exists where the NumPy dependency is not fully clear and the name +could clash with other libraries. + +For booleans an alternative would be to use ``np.bool_(True)`` or ``bool_(True)``. +However, NumPy boolean scalars are singletons and the proposed formatting is more +concise. Alternatives for booleans were also discussed previously in [1]_. + +For the string scalars, the confusion is generally less pronounced. It may be +reasonable to defer changing these. + +Non-finite values +----------------- +The proposal does not allow copy pasting ``nan`` and ``inf`` values. +They could be represented by ``np.float64('nan')`` or ``np.float64(np.nan)`` +instead. +This is more concise and Python also uses ``nan`` and ``inf`` rather than +allowing copy-pasting by showing it as ``float('nan')``. Arguably, it would be +a smaller addition in NumPy, where the will already be always printed. + +Alternatives for the new ``get_formatter()`` +-------------------------------------------- +When ``fmt=`` is passed, and specifically for the main use (in this NEP) to +format to a ``repr`` or ``str``. +It would also be possible to use a ufunc or a direct formatting function +rather than wrapping it into a ```get_formatter()`` which relies on +instantiating a formatter class for the DType. + +This NEP does not preclude creating a ufunc or making a special path. +However, NumPy array formatting commonly looks at all values to be formatted +in order to add padding for alignment or give uniform exponential output. +In this case ``data=`` is passed and used in preparation. This form of +formatting (unlike the scalar case where ``data=None`` would be desired) is +unfortunately fundamentally incompatible with UFuncs. + +The use of the singleton ``str`` and ``repr`` ensures that future formatting +strings like ``f"{arr:r}"`` are not in any way limited by using ``"r"`` or +``"s"`` instead. + +Discussion +========== + +* An initial discussion on this changed happened in the mailing list: + https://mail.python.org/archives/list/numpy-discussion@python.org/thread/7GLGFHTZHJ6KQPOLMVY64OM6IC6KVMYI/ +* There was a previous issue [1]_ and PR [2]_ to change only the + representation of the NumPy booleans. The PR was later updated to change + the representation of all (or at least most) NumPy scalars. + + +References and Footnotes +======================== + +.. [1] https://github.com/numpy/numpy/issues/12950 +.. [2] https://github.com/numpy/numpy/pull/17592 + +Copyright +========= + +This document has been placed in the public domain. diff --git a/doc/neps/open.rst.tmpl b/doc/neps/open.rst.tmpl new file mode 100644 index 000000000000..78cdafb8280c --- /dev/null +++ b/doc/neps/open.rst.tmpl @@ -0,0 +1,9 @@ +Open NEPs (under consideration) +------------------------------- + +.. toctree:: + :maxdepth: 1 + +{% for nep, tags in neps.items() if tags['Status'] == 'Draft' %} + {{ tags['Title'] }} <{{ tags['Filename'] }}> +{% endfor %} diff --git a/doc/neps/provisional.rst.tmpl b/doc/neps/provisional.rst.tmpl new file mode 100644 index 000000000000..4c289db98173 --- /dev/null +++ b/doc/neps/provisional.rst.tmpl @@ -0,0 +1,9 @@ +Provisional NEPs (provisionally accepted; interface may change) +--------------------------------------------------------------- + +.. toctree:: + :maxdepth: 1 + +{% for nep, tags in neps.items() if tags['Status'] == 'Provisional' %} + {{ tags['Title'] }} <{{ tags['Filename'] }}> +{% endfor %} diff --git a/doc/neps/rejected.rst.tmpl b/doc/neps/rejected.rst.tmpl new file mode 100644 index 000000000000..5898a8cff400 --- /dev/null +++ b/doc/neps/rejected.rst.tmpl @@ -0,0 +1,9 @@ +Rejected and Withdrawn NEPs +--------------------------- + +.. toctree:: + :maxdepth: 1 + +{% for nep, tags in neps.items() if tags['Status'] in ('Rejected', 'Withdrawn') %} + {{ tags['Title'] }} <{{ tags['Filename'] }}> +{% endfor %} diff --git a/doc/neps/tools/build_index.py b/doc/neps/tools/build_index.py index 51227a6f1273..bcf414ddc872 100644 --- a/doc/neps/tools/build_index.py +++ b/doc/neps/tools/build_index.py @@ -1,6 +1,7 @@ """ Scan the directory of nep files and extract their metadata. The -metadata is passed to Jinja for filling out `index.rst.tmpl`. +metadata is passed to Jinja for filling out the toctrees for various NEP +categories. """ import os @@ -50,7 +51,7 @@ def nep_metadata(): if not tags['Title'].startswith(f'NEP {nr} — '): raise RuntimeError( f'Title for NEP {nr} does not start with "NEP {nr} — " ' - '(note that — here is a special, enlongated dash). Got: ' + '(note that — here is a special, elongated dash). Got: ' f' {tags["Title"]!r}') if tags['Status'] in ('Accepted', 'Rejected', 'Withdrawn'): @@ -100,14 +101,16 @@ def nep_metadata(): return {'neps': neps, 'has_provisional': has_provisional} - -infile = 'index.rst.tmpl' -outfile = 'index.rst' - meta = nep_metadata() -print(f'Compiling {infile} -> {outfile}') -index = render(infile, meta) - -with open(outfile, 'w') as f: - f.write(index) +for nepcat in ( + "provisional", "accepted", "deferred", "finished", "meta", + "open", "rejected", +): + infile = f"{nepcat}.rst.tmpl" + outfile =f"{nepcat}.rst" + + print(f'Compiling {infile} -> {outfile}') + genf = render(infile, meta) + with open(outfile, 'w') as f: + f.write(genf) diff --git a/doc/records.rst.txt b/doc/records.rst similarity index 100% rename from doc/records.rst.txt rename to doc/records.rst diff --git a/doc/release/upcoming_changes/17530.improvement.rst b/doc/release/upcoming_changes/17530.improvement.rst deleted file mode 100644 index 07a23f0e5e6b..000000000000 --- a/doc/release/upcoming_changes/17530.improvement.rst +++ /dev/null @@ -1,5 +0,0 @@ -`ctypeslib.load_library` can now take any path-like object ------------------------------------------------------------------------ -All parameters in the can now take any :term:`python:path-like object`. -This includes the likes of strings, bytes and objects implementing the -:meth:`__fspath__` protocol. diff --git a/doc/release/upcoming_changes/17582.new_feature.rst b/doc/release/upcoming_changes/17582.new_feature.rst deleted file mode 100644 index c2426330c6d7..000000000000 --- a/doc/release/upcoming_changes/17582.new_feature.rst +++ /dev/null @@ -1,10 +0,0 @@ -NEP 49 configurable allocators ------------------------------- -As detailed in `NEP 49`_, the function used for allocation of the data segment -of a ndarray can be changed. The policy can be set globally or in a context. -For more information see the NEP and the :ref:`data_memory` reference docs. -Also add a ``NUMPY_WARN_IF_NO_MEM_POLICY`` override to warn on dangerous use -of transfering ownership by setting ``NPY_ARRAY_OWNDATA``. - -.. _`NEP 49`: https://numpy.org/neps/nep-0049.html - diff --git a/doc/release/upcoming_changes/18536.improvement.rst b/doc/release/upcoming_changes/18536.improvement.rst deleted file mode 100644 index 8693916dbdba..000000000000 --- a/doc/release/upcoming_changes/18536.improvement.rst +++ /dev/null @@ -1,7 +0,0 @@ -Add ``smallest_normal`` and ``smallest_subnormal`` attributes to `finfo` -------------------------------------------------------------------------- - -The attributes ``smallest_normal`` and ``smallest_subnormal`` are available as -an extension of `finfo` class for any floating-point data type. To use these -new attributes, write ``np.finfo(np.float64).smallest_normal`` or -``np.finfo(np.float64).smallest_subnormal``. diff --git a/doc/release/upcoming_changes/18585.new_feature.rst b/doc/release/upcoming_changes/18585.new_feature.rst deleted file mode 100644 index bb83d755cf4e..000000000000 --- a/doc/release/upcoming_changes/18585.new_feature.rst +++ /dev/null @@ -1,15 +0,0 @@ -Implementation of the NEP 47 (adopting the array API standard) --------------------------------------------------------------- - -An initial implementation of `NEP 47`_ (adoption the array API standard) has -been added as ``numpy.array_api``. The implementation is experimental and will -issue a UserWarning on import, as the `array API standard -`_ is still in draft state. -``numpy.array_api`` is a conforming implementation of the array API standard, -which is also minimal, meaning that only those functions and behaviors that -are required by the standard are implemented (see the NEP for more info). -Libraries wishing to make use of the array API standard are encouraged to use -``numpy.array_api`` to check that they are only using functionality that is -guaranteed to be present in standard conforming implementations. - -.. _`NEP 47`: https://numpy.org/neps/nep-0047-array-api-standard.html diff --git a/doc/release/upcoming_changes/18884.new_feature.rst b/doc/release/upcoming_changes/18884.new_feature.rst deleted file mode 100644 index 41503b00e577..000000000000 --- a/doc/release/upcoming_changes/18884.new_feature.rst +++ /dev/null @@ -1,7 +0,0 @@ -Generate C/C++ API reference documentation from comments blocks is now possible -------------------------------------------------------------------------------- -This feature depends on Doxygen_ in the generation process and on Breathe_ -to integrate it with Sphinx. - -.. _`Doxygen`: https://www.doxygen.nl/index.html -.. _`Breathe`: https://breathe.readthedocs.io/en/latest/ diff --git a/doc/release/upcoming_changes/19062.new_feature.rst b/doc/release/upcoming_changes/19062.new_feature.rst deleted file mode 100644 index 17171556853c..000000000000 --- a/doc/release/upcoming_changes/19062.new_feature.rst +++ /dev/null @@ -1,21 +0,0 @@ -Assign the platform-specific ``c_intp`` precision via a mypy plugin -------------------------------------------------------------------- - -The mypy_ plugin, introduced in `numpy/numpy#17843`_, has again been expanded: -the plugin now is now responsible for setting the platform-specific precision -of `numpy.ctypeslib.c_intp`, the latter being used as data type for various -`numpy.ndarray.ctypes` attributes. - -Without the plugin, aforementioned type will default to `ctypes.c_int64`. - -To enable the plugin, one must add it to their mypy `configuration file`_: - -.. code-block:: ini - - [mypy] - plugins = numpy.typing.mypy_plugin - - -.. _mypy: http://mypy-lang.org/ -.. _configuration file: https://mypy.readthedocs.io/en/stable/config_file.html -.. _`numpy/numpy#17843`: https://github.com/numpy/numpy/pull/17843 diff --git a/doc/release/upcoming_changes/19083.new_feature.rst b/doc/release/upcoming_changes/19083.new_feature.rst deleted file mode 100644 index 92f00c0d6111..000000000000 --- a/doc/release/upcoming_changes/19083.new_feature.rst +++ /dev/null @@ -1,6 +0,0 @@ -Add NEP 47-compatible dlpack support ------------------------------------- - -Add a ``ndarray.__dlpack__()`` method which returns a ``dlpack`` C structure -wrapped in a ``PyCapsule``. Also add a ``np._from_dlpack(obj)`` function, where -``obj`` supports ``__dlpack__()``, and returns an ``ndarray``. diff --git a/doc/release/upcoming_changes/19135.change.rst b/doc/release/upcoming_changes/19135.change.rst deleted file mode 100644 index 0b900a16acc1..000000000000 --- a/doc/release/upcoming_changes/19135.change.rst +++ /dev/null @@ -1,10 +0,0 @@ -Removed floor division support for complex types ------------------------------------------------- - -Floor division of complex types will now result in a `TypeError` - -.. code-block:: python - - >>> a = np.arange(10) + 1j* np.arange(10) - >>> a // 1 - TypeError: ufunc 'floor_divide' not supported for the input types, and the inputs could not be safely coerced to any supported types according to the casting rule ''safe'' diff --git a/doc/release/upcoming_changes/19151.improvement.rst b/doc/release/upcoming_changes/19151.improvement.rst deleted file mode 100644 index 2108b9c4f96d..000000000000 --- a/doc/release/upcoming_changes/19151.improvement.rst +++ /dev/null @@ -1,6 +0,0 @@ -`numpy.linalg.qr` accepts stacked matrices as inputs ----------------------------------------------------- - -`numpy.linalg.qr` is able to produce results for stacked matrices as inputs. -Moreover, the implementation of QR decomposition has been shifted to C -from Python. diff --git a/doc/release/upcoming_changes/19211.new_feature.rst b/doc/release/upcoming_changes/19211.new_feature.rst deleted file mode 100644 index 40e42387c153..000000000000 --- a/doc/release/upcoming_changes/19211.new_feature.rst +++ /dev/null @@ -1,7 +0,0 @@ -``keepdims`` optional argument added to `numpy.argmin`, `numpy.argmax` ----------------------------------------------------------------------- - -``keepdims`` argument is added to `numpy.argmin`, `numpy.argmax`. -If set to ``True``, the axes which are reduced are left in the result as dimensions with size one. -The resulting array has the same number of dimensions and will broadcast with the -input array. diff --git a/doc/release/upcoming_changes/19259.c_api.rst b/doc/release/upcoming_changes/19259.c_api.rst deleted file mode 100644 index dac9f520a76f..000000000000 --- a/doc/release/upcoming_changes/19259.c_api.rst +++ /dev/null @@ -1,12 +0,0 @@ -Masked inner-loops cannot be customized anymore ------------------------------------------------ -The masked inner-loop selector is now never used. A warning -will be given in the unlikely event that it was customized. - -We do not expect that any code uses this. If you do use it, -you must unset the selector on newer NumPy version. -Please also contact the NumPy developers, we do anticipate -providing a new, more specific, mechanism. - -The customization was part of a never-implemented feature to allow -for faster masked operations. diff --git a/doc/release/upcoming_changes/19355.new_feature.rst b/doc/release/upcoming_changes/19355.new_feature.rst deleted file mode 100644 index cfa50b7a175c..000000000000 --- a/doc/release/upcoming_changes/19355.new_feature.rst +++ /dev/null @@ -1,13 +0,0 @@ -``bit_count`` to compute the number of 1-bits in an integer ------------------------------------------------------------ - -Computes the number of 1-bits in the absolute value of the input. -This works on all the numpy integer types. Analogous to the builtin -``int.bit_count`` or ``popcount`` in C++. - -.. code-block:: python - - >>> np.uint32(1023).bit_count() - 10 - >>> np.int32(-127).bit_count() - 7 diff --git a/doc/release/upcoming_changes/19356.change.rst b/doc/release/upcoming_changes/19356.change.rst deleted file mode 100644 index 3c5ef4a91475..000000000000 --- a/doc/release/upcoming_changes/19356.change.rst +++ /dev/null @@ -1,7 +0,0 @@ -`numpy.vectorize` functions now produce the same output class as the base function ----------------------------------------------------------------------------------- -When a function that respects `numpy.ndarray` subclasses is vectorized using -`numpy.vectorize`, the vectorized function will now be subclass-safe -also for cases that a signature is given (i.e., when creating a ``gufunc``): -the output class will be the same as that returned by the first call to -the underlying function. diff --git a/doc/release/upcoming_changes/19459.new_feature.rst b/doc/release/upcoming_changes/19459.new_feature.rst deleted file mode 100644 index aecae670feba..000000000000 --- a/doc/release/upcoming_changes/19459.new_feature.rst +++ /dev/null @@ -1,4 +0,0 @@ -The ``ndim`` and ``axis`` attributes have been added to `numpy.AxisError` -------------------------------------------------------------------------- -The ``ndim`` and ``axis`` parameters are now also stored as attributes -within each `numpy.AxisError` instance. diff --git a/doc/release/upcoming_changes/19462.change.rst b/doc/release/upcoming_changes/19462.change.rst deleted file mode 100644 index 8fbadb394ded..000000000000 --- a/doc/release/upcoming_changes/19462.change.rst +++ /dev/null @@ -1,3 +0,0 @@ -OpenBLAS v0.3.17 ----------------- -Update the OpenBLAS used in testing and in wheels to v0.3.17 diff --git a/doc/release/upcoming_changes/19478.performance.rst b/doc/release/upcoming_changes/19478.performance.rst deleted file mode 100644 index 6a389c20eb0c..000000000000 --- a/doc/release/upcoming_changes/19478.performance.rst +++ /dev/null @@ -1,11 +0,0 @@ -Vectorize umath module using AVX-512 -------------------------------------- - -By leveraging Intel Short Vector Math Library (SVML), 18 umath functions -(``exp2``, ``log2``, ``log10``, ``expm1``, ``log1p``, ``cbrt``, ``sin``, -``cos``, ``tan``, ``arcsin``, ``arccos``, ``arctan``, ``sinh``, ``cosh``, -``tanh``, ``arcsinh``, ``arccosh``, ``arctanh``) are vectorized using AVX-512 -instruction set for both single and double precision implementations. This -change is currently enabled only for Linux users and on processors with -AVX-512 instruction set. It provides an average speed up of 32x and 14x for -single and double precision functions respectively. diff --git a/doc/release/upcoming_changes/19479.compatibility.rst b/doc/release/upcoming_changes/19479.compatibility.rst deleted file mode 100644 index 83533a305749..000000000000 --- a/doc/release/upcoming_changes/19479.compatibility.rst +++ /dev/null @@ -1,7 +0,0 @@ -Distutils forces strict floating point model on clang ------------------------------------------------------ -NumPy now sets the ``-ftrapping-math`` option on clang to enforce correct -floating point error handling for universal functions. -Clang defaults to non-IEEE and C99 conform behaviour otherwise. -This change (using the equivalent but newer ``-ffp-exception-behavior=strict``) -was attempted in NumPy 1.21, but was effectively never used. diff --git a/doc/release/upcoming_changes/19513.new_feature.rst b/doc/release/upcoming_changes/19513.new_feature.rst deleted file mode 100644 index 5f945cea2b68..000000000000 --- a/doc/release/upcoming_changes/19513.new_feature.rst +++ /dev/null @@ -1,4 +0,0 @@ -Preliminary support for `windows/arm64` target ----------------------------------------------- -``numpy`` added support for windows/arm64 target. Please note -``OpenBLAS`` support is not yet available for windows/arm64 target. diff --git a/doc/release/upcoming_changes/19527.new_feature.rst b/doc/release/upcoming_changes/19527.new_feature.rst deleted file mode 100644 index 3967f18413eb..000000000000 --- a/doc/release/upcoming_changes/19527.new_feature.rst +++ /dev/null @@ -1,3 +0,0 @@ -Added support for LoongArch ------------------------------------------------- -LoongArch is a new instruction set, numpy compilation failure on LoongArch architecture, so add the commit. diff --git a/doc/release/upcoming_changes/19539.expired.rst b/doc/release/upcoming_changes/19539.expired.rst deleted file mode 100644 index 6e94f175d85c..000000000000 --- a/doc/release/upcoming_changes/19539.expired.rst +++ /dev/null @@ -1,2 +0,0 @@ -* Using the strings ``"Bytes0"``, ``"Datetime64"``, ``"Str0"``, ``"Uint32"``, - and ``"Uint64"`` as a dtype will now raise a ``TypeError``. \ No newline at end of file diff --git a/doc/release/upcoming_changes/19615.expired.rst b/doc/release/upcoming_changes/19615.expired.rst deleted file mode 100644 index 4e02771e3ad8..000000000000 --- a/doc/release/upcoming_changes/19615.expired.rst +++ /dev/null @@ -1,8 +0,0 @@ -Expired deprecations for ``loads``, ``ndfromtxt``, and ``mafromtxt`` in npyio ------------------------------------------------------------------------------ - -``numpy.loads`` was deprecated in v1.15, with the recommendation that users -use `pickle.loads` instead. -``ndfromtxt`` and ``mafromtxt`` were both deprecated in v1.17 - users should -use `numpy.genfromtxt` instead with the appropriate value for the -``usemask`` parameter. diff --git a/doc/release/upcoming_changes/19665.change.rst b/doc/release/upcoming_changes/19665.change.rst deleted file mode 100644 index 2c2315dd2597..000000000000 --- a/doc/release/upcoming_changes/19665.change.rst +++ /dev/null @@ -1,4 +0,0 @@ -Python 3.7 is no longer supported ---------------------------------- -Python support has been dropped. This is rather strict, there are -changes that require Python >=3.8. diff --git a/doc/release/upcoming_changes/19680.improvement.rst b/doc/release/upcoming_changes/19680.improvement.rst deleted file mode 100644 index 1a2a3496b835..000000000000 --- a/doc/release/upcoming_changes/19680.improvement.rst +++ /dev/null @@ -1,5 +0,0 @@ -`numpy.fromregex` now accepts ``os.PathLike`` implementations -------------------------------------------------------------- - -`numpy.fromregex` now accepts objects implementing the `__fspath__` -protocol, *e.g.* `pathlib.Path`. diff --git a/doc/release/upcoming_changes/19687.change.rst b/doc/release/upcoming_changes/19687.change.rst deleted file mode 100644 index c7f7512b6d03..000000000000 --- a/doc/release/upcoming_changes/19687.change.rst +++ /dev/null @@ -1,8 +0,0 @@ -str/repr of complex dtypes now include space after punctuation --------------------------------------------------------------- - -The repr of ``np.dtype({"names": ["a"], "formats": [int], "offsets": [2]})`` is -now ``dtype({'names': ['a'], 'formats': ['>> np.float32(-2.0).is_integer() - True - >>> np.float64(3.2).is_integer() - False - >>> np.int32(-2).is_integer() - True diff --git a/doc/release/upcoming_changes/19805.new_feature.rst b/doc/release/upcoming_changes/19805.new_feature.rst deleted file mode 100644 index f59409254a12..000000000000 --- a/doc/release/upcoming_changes/19805.new_feature.rst +++ /dev/null @@ -1,5 +0,0 @@ -Symbolic parser for Fortran dimension specifications ----------------------------------------------------- -A new symbolic parser has been added to f2py in order to correctly parse -dimension specifications. The parser is the basis for future improvements -and provides compatibility with Draft Fortran 202x. diff --git a/doc/release/upcoming_changes/19857.improvement.rst b/doc/release/upcoming_changes/19857.improvement.rst deleted file mode 100644 index cbeff08b1ade..000000000000 --- a/doc/release/upcoming_changes/19857.improvement.rst +++ /dev/null @@ -1,13 +0,0 @@ -Add new methods for ``quantile`` and ``percentile`` ---------------------------------------------------- - -``quantile`` and ``percentile`` now have have a ``method=`` -keyword argument supporting 13 different methods. -This replaces the ``interpolation=`` keyword argument. - -The methods are now aligned with nine methods which can be -found in scientific literature and the R language. -The remaining methods are the previous discontinuous variations -of the default "linear" one. - -Please see the documentation of `numpy.percentile` for more information. diff --git a/doc/release/upcoming_changes/19879.new_feature.rst b/doc/release/upcoming_changes/19879.new_feature.rst deleted file mode 100644 index c6624138b52f..000000000000 --- a/doc/release/upcoming_changes/19879.new_feature.rst +++ /dev/null @@ -1,15 +0,0 @@ -``ndarray``, ``dtype`` and ``number`` are now runtime-subscriptable -------------------------------------------------------------------- -Mimicking :pep:`585`, the `~numpy.ndarray`, `~numpy.dtype` and `~numpy.number` -classes are now subscriptable for python 3.9 and later. -Consequently, expressions that were previously only allowed in .pyi stub files -or with the help of ``from __future__ import annotations`` are now also legal -during runtime. - -.. code-block:: python - - >>> import numpy as np - >>> from typing import Any - - >>> np.ndarray[Any, np.dtype[np.float64]] - numpy.ndarray[typing.Any, numpy.dtype[numpy.float64]] diff --git a/doc/release/upcoming_changes/19921.deprecation.rst b/doc/release/upcoming_changes/19921.deprecation.rst deleted file mode 100644 index 17fa0f605be0..000000000000 --- a/doc/release/upcoming_changes/19921.deprecation.rst +++ /dev/null @@ -1,3 +0,0 @@ -* the misspelled keyword argument ``delimitor`` of - ``numpy.ma.mrecords.fromtextfile()`` has been changed into - ``delimiter``, using it will emit a deprecation warning. diff --git a/doc/release/upcoming_changes/20000.deprecation.rst b/doc/release/upcoming_changes/20000.deprecation.rst deleted file mode 100644 index e0a56cd47e91..000000000000 --- a/doc/release/upcoming_changes/20000.deprecation.rst +++ /dev/null @@ -1,5 +0,0 @@ -Passing boolean ``kth`` values to (arg-)partition has been deprecated ---------------------------------------------------------------------- -`~numpy.partition` and `~numpy.argpartition` would previously accept boolean -values for the ``kth`` parameter, which would subsequently be converted into -integers. This behavior has now been deprecated. diff --git a/doc/release/upcoming_changes/20027.improvement.rst b/doc/release/upcoming_changes/20027.improvement.rst deleted file mode 100644 index 86b3bed744e7..000000000000 --- a/doc/release/upcoming_changes/20027.improvement.rst +++ /dev/null @@ -1,17 +0,0 @@ -Missing parameters have been added to the ``nan`` functions --------------------------------------------------------------- -A number of the ``nan`` functions previously lacked parameters that were -present in their ````-based counterpart, *e.g.* the ``where`` parameter was -present in `~numpy.mean` but absent from `~numpy.nanmean`. - -The following parameters have now been added to the ``nan`` functions: - -* nanmin: ``initial`` & ``where`` -* nanmax: ``initial`` & ``where`` -* nanargmin: ``keepdims`` & ``out`` -* nanargmax: ``keepdims`` & ``out`` -* nansum: ``initial`` & ``where`` -* nanprod: ``initial`` & ``where`` -* nanmean: ``where`` -* nanvar: ``where`` -* nanstd: ``where`` diff --git a/doc/release/upcoming_changes/20049.change.rst b/doc/release/upcoming_changes/20049.change.rst deleted file mode 100644 index e1f08b3437c8..000000000000 --- a/doc/release/upcoming_changes/20049.change.rst +++ /dev/null @@ -1,5 +0,0 @@ -Corrected ``advance`` in ``PCG64DSXM`` and ``PCG64`` ----------------------------------------------------- -Fixed a bug in the ``advance`` method of ``PCG64DSXM`` and ``PCG64``. The bug only -affects results when the step was larger than :math:`2^{64}` on platforms -that do not support 128-bit integers(e.g., Windows and 32-bit Linux). diff --git a/doc/release/upcoming_changes/20201.deprecation.rst b/doc/release/upcoming_changes/20201.deprecation.rst deleted file mode 100644 index db8cda21f675..000000000000 --- a/doc/release/upcoming_changes/20201.deprecation.rst +++ /dev/null @@ -1,5 +0,0 @@ -The ``np.MachAr`` class has been deprecated -------------------------------------------- -The `~numpy.MachAr` class and `finfo.machar ` attribute have -been deprecated. Users are encouraged to access the property if interest -directly from the corresponding `~numpy.finfo` attribute. diff --git a/doc/release/upcoming_changes/20217.improvement.rst b/doc/release/upcoming_changes/20217.improvement.rst deleted file mode 100644 index 28e5c8ff714d..000000000000 --- a/doc/release/upcoming_changes/20217.improvement.rst +++ /dev/null @@ -1,10 +0,0 @@ -Annotating the main Numpy namespace --------------------------------------- -Starting from the 1.20 release, PEP 484 type annotations have been included -for parts of the NumPy library; annotating the remaining functions being a -work in progress. With the release of 1.22 this process has been completed for -the main NumPy namespace, which is now fully annotated. - -Besides the main namespace, a limited number of sub-packages contain -annotations as well. This includes, among others, `numpy.testing`, -`numpy.linalg` and `numpy.random` (available since 1.21). diff --git a/doc/release/upcoming_changes/20314.change.rst b/doc/release/upcoming_changes/20314.change.rst deleted file mode 100644 index ea7e29aff545..000000000000 --- a/doc/release/upcoming_changes/20314.change.rst +++ /dev/null @@ -1,10 +0,0 @@ -Change in generation of random 32 bit floating point variates -------------------------------------------------------------- -There was bug in the generation of 32 bit floating point values from -the uniform distribution that would result in the least significant -bit of the random variate always being 0. This has been fixed. - -This change affects the variates produced by the `random.Generator` -methods ``random``, ``standard_normal``, ``standard_exponential``, and -``standard_gamma``, but only when the dtype is specified as -``numpy.float32``. diff --git a/doc/source/_static/index-images/api.svg b/doc/source/_static/index-images/api.svg new file mode 100644 index 000000000000..e637525cc0b6 --- /dev/null +++ b/doc/source/_static/index-images/api.svg @@ -0,0 +1,31 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/doc/source/_static/index-images/contributor.svg b/doc/source/_static/index-images/contributor.svg new file mode 100644 index 000000000000..3a689e0e4cb2 --- /dev/null +++ b/doc/source/_static/index-images/contributor.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/doc/source/_static/index-images/getting_started.svg b/doc/source/_static/index-images/getting_started.svg new file mode 100644 index 000000000000..04db7e615671 --- /dev/null +++ b/doc/source/_static/index-images/getting_started.svg @@ -0,0 +1,31 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/doc/source/_static/index-images/user_guide.svg b/doc/source/_static/index-images/user_guide.svg new file mode 100644 index 000000000000..d61b0937da75 --- /dev/null +++ b/doc/source/_static/index-images/user_guide.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/doc/source/_static/numpy.css b/doc/source/_static/numpy.css index 53b610bf13d9..bc84d02dbeea 100644 --- a/doc/source/_static/numpy.css +++ b/doc/source/_static/numpy.css @@ -9,7 +9,6 @@ body { font-family: 'Open Sans', sans-serif; - color:#4A4A4A; /* numpy.org body color */ } pre, code { @@ -22,7 +21,6 @@ h1 { color: #013243; /* warm black */ } - h2 { color: #4d77cf; /* han blue */ letter-spacing: -.03em; @@ -32,3 +30,109 @@ h3 { color: #013243; /* warm black */ letter-spacing: -.03em; } + +/* Style the active version button. + +- dev: orange +- stable: green +- old, PR: red + +Colors from: + +Wong, B. Points of view: Color blindness. +Nat Methods 8, 441 (2011). https://doi.org/10.1038/nmeth.1618 +*/ + +/* If the active version has the name "dev", style it orange */ +#version_switcher_button[data-active-version-name*="dev"] { + background-color: #E69F00; + border-color: #E69F00; + color:#000000; +} + +/* green for `stable` */ +#version_switcher_button[data-active-version-name*="stable"] { + background-color: #009E73; + border-color: #009E73; +} + +/* red for `old` */ +#version_switcher_button:not([data-active-version-name*="stable"], [data-active-version-name*="dev"], [data-active-version-name=""]) { + background-color: #980F0F; + border-color: #980F0F; +} + +/* Main page overview cards */ + +.sd-card { + background: #fff; + border-radius: 0; + padding: 30px 10px 20px 10px; + margin: 10px 0px; +} + +.sd-card .sd-card-header { + text-align: center; +} + +.sd-card .sd-card-header .sd-card-text { + margin: 0px; +} + +.sd-card .sd-card-img-top { + height: 52px; + width: 52px; + margin-left: auto; + margin-right: auto; +} + +.sd-card .sd-card-header { + border: none; + background-color: white; + color: #150458 !important; + font-size: var(--pst-font-size-h5); + font-weight: bold; + padding: 2.5rem 0rem 0.5rem 0rem; +} + +.sd-card .sd-card-footer { + border: none; + background-color: white; +} + +.sd-card .sd-card-footer .sd-card-text { + max-width: 220px; + margin-left: auto; + margin-right: auto; +} + +/* Dark theme tweaking */ +html[data-theme=dark] .sd-card img[src*='.svg'] { + filter: invert(0.82) brightness(0.8) contrast(1.2); +} + +/* Main index page overview cards */ +html[data-theme=dark] .sd-card { + background-color:var(--pst-color-background); +} + +html[data-theme=dark] .sd-shadow-sm { + box-shadow: 0 .1rem 1rem rgba(250, 250, 250, .6) !important +} + +html[data-theme=dark] .sd-card .sd-card-header { + background-color:var(--pst-color-background); + color: #150458 !important; +} + +html[data-theme=dark] .sd-card .sd-card-footer { + background-color:var(--pst-color-background); +} + +html[data-theme=dark] h1 { + color: var(--pst-color-primary); +} + +html[data-theme=dark] h3 { + color: #0a6774; +} diff --git a/doc/source/_static/numpylogo_dark.svg b/doc/source/_static/numpylogo_dark.svg new file mode 100644 index 000000000000..7be7a492c511 --- /dev/null +++ b/doc/source/_static/numpylogo_dark.svg @@ -0,0 +1,23 @@ + + + + + + + + + + + + + + + + + + + + + + + diff --git a/doc/source/_templates/indexcontent.html b/doc/source/_templates/indexcontent.html deleted file mode 100644 index 450cb1e2ec68..000000000000 --- a/doc/source/_templates/indexcontent.html +++ /dev/null @@ -1,75 +0,0 @@ -{# - Loosely inspired by the deprecated sphinx/themes/basic/defindex.html -#} -{%- extends "layout.html" %} -{% set title = _('Overview') %} -{% block body %} -

{{ docstitle|e }}

-

- Welcome! This is the documentation for NumPy {{ release|e }} - {%- if last_updated %}, last updated {{ last_updated|e }}{% endif %}. - For a PDF version of the documentation, go to https://numpy.org/doc/. -

-

For users:

- - -
-

What is NumPy?
- Who uses it and why

-

NumPy: the absolute beginner's guide
-

Installation
-

NumPy quickstart
- Aimed at domain experts or people migrating to NumPy

-

NumPy for MATLAB users
-

NumPy Tutorials
- Learn about concepts and submodules

-

NumPy How Tos
- How to do common tasks with NumPy

-

NumPy fundamentals
-

Building from source
-

Using NumPy C-API
-

F2PY Users Guide and Reference Manual
- Documentation for the f2py module (Fortran extensions for Python)

-

Glossary
- List of the most important terms

-
- -

For developers/contributors:

- - -
-

NumPy contributor guide
- Contributing to NumPy

-

Under-the-hood docs
- Specialized, in-depth documentation

-

How to contribute to the NumPy documentation
-

Building the NumPy API and reference docs
-

Benchmarking
- benchmarking NumPy

-

NumPy Enhancement Proposals
-

- -

Meta information:

- - -
-

Reporting bugs

-

Release notes

- 		-

License of NumPy

-
- -

Acknowledgements

-

- Large parts of this manual originate from Travis E. Oliphant's book - "Guide to NumPy" - (which generously entered public domain in August 2008). The reference - documentation for many of the functions are written by numerous - contributors and developers of NumPy. -

-

- The preferred way to update the documentation is by submitting a pull - request on GitHub (see the Documentation guide). - Please help us to further improve the NumPy documentation! -

-{% endblock %} diff --git a/doc/source/_templates/indexsidebar.html b/doc/source/_templates/indexsidebar.html deleted file mode 100644 index 4707fc0e81e3..000000000000 --- a/doc/source/_templates/indexsidebar.html +++ /dev/null @@ -1,5 +0,0 @@ -

Resources

- diff --git a/doc/source/_templates/layout.html b/doc/source/_templates/layout.html deleted file mode 100644 index e2812fdd5ff3..000000000000 --- a/doc/source/_templates/layout.html +++ /dev/null @@ -1,10 +0,0 @@ -{% extends "!layout.html" %} - -{%- block extrahead %} -{{ super() }} - - - - - -{% endblock %} diff --git a/doc/source/bugs.rst b/doc/source/bugs.rst deleted file mode 100644 index 304a4136a4a1..000000000000 --- a/doc/source/bugs.rst +++ /dev/null @@ -1,19 +0,0 @@ -************** -Reporting bugs -************** - -File bug reports or feature requests, and make contributions -(e.g. code patches), by opening a "new issue" on GitHub: - -- NumPy Issues: https://github.com/numpy/numpy/issues - -Please give as much information as you can in the ticket. It is extremely -useful if you can supply a small self-contained code snippet that reproduces -the problem. Also specify the component, the version you are referring to and -the milestone. - -Report bugs to the appropriate GitHub project (there is one for NumPy -and a different one for SciPy). - -More information can be found on the -https://www.scipy.org/scipylib/dev-zone.html website. diff --git a/doc/source/conf.py b/doc/source/conf.py index a7a885c343d5..9546db5f281d 100644 --- a/doc/source/conf.py +++ b/doc/source/conf.py @@ -4,7 +4,7 @@ import importlib # Minimum version, enforced by sphinx -needs_sphinx = '3.2.0' +needs_sphinx = '4.3' # This is a nasty hack to use platform-agnostic names for types in the @@ -84,6 +84,7 @@ class PyTypeObject(ctypes.Structure): 'IPython.sphinxext.ipython_console_highlighting', 'IPython.sphinxext.ipython_directive', 'sphinx.ext.mathjax', + 'sphinx_design', ] skippable_extensions = [ @@ -102,12 +103,9 @@ class PyTypeObject(ctypes.Structure): # The suffix of source filenames. source_suffix = '.rst' -# Will change to `root_doc` in Sphinx 4 -master_doc = 'index' - # General substitutions. project = 'NumPy' -copyright = '2008-2021, The NumPy community' +copyright = '2008-2022, NumPy Developers' # The default replacements for |version| and |release|, also used in various # other places throughout the built documents. @@ -166,29 +164,42 @@ def setup(app): html_theme = 'pydata_sphinx_theme' -html_logo = '_static/numpylogo.svg' - html_favicon = '_static/favicon/favicon.ico' +# Set up the version switcher. The versions.json is stored in the doc repo. +if os.environ.get('CIRCLE_JOB', False) and \ + os.environ.get('CIRCLE_BRANCH', '') != 'main': + # For PR, name is set to its ref + switcher_version = os.environ['CIRCLE_BRANCH'] +elif ".dev" in version: + switcher_version = "devdocs" +else: + switcher_version = f"{version}" + html_theme_options = { - "logo_link": "index", + "logo": { + "image_light": "numpylogo.svg", + "image_dark": "numpylogo_dark.svg", + }, "github_url": "https://github.com/numpy/numpy", "twitter_url": "https://twitter.com/numpy_team", "collapse_navigation": True, "external_links": [ {"name": "Learn", "url": "https://numpy.org/numpy-tutorials/"} ], -} - - -html_additional_pages = { - 'index': 'indexcontent.html', + # Add light/dark mode and documentation version switcher: + "navbar_end": ["theme-switcher", "version-switcher", "navbar-icon-links"], + "switcher": { + "version_match": switcher_version, + "json_url": "https://numpy.org/doc/_static/versions.json", + }, } html_title = "%s v%s Manual" % (project, version) html_static_path = ['_static'] html_last_updated_fmt = '%b %d, %Y' - +html_css_files = ["numpy.css"] +html_context = {"default_mode": "light"} html_use_modindex = True html_copy_source = False html_domain_indices = False @@ -301,8 +312,8 @@ def setup(app): # ----------------------------------------------------------------------------- intersphinx_mapping = { 'neps': ('https://numpy.org/neps', None), - 'python': ('https://docs.python.org/dev', None), - 'scipy': ('https://docs.scipy.org/doc/scipy/reference', None), + 'python': ('https://docs.python.org/3', None), + 'scipy': ('https://docs.scipy.org/doc/scipy', None), 'matplotlib': ('https://matplotlib.org/stable', None), 'imageio': ('https://imageio.readthedocs.io/en/stable', None), 'skimage': ('https://scikit-image.org/docs/stable', None), @@ -311,6 +322,7 @@ def setup(app): 'pytest': ('https://docs.pytest.org/en/stable', None), 'numpy-tutorials': ('https://numpy.org/numpy-tutorials', None), 'numpydoc': ('https://numpydoc.readthedocs.io/en/latest', None), + 'dlpack': ('https://dmlc.github.io/dlpack/latest', None) } diff --git a/doc/source/user/depending_on_numpy.rst b/doc/source/dev/depending_on_numpy.rst similarity index 75% rename from doc/source/user/depending_on_numpy.rst rename to doc/source/dev/depending_on_numpy.rst index d8e97ef1f967..0582048cb735 100644 --- a/doc/source/user/depending_on_numpy.rst +++ b/doc/source/dev/depending_on_numpy.rst @@ -37,7 +37,10 @@ Testing against the NumPy main branch or pre-releases For large, actively maintained packages that depend on NumPy, we recommend testing against the development version of NumPy in CI. To make this easy, nightly builds are provided as wheels at -https://anaconda.org/scipy-wheels-nightly/. +https://anaconda.org/scipy-wheels-nightly/. Example install command:: + + pip install -U --pre --only-binary :all: -i https://pypi.anaconda.org/scipy-wheels-nightly/simple numpy + This helps detect regressions in NumPy that need fixing before the next NumPy release. Furthermore, we recommend to raise errors on warnings in CI for this job, either all warnings or otherwise at least ``DeprecationWarning`` and @@ -49,7 +52,7 @@ Adding a dependency on NumPy ---------------------------- Build-time dependency -````````````````````` +~~~~~~~~~~~~~~~~~~~~~ If a package either uses the NumPy C API directly or it uses some other tool that depends on it like Cython or Pythran, NumPy is a *build-time* dependency @@ -101,39 +104,48 @@ specify the version with ``==`` to the lowest supported version. For your other build dependencies you can probably be looser, however it's still important to set lower and upper bounds for each dependency. It's fine to specify either a range or a specific version for a dependency like ``wheel`` or ``setuptools``. -It's recommended to set the upper bound of the range to the latest already -released version of ``wheel`` and ``setuptools`` - this prevents future -releases from breaking your packages on PyPI. + +.. warning:: + + Note that ``setuptools`` does major releases often and those may contain + changes that break ``numpy.distutils``, which will *not* be updated anymore + for new ``setuptools`` versions. It is therefore recommended to set an + upper version bound in your build configuration for the last known version + of ``setuptools`` that works with your build. Runtime dependency & version ranges -``````````````````````````````````` +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ NumPy itself and many core scientific Python packages have agreed on a schedule for dropping support for old Python and NumPy versions: :ref:`NEP29`. We recommend all packages depending on NumPy to follow the recommendations in NEP 29. -For *run-time dependencies*, you specify the range of versions in +For *run-time dependencies*, specify version bounds using ``install_requires`` in ``setup.py`` (assuming you use ``numpy.distutils`` or -``setuptools`` to build). Getting the upper bound right for NumPy is slightly -tricky. If we don't set any bound, a too-new version will be pulled in a few -years down the line, and NumPy may have deprecated and removed some API that -your package depended on by then. On the other hand if you set the upper bound -to the newest already-released version, then as soon as a new NumPy version is -released there will be no matching version of your package that works with it. - -What to do here depends on your release frequency. Given that NumPy releases -come in a 6-monthly cadence and that features that get deprecated in NumPy -should stay around for another two releases, a good upper bound is -``<1.(xx+3).0`` - where ``xx`` is the minor version of the latest -already-released NumPy. This is safe to do if you release at least once a year. -If your own releases are much less frequent, you may set the upper bound a -little further into the future - this is a trade-off between a future NumPy -version _maybe_ removing something you rely on, and the upper bound being -exceeded which _may_ lead to your package being hard to install in combination -with other packages relying on the latest NumPy. - +``setuptools`` to build). + +Most libraries that rely on NumPy will not need to set an upper +version bound: NumPy is careful to preserve backward-compatibility. + +That said, if you are (a) a project that is guaranteed to release +frequently, (b) use a large part of NumPy's API surface, and (c) is +worried that changes in NumPy may break your code, you can set an +upper bound of ```__. + +.. [*] The reason for setting ``N=3`` is that NumPy will, on the + rare occasion where it makes breaking changes, raise warnings + for at least two releases. (NumPy releases about once every six + months, so this translates to a window of at least a year; + hence the subsequent requirement that your project releases at + least on that cadence.) .. note:: diff --git a/doc/source/dev/development_advanced_debugging.rst b/doc/source/dev/development_advanced_debugging.rst index 18a7f6ae9ad1..735ff732864d 100644 --- a/doc/source/dev/development_advanced_debugging.rst +++ b/doc/source/dev/development_advanced_debugging.rst @@ -1,3 +1,5 @@ +.. _advanced_debugging: + ======================== Advanced debugging tools ======================== @@ -23,7 +25,7 @@ But for example memory leaks can be particularly subtle or difficult to narrow down. We do not expect any of these tools to be run by most contributors. -However, you can ensure that we can track down such issues more easily easier: +However, you can ensure that we can track down such issues more easily: * Tests should cover all code paths, including error paths. * Try to write short and simple tests. If you have a very complicated test @@ -39,12 +41,33 @@ and means you do not have to worry about making reference counting errors, which can be intimidating. -Python debug build for finding memory leaks -=========================================== +Python debug build +================== + +Debug builds of Python are easily available for example via the system package +manager on Linux systems, but are also available on other platforms, possibly in +a less convenient format. If you cannot easily install a debug build of Python +from a system package manager, you can build one yourself using `pyenv +`_. For example, to install and globally +activate a debug build of Python 3.10.8, one would do:: + + pyenv install -g 3.10.8 + pyenv global 3.10.8 -Debug builds of Python are easily available for example on ``debian`` systems, -and can be used on all platforms. -Running a test or terminal is usually as easy as:: +Note that ``pyenv install`` builds Python from source, so you must ensure that +Python's dependencies are installed before building, see the pyenv documentation +for platform-specific installation instructions. You can use ``pip`` to install +Python dependencies you may need for your debugging session. If there is no +debug wheel available on `pypi,` you will need to build the dependencies from +source and ensure that your dependencies are also compiled as debug builds. + +Often debug builds of Python name the Python executable ``pythond`` instead of +``python``. To check if you have a debug build of Python installed, you can run +e.g. ``pythond -m sysconfig`` to get the build configuration for the Python +executable. A debug build will be built with debug compiler options in +``CFLAGS`` (e.g. ``-g -Og``). + +Running the Numpy tests or an interactive terminal is usually as easy as:: python3.8d runtests.py # or @@ -63,6 +86,8 @@ A Python debug build will help: sys.gettotalrefcount() sys.getallocatedblocks() +- Python debug builds allow easier debugging with gdb and other C debuggers. + Use together with ``pytest`` ---------------------------- @@ -106,7 +131,7 @@ Valgrind is a powerful tool to find certain memory access problems and should be run on complicated C code. Basic use of ``valgrind`` usually requires no more than:: - PYTHONMALLOC=malloc python runtests.py + PYTHONMALLOC=malloc valgrind python runtests.py where ``PYTHONMALLOC=malloc`` is necessary to avoid false positives from python itself. diff --git a/doc/source/dev/development_environment.rst b/doc/source/dev/development_environment.rst index 37cf6f7afb50..0ac02271d389 100644 --- a/doc/source/dev/development_environment.rst +++ b/doc/source/dev/development_environment.rst @@ -18,6 +18,10 @@ sources needs some additional steps, which are explained below. For the rest of this chapter we assume that you have set up your git repo as described in :ref:`using-git`. +.. note:: If you are having trouble building NumPy from source or setting up + your local development environment, you can try + to :ref:`build NumPy with Gitpod `. + .. _testing-builds: Testing builds @@ -190,9 +194,9 @@ That also takes extra arguments, like ``--pdb`` which drops you into the Python debugger when a test fails or an exception is raised. Running tests with `tox`_ is also supported. For example, to build NumPy and -run the test suite with Python 3.7, use:: +run the test suite with Python 3.9, use:: - $ tox -e py37 + $ tox -e py39 For more extensive information, see :ref:`testing-guidelines` @@ -263,6 +267,10 @@ Python is running inside gdb to verify your setup:: >end sys.version_info(major=3, minor=7, micro=0, releaselevel='final', serial=0) +Most python builds do not include debug symbols and are built with compiler +optimizations enabled. To get the best debugging experience using a debug build +of Python is encouraged, see :ref:`advanced_debugging`. + Next you need to write a Python script that invokes the C code whose execution you want to debug. For instance ``mytest.py``:: @@ -281,14 +289,28 @@ And then in the debugger:: The execution will now stop at the corresponding C function and you can step through it as usual. A number of useful Python-specific commands are available. -For example to see where in the Python code you are, use ``py-list``. For more -details, see `DebuggingWithGdb`_. Here are some commonly used commands: +For example to see where in the Python code you are, use ``py-list``, to see the +python traceback, use ``py-bt``. For more details, see +`DebuggingWithGdb`_. Here are some commonly used commands: - ``list``: List specified function or line. - ``next``: Step program, proceeding through subroutine calls. - ``step``: Continue program being debugged, after signal or breakpoint. - ``print``: Print value of expression EXP. +Rich support for Python debugging requires that the ``python-gdb.py`` script +distributed with Python is installed in a path where gdb can find it. If you +installed your Python build from your system package manager, you likely do +not need to manually do anything. However, if you built Python from source, +you will likely need to create a ``.gdbinit`` file in your home directory +pointing gdb at the location of your Python installation. For example, a +version of python installed via `pyenv `_ +needs a ``.gdbinit`` file with the following contents: + +.. code-block:: text + + add-auto-load-safe-path ~/.pyenv + Instead of plain ``gdb`` you can of course use your favourite alternative debugger; run it on the python binary with arguments ``runtests.py -g --python mytest.py``. @@ -296,8 +318,6 @@ alternative debugger; run it on the python binary with arguments Building NumPy with a Python built with debug support (on Linux distributions typically packaged as ``python-dbg``) is highly recommended. - - .. _DebuggingWithGdb: https://wiki.python.org/moin/DebuggingWithGdb .. _tox: https://tox.readthedocs.io/ .. _virtualenv: http://www.virtualenv.org/ diff --git a/doc/source/dev/development_gitpod.rst b/doc/source/dev/development_gitpod.rst index 92cca81fca69..4e386867d374 100644 --- a/doc/source/dev/development_gitpod.rst +++ b/doc/source/dev/development_gitpod.rst @@ -2,7 +2,7 @@ Using Gitpod for NumPy development -======================================================= +================================== This section of the documentation will guide you through: @@ -12,7 +12,7 @@ This section of the documentation will guide you through: * working on the NumPy documentation in Gitpod Gitpod -------- +------ `Gitpod`_ is an open-source platform for automated and ready-to-code development environments. It enables developers to describe their dev @@ -21,7 +21,7 @@ each new task directly from your browser. This reduces the need to install local development environments and deal with incompatible dependencies. Gitpod GitHub integration --------------------------- +------------------------- To be able to use Gitpod, you will need to have the Gitpod app installed on your GitHub account, so if @@ -40,7 +40,7 @@ permissions later on. Click on the green **Install** button This will install the necessary hooks for the integration. Forking the NumPy repository ------------------------------ +---------------------------- The best way to work on NumPy as a contributor is by making a fork of the repository first. @@ -50,7 +50,7 @@ repository first. https://github.com/melissawm/NumPy, except with your GitHub username in place of ``melissawm``. Starting Gitpod ----------------- +--------------- Once you have authenticated to Gitpod through GitHub, you can install the `Gitpod browser extension `_ which will add a **Gitpod** button next to the **Code** button in the @@ -86,7 +86,7 @@ of tests that make sure NumPy is working as it should, and ``-v`` activates the ``--verbose`` option to show all the test output. Quick workspace tour ---------------------- +-------------------- Gitpod uses VSCode as the editor. If you have not used this editor before, you can check the Getting started `VSCode docs`_ to familiarize yourself with it. @@ -125,7 +125,7 @@ development experience: * `VSCode Git Graph extension `_ Development workflow with Gitpod ---------------------------------- +-------------------------------- The :ref:`development-workflow` section of this documentation contains information regarding the NumPy development workflow. Make sure to check this before working on your contributions. @@ -144,7 +144,7 @@ When using Gitpod, git is pre configured for you: :alt: Gitpod workspace branches plugin screenshot Rendering the NumPy documentation ----------------------------------- +--------------------------------- You can find the detailed documentation on how rendering the documentation with Sphinx works in the :ref:`howto-build-docs` section. @@ -153,7 +153,7 @@ this task is completed, you have two main options to render the documentation in Gitpod. Option 1: Using Liveserve -*************************** +~~~~~~~~~~~~~~~~~~~~~~~~~ #. View the documentation in ``NumPy/doc/build/html``. You can start with ``index.html`` and browse, or you can jump straight to the file you're @@ -170,7 +170,7 @@ Option 1: Using Liveserve #. To stop the server click on the **Port: 5500** button on the status bar. Option 2: Using the rst extension -*********************************** +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ A quick and easy way to see live changes in a ``.rst`` file as you work on it uses the rst extension with docutils. @@ -200,13 +200,13 @@ FAQ's and troubleshooting ------------------------- How long is my Gitpod workspace kept for? -***************************************** +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Your stopped workspace will be kept for 14 days and deleted afterwards if you do not use them. Can I come back to a previous workspace? -***************************************** +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Yes, let's say you stepped away for a while and you want to carry on working on your NumPy contributions. You need to visit https://gitpod.io/workspaces and @@ -214,13 +214,13 @@ click on the workspace you want to spin up again. All your changes will be there as you last left them. Can I install additional VSCode extensions? -******************************************* +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Absolutely! Any extensions you installed will be installed in your own workspace and preserved. I registered on Gitpod but I still cannot see a ``Gitpod`` button in my repositories. -************************************************************************************* +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Head to https://gitpod.io/integrations and make sure you are logged in. Hover over GitHub and click on the three buttons that appear on the right. @@ -232,14 +232,14 @@ and confirm the changes in the GitHub application page. :alt: Gitpod integrations - edit GH permissions screenshot How long does my workspace stay active if I'm not using it? -*********************************************************** +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ If you keep your workspace open in a browser tab but don't interact with it, it will shut down after 30 minutes. If you close the browser tab, it will shut down after 3 minutes. My terminal is blank - there is no cursor and it's completely unresponsive -************************************************************************** +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Unfortunately this is a known-issue on Gitpod's side. You can sort this issue in two ways: @@ -254,7 +254,7 @@ issue in two ways: :alt: Gitpod dashboard and workspace menu screenshot I authenticated through GitHub but I still cannot commit to the repository through Gitpod. -****************************************************************************************** +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Head to https://gitpod.io/integrations and make sure you are logged in. Hover over GitHub and click on the three buttons that appear on the right. diff --git a/doc/source/dev/development_workflow.rst b/doc/source/dev/development_workflow.rst index 8c56f6fb2cbc..33bd0126d39a 100644 --- a/doc/source/dev/development_workflow.rst +++ b/doc/source/dev/development_workflow.rst @@ -185,8 +185,57 @@ Standard acronyms to start the commit message with are:: REV: revert an earlier commit STY: style fix (whitespace, PEP8) TST: addition or modification of tests + TYP: static typing REL: related to releasing numpy +Commands to skip continuous integration +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +By default a lot of continuous integration (CI) jobs are run for every PR, +from running the test suite on different operating systems and hardware +platforms to building the docs. In some cases you already know that CI isn't +needed (or not all of it), for example if you work on CI config files, text in +the README, or other files that aren't involved in regular build, test or docs +sequences. In such cases you may explicitly skip CI by including one of these +fragments in your commit message: + +* ``[skip ci]``: skip all CI +* ``[skip github]``: skip GitHub Actions "build numpy and run tests" jobs +* ``[skip actions]``: skip all GitHub Actions +* ``[skip travis]``: skip TravisCI jobs +* ``[skip azp]``: skip Azure jobs +* ``[skip circle]``: skip CircleCI jobs + +Test building wheels +~~~~~~~~~~~~~~~~~~~~ + +Numpy currently uses `cibuildwheel `_ +in order to build wheels through continuous integration services. To save resources, the +cibuildwheel wheel builders are not run by default on every single PR or commit to main. + +If you would like to test that your pull request do not break the wheel builders, +you may either append ``[wheel build]`` to the end of the commit message of the commit +or add one of the following labels to the pull request(if you have the permissions to do so): + +- ``36 - Build``: for pull requests changing build processes/configurations +- ``03 - Maintenance``: for pull requests upgrading dependencies +- ``14 - Release``: for pull requests preparing for a release + +The wheels built via github actions (including 64-bit linux, macOS, and +windows, arm64 macOS, and 32-bit windows) will be uploaded as artifacts in zip +files. You can access them from the Summary page of the "Wheel builder" +Action_. The aarch64 wheels built via travis_ CI are not available as artifacts. +Additionally, the wheels will be uploaded to +https://anaconda.org/scipy-wheels-nightly/ on the following conditions: + +- by a weekly cron job or +- if the github action or travis build has been manually triggered, which requires appropriate permissions + +The wheels will be uploaded to https://anaconda.org/multibuild-wheels-staging/ +if the build was triggered by a tag to the repo that begins with ``v`` + +.. _Action: https://github.com/numpy/numpy/actions +.. _travis: https://app.travis-ci.com/github/numpy/numpy/builds .. _workflow_mailing_list: diff --git a/doc/source/dev/gitwash/development_setup.rst b/doc/source/dev/gitwash/development_setup.rst index 2be7125da032..4cb6c8358c68 100644 --- a/doc/source/dev/gitwash/development_setup.rst +++ b/doc/source/dev/gitwash/development_setup.rst @@ -103,6 +103,10 @@ Make the local copy git config branch.main.remote upstream git config branch.main.merge refs/heads/main +#. Initialize the required git submodules: :: + + git submodule update --init + ****************************************************************************** Look it over ****************************************************************************** @@ -112,7 +116,7 @@ Look it over - the ``main`` branch you just cloned on your own machine - the ``main`` branch from your fork on GitHub, which git named ``origin`` by default - - the ``main`` branch on the the main NumPy repo, which you named + - the ``main`` branch on the main NumPy repo, which you named ``upstream``. :: diff --git a/doc/source/dev/gitwash/following_latest.rst b/doc/source/dev/gitwash/following_latest.rst index 0e98b4ec41d6..ffe753180e1c 100644 --- a/doc/source/dev/gitwash/following_latest.rst +++ b/doc/source/dev/gitwash/following_latest.rst @@ -16,7 +16,7 @@ Get the local copy of the code From the command line:: - git clone git://github.com/numpy/numpy.git + git clone https://github.com/numpy/numpy.git You now have a copy of the code tree in the new ``numpy`` directory. If this doesn't work you can try the alternative read-only url:: diff --git a/doc/source/dev/howto-docs.rst b/doc/source/dev/howto-docs.rst index 93fec509c237..b30955e3e88f 100644 --- a/doc/source/dev/howto-docs.rst +++ b/doc/source/dev/howto-docs.rst @@ -252,7 +252,7 @@ existing non-indexed comment blocks. .. doxygenclass:: DoxyLimbo Common Doxygen Tags: -++++++++++++++++++++ +~~~~~~~~~~~~~~~~~~~~ .. note:: For more tags/commands, please take a look at https://www.doxygen.nl/manual/commands.html @@ -315,7 +315,7 @@ Sub-config files can accept any of Doxygen_ `configuration options `__" Common directives: -++++++++++++++++++ +~~~~~~~~~~~~~~~~~~ ``doxygenfunction`` diff --git a/doc/source/dev/howto_build_docs.rst b/doc/source/dev/howto_build_docs.rst index b175926da075..02a8820c9d44 100644 --- a/doc/source/dev/howto_build_docs.rst +++ b/doc/source/dev/howto_build_docs.rst @@ -12,7 +12,7 @@ versions can be found at in several different formats. Development environments ------------------------- +======================== Before proceeding further it should be noted that the documentation is built with the ``make`` tool, which is not natively available on Windows. MacOS or Linux users can jump @@ -22,7 +22,7 @@ for Linux (WSL) `_. for a persistent local set-up. Gitpod -^^^^^^ +~~~~~~ Gitpod is an open-source platform that automatically creates the correct development environment right in your browser, reducing the need to install local development environments and deal with incompatible dependencies. @@ -35,12 +35,12 @@ it is often faster to build with Gitpod. Here are the in-depth instructions for .. _how-todoc.prerequisites: Prerequisites -------------- +============= Building the NumPy documentation and API reference requires the following: NumPy -^^^^^ +~~~~~ Since large parts of the main documentation are obtained from NumPy via ``import numpy`` and examining the docstrings, you will need to first @@ -56,7 +56,7 @@ Alternatively, if using Python virtual environments (via e.g. ``conda``, new virtual environment is recommended. Dependencies -^^^^^^^^^^^^ +~~~~~~~~~~~~ All of the necessary dependencies for building the NumPy docs except for Doxygen_ can be installed with:: @@ -81,7 +81,7 @@ are using Linux then you can install it through your distribution package manage warnings during the build. Submodules -^^^^^^^^^^ +~~~~~~~~~~ If you obtained NumPy via git, also get the git submodules that contain additional parts required for building the documentation:: @@ -93,7 +93,7 @@ additional parts required for building the documentation:: .. _Doxygen: https://www.doxygen.nl/index.html Instructions ------------- +============ Now you are ready to generate the docs, so write:: @@ -134,4 +134,4 @@ pdf format is also built with ``make dist``. See `HOWTO RELEASE`_ for details on how to update https://numpy.org/doc. .. _LaTeX: https://www.latex-project.org/ -.. _HOWTO RELEASE: https://github.com/numpy/numpy/blob/main/doc/HOWTO_RELEASE.rst.txt +.. _HOWTO RELEASE: https://github.com/numpy/numpy/blob/main/doc/HOWTO_RELEASE.rst diff --git a/doc/source/dev/index.rst b/doc/source/dev/index.rst index a8c9692679b3..93b57f7e26d9 100644 --- a/doc/source/dev/index.rst +++ b/doc/source/dev/index.rst @@ -27,8 +27,10 @@ the `numpy-discussion mailing list `__ (open an issue or comment on a relevant issue). These are our preferred communication channels (open source is open by nature!), however if you prefer to discuss in private first, please reach out to -our community coordinators at `numpy-team@googlegroups.com` or `numpy-team.slack.com` -(send an email to `numpy-team@googlegroups.com` for an invite the first time). +our community coordinators at `numpy-team@googlegroups.com +`_ or `numpy-team.slack.com +`__ (send an email to `numpy-team@googlegroups.com`_ for an +invite the first time). Development process - summary ============================= @@ -53,7 +55,7 @@ Here's the short summary, complete TOC links are below: git remote add upstream https://github.com/numpy/numpy.git - * Now, `git remote -v` will show two remote repositories named: + * Now, ``git remote -v`` will show two remote repositories named: - ``upstream``, which refers to the ``numpy`` repository - ``origin``, which refers to your personal fork @@ -263,6 +265,7 @@ The rest of the story reviewer_guidelines ../benchmarking NumPy C style guide + depending_on_numpy releasing governance/index howto-docs diff --git a/doc/source/dev/internals.code-explanations.rst b/doc/source/dev/internals.code-explanations.rst index b6edd61b1efa..eaa629523c17 100644 --- a/doc/source/dev/internals.code-explanations.rst +++ b/doc/source/dev/internals.code-explanations.rst @@ -421,7 +421,7 @@ the 1-D loop is completed. One loop -^^^^^^^^ +~~~~~~~~ This is the simplest case of all. The ufunc is executed by calling the underlying 1-D loop exactly once. This is possible only when we have @@ -434,7 +434,7 @@ complete. Strided loop -^^^^^^^^^^^^ +~~~~~~~~~~~~ When the input and output arrays are aligned and of the correct type, but the striding is not uniform (non-contiguous and 2-D or larger), @@ -447,7 +447,7 @@ hardware error flags are checked after each 1-D loop is completed. Buffered loop -^^^^^^^^^^^^^ +~~~~~~~~~~~~~ This is the code that handles the situation whenever the input and/or output arrays are either misaligned or of the wrong datatype @@ -514,7 +514,7 @@ objects have 0 and 1 elements respectively. Setup -^^^^^ +~~~~~ The setup function for all three methods is ``construct_reduce``. This function creates a reducing loop object and fills it with the @@ -546,7 +546,7 @@ routine returns to the actual computation routine. :meth:`Reduce ` -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ .. index:: triple: ufunc; methods; reduce @@ -585,7 +585,7 @@ the loop function on chunks no greater than the user-specified :meth:`Accumulate ` -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ .. index:: triple: ufunc; methods; accumulate @@ -611,7 +611,7 @@ calling the underlying 1-D computational loop. :meth:`Reduceat ` -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ .. index:: triple: ufunc; methods; reduceat diff --git a/doc/source/dev/releasing.rst b/doc/source/dev/releasing.rst index 75081aec1675..f5606508856d 100644 --- a/doc/source/dev/releasing.rst +++ b/doc/source/dev/releasing.rst @@ -2,15 +2,27 @@ Releasing a version =================== +The following guides include detailed information on how to prepare a NumPy +release. + +.. _prepare_release: + ------------------------ -How to Prepare a Release +How to prepare a release ------------------------ -.. include:: ../../HOWTO_RELEASE.rst.txt +.. include:: ../../HOWTO_RELEASE.rst ----------------------- -Step-by-Step Directions +Step-by-step directions ----------------------- -.. include:: ../../RELEASE_WALKTHROUGH.rst.txt +.. include:: ../../RELEASE_WALKTHROUGH.rst + +.. _branching: + +------------------ +Branch walkthrough +------------------ +.. include:: ../../BRANCH_WALKTHROUGH.rst \ No newline at end of file diff --git a/doc/source/dev/reviewer_guidelines.rst b/doc/source/dev/reviewer_guidelines.rst index ffac85f7720a..8d938319edfa 100644 --- a/doc/source/dev/reviewer_guidelines.rst +++ b/doc/source/dev/reviewer_guidelines.rst @@ -91,7 +91,17 @@ For maintainers explain why. If it's not, then it's a good idea to first explain why you think the PR is not suitable for inclusion in NumPy and then let a second committer comment or close. - +- If the PR submitter doesn't respond to your comments for 6 months, move the PR + in question to the inactive category with the “inactive” tag attached. + At this point, the PR can be closed by a maintainer. If there is any interest + in finalizing the PR under consideration, this can be indicated at any time, + without waiting 6 months, by a comment. +- Maintainers are encouraged to finalize PRs when only small changes are + necessary before merging (e.g., fixing code style or grammatical errors). + If a PR becomes inactive, maintainers may make larger changes. + Remember, a PR is a collaboration between a contributor and a reviewer/s, + sometimes a direct push is the best way to finish it. + GitHub Workflow --------------- diff --git a/doc/source/dev/underthehood.rst b/doc/source/dev/underthehood.rst index c0f37fd5b493..53af4a3f1c38 100644 --- a/doc/source/dev/underthehood.rst +++ b/doc/source/dev/underthehood.rst @@ -1,7 +1,7 @@ .. _underthehood: =========================================== -Under-the-hood Documentation for developers +Under-the-hood documentation for developers =========================================== These documents are intended as a low-level look into NumPy; focused @@ -13,3 +13,7 @@ towards developers. internals internals.code-explanations alignment + ../user/byteswapping + ../user/basics.dispatch + ../user/basics.subclassing + diff --git a/doc/source/f2py/advanced.rst b/doc/source/f2py/advanced.rst index c8efbaadb426..9a7b88e692ee 100644 --- a/doc/source/f2py/advanced.rst +++ b/doc/source/f2py/advanced.rst @@ -79,17 +79,97 @@ that defines mapping between Fortran type:: and the corresponding . The can be one of the following:: + double + float + long_double char signed_char + unsigned_char short + unsigned_short int + long long_long - float - double - long_double + unsigned complex_float complex_double complex_long_double string -For more information, see the F2Py source code ``numpy/f2py/capi_maps.py``. +For example, for a Fortran file ``func1.f`` containing: + +.. literalinclude:: ./code/f2cmap_demo.f + :language: fortran + +In order to convert ``int64`` and ``real64`` to valid ``C`` data types, +a ``.f2py_f2cmap`` file with the following content can be created in the current directory: + +.. code-block:: python + + dict(real=dict(real64='double'), integer=dict(int64='long long')) + +and create the module as usual. F2PY checks if a ``.f2py_f2cmap`` file is present +in the current directory and will use it to map ``KIND`` specifiers to ``C`` data types. + +.. code-block:: sh + + f2py -c func1.f -m func1 + +Alternatively, the mapping file can be saved with any other name, for example +``mapfile.txt``, and this information can be passed to F2PY by using the ``--f2cmap`` option. + +.. code-block:: sh + + f2py -c func1.f -m func1 --f2cmap mapfile.txt + +For more information, see F2Py source code ``numpy/f2py/capi_maps.py``. + +.. _Character strings: + +Character strings +================= + +Assumed length character strings +----------------------------------- + +In Fortran, assumed length character string arguments are declared as +``character*(*)`` or ``character(len=*)``, that is, the length of such +arguments are determined by the actual string arguments at runtime. +For ``intent(in)`` arguments, this lack of length information poses no +problems for f2py to construct functional wrapper functions. However, +for ``intent(out)`` arguments, the lack of length information is +problematic for f2py generated wrappers because there is no size +information available for creating memory buffers for such arguments +and F2PY assumes the length is 0. Depending on how the length of +assumed length character strings are specified, there exist ways to +workaround this problem, as exemplified below. + +If the length of the ``character*(*)`` output argument is determined +by the state of other input arguments, the required connection can be +established in a signature file or within a f2py-comment by adding an +extra declaration for the corresponding argument that specifies the +length in character selector part. For example, consider a Fortran +file ``asterisk1.f90``: + +.. include:: ./code/asterisk1.f90 + :literal: + +Compile it with ``f2py -c asterisk1.f90 -m asterisk1`` and then in Python: + +.. include:: ./code/results/asterisk1_session.dat + :literal: + +Notice that the extra declaration ``character(f2py_len=12) s`` is +interpreted only by f2py and in the ``f2py_len=`` specification one +can use C-expressions as a length value. + +In the following example: + +.. include:: ./code/asterisk2.f90 + :literal: + +the length of the output assumed length string depends on an input +argument ``n``, after wrapping with F2PY, in Python: + +.. include:: ./code/results/asterisk2_session.dat + :literal: diff --git a/doc/source/f2py/buildtools/cmake.rst b/doc/source/f2py/buildtools/cmake.rst index 3ed5a2beea14..8c654c73e83e 100644 --- a/doc/source/f2py/buildtools/cmake.rst +++ b/doc/source/f2py/buildtools/cmake.rst @@ -48,9 +48,9 @@ with the ``cython`` information. ls . # CMakeLists.txt fib1.f - mkdir build && cd build - cmake .. - make + cmake -S . -B build + cmake --build build + cd build python -c "import numpy as np; import fibby; a = np.zeros(9); fibby.fib(a); print (a)" # [ 0. 1. 1. 2. 3. 5. 8. 13. 21.] diff --git a/doc/source/f2py/buildtools/index.rst b/doc/source/f2py/buildtools/index.rst index aa41fd37f01a..d3bfd93a5324 100644 --- a/doc/source/f2py/buildtools/index.rst +++ b/doc/source/f2py/buildtools/index.rst @@ -10,7 +10,7 @@ with ``f2py``. .. note:: **As of November 2021** - The default build system for ``F2PY`` has traditionally been the through the + The default build system for ``F2PY`` has traditionally been through the enhanced ``numpy.distutils`` module. This module is based on ``distutils`` which will be removed in ``Python 3.12.0`` in **October 2023**; ``setuptools`` does not have support for Fortran or ``F2PY`` and it is unclear if it will be supported @@ -27,6 +27,7 @@ Building an extension module which includes Python and Fortran consists of: + A ``C`` wrapper file is always created + Code with modules require an additional ``.f90`` wrapper + + Code with functions generate an additional ``.f`` wrapper - ``fortranobject.{c,h}`` @@ -46,7 +47,7 @@ Fortran 77 programs - Generates + ``blahmodule.c`` - + ``f2pywrappers.f`` + + ``blah-f2pywrappers.f`` When no ``COMMON`` blocks are present only a ``C`` wrapper file is generated. Wrappers are also generated to rewrite assumed shape arrays as automatic @@ -57,10 +58,12 @@ Fortran 90 programs - Generates: + ``blahmodule.c`` + + ``blah-f2pywrappers.f`` + ``blah-f2pywrappers2.f90`` - The secondary wrapper is used to handle code which is subdivided into - modules. It rewrites assumed shape arrays as automatic arrays. + The ``f90`` wrapper is used to handle code which is subdivided into + modules. The ``f`` wrapper makes ``subroutines`` for ``functions``. It + rewrites assumed shape arrays as automatic arrays. Signature files - Input file ``blah.pyf`` @@ -68,7 +71,7 @@ Signature files + ``blahmodule.c`` + ``blah-f2pywrappers2.f90`` (occasionally) - + ``f2pywrappers.f`` (occasionally) + + ``blah-f2pywrappers.f`` (occasionally) Signature files ``.pyf`` do not signal their language standard via the file extension, they may generate the F90 and F77 specific wrappers depending on @@ -77,7 +80,10 @@ Signature files .. note:: - The signature file output situation is being reconsidered in `issue 20385`_ . + From NumPy ``1.22.4`` onwards, ``f2py`` will deterministically generate + wrapper files based on the input file Fortran standard (F77 or greater). + ``--skip-empty-wrappers`` can be passed to ``f2py`` to restore the previous + behaviour of only generating wrappers when needed by the input . In theory keeping the above requirements in hand, any build system can be diff --git a/doc/source/f2py/buildtools/meson.rst b/doc/source/f2py/buildtools/meson.rst index d98752e65f80..7edc6722f77d 100644 --- a/doc/source/f2py/buildtools/meson.rst +++ b/doc/source/f2py/buildtools/meson.rst @@ -77,12 +77,19 @@ possible. The easiest way to solve this is to let ``f2py`` deal with it: Automating wrapper generation -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ A major pain point in the workflow defined above, is the manual tracking of inputs. Although it would require more effort to figure out the actual outputs for reasons discussed in :ref:`f2py-bldsys`. +.. note:: + + From NumPy ``1.22.4`` onwards, ``f2py`` will deterministically generate + wrapper files based on the input file Fortran standard (F77 or greater). + ``--skip-empty-wrappers`` can be passed to ``f2py`` to restore the previous + behaviour of only generating wrappers when needed by the input . + However, we can augment our workflow in a straightforward to take into account files for which the outputs are known when the build system is set up. diff --git a/doc/source/f2py/buildtools/skbuild.rst b/doc/source/f2py/buildtools/skbuild.rst index af18ea43bfd0..0db12e7b4496 100644 --- a/doc/source/f2py/buildtools/skbuild.rst +++ b/doc/source/f2py/buildtools/skbuild.rst @@ -29,7 +29,7 @@ We will consider the ``fib`` example from :ref:`f2py-getting-started` section. :language: fortran ``CMake`` modules only -^^^^^^^^^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~~~~~~~~ Consider using the following ``CMakeLists.txt``. @@ -44,15 +44,15 @@ The resulting extension can be built and loaded in the standard workflow. ls . # CMakeLists.txt fib1.f - mkdir build && cd build - cmake .. - make + cmake -S . -B build + cmake --build build + cd build python -c "import numpy as np; import fibby; a = np.zeros(9); fibby.fib(a); print (a)" # [ 0. 1. 1. 2. 3. 5. 8. 13. 21.] ``setuptools`` replacement -^^^^^^^^^^^^^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~~~~~~~~~~~~ .. note:: diff --git a/doc/source/f2py/code/CMakeLists.txt b/doc/source/f2py/code/CMakeLists.txt index 62ff193bbb2d..6f5170ad5348 100644 --- a/doc/source/f2py/code/CMakeLists.txt +++ b/doc/source/f2py/code/CMakeLists.txt @@ -1,12 +1,10 @@ -### setup project ### -cmake_minimum_required(VERSION 3.17.3) # 3.17 > for Python3_SOABI -set(CMAKE_CXX_STANDARD_REQUIRED ON) +cmake_minimum_required(VERSION 3.18) # Needed to avoid requiring embedded Python libs too project(fibby VERSION 1.0 DESCRIPTION "FIB module" LANGUAGES C Fortran - ) +) # Safety net if(PROJECT_SOURCE_DIR STREQUAL PROJECT_BINARY_DIR) @@ -16,65 +14,52 @@ if(PROJECT_SOURCE_DIR STREQUAL PROJECT_BINARY_DIR) ) endif() -# Grab Python -find_package(Python3 3.9 REQUIRED - COMPONENTS Interpreter Development NumPy) +# Grab Python, 3.8 or newer +find_package(Python 3.8 REQUIRED + COMPONENTS Interpreter Development.Module NumPy) # Grab the variables from a local Python installation # F2PY headers execute_process( - COMMAND "${Python3_EXECUTABLE}" + COMMAND "${Python_EXECUTABLE}" -c "import numpy.f2py; print(numpy.f2py.get_include())" OUTPUT_VARIABLE F2PY_INCLUDE_DIR OUTPUT_STRIP_TRAILING_WHITESPACE ) -# Project scope; consider using target_include_directories instead -include_directories( - BEFORE - ${Python3_INCLUDE_DIRS} - ${Python3_NumPy_INCLUDE_DIRS} - ${F2PY_INCLUDE_DIR} - ) - -message(STATUS ${Python3_INCLUDE_DIRS}) -message(STATUS ${F2PY_INCLUDE_DIR}) -message(STATUS ${Python3_NumPy_INCLUDE_DIRS}) +# Print out the discovered paths +include(CMakePrintHelpers) +cmake_print_variables(Python_INCLUDE_DIRS) +cmake_print_variables(F2PY_INCLUDE_DIR) +cmake_print_variables(Python_NumPy_INCLUDE_DIRS) -# Vars +# Common variables set(f2py_module_name "fibby") set(fortran_src_file "${CMAKE_SOURCE_DIR}/fib1.f") set(f2py_module_c "${f2py_module_name}module.c") -set(generated_module_file "${f2py_module_name}${Python3_SOABI}") # Generate sources add_custom_target( genpyf DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/${f2py_module_c}" - ) +) add_custom_command( OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${f2py_module_c}" - COMMAND ${Python3_EXECUTABLE} -m "numpy.f2py" + COMMAND ${Python_EXECUTABLE} -m "numpy.f2py" "${fortran_src_file}" -m "fibby" --lower # Important DEPENDS fib1.f # Fortran source - ) +) # Set up target -add_library(${CMAKE_PROJECT_NAME} SHARED +Python_add_library(${CMAKE_PROJECT_NAME} MODULE WITH_SOABI "${CMAKE_CURRENT_BINARY_DIR}/${f2py_module_c}" # Generated "${F2PY_INCLUDE_DIR}/fortranobject.c" # From NumPy "${fortran_src_file}" # Fortran source(s) - ) +) # Depend on sources +target_link_libraries(${CMAKE_PROJECT_NAME} PRIVATE Python::NumPy) add_dependencies(${CMAKE_PROJECT_NAME} genpyf) - -set_target_properties( - ${CMAKE_PROJECT_NAME} - PROPERTIES - PREFIX "" - OUTPUT_NAME "${CMAKE_PROJECT_NAME}" - LINKER_LANGUAGE C - ) +target_include_directories(${CMAKE_PROJECT_NAME} PRIVATE "${F2PY_INCLUDE_DIR}") diff --git a/doc/source/f2py/code/CMakeLists_skbuild.txt b/doc/source/f2py/code/CMakeLists_skbuild.txt index 97bc5c744d41..f2d6b69c1ba8 100644 --- a/doc/source/f2py/code/CMakeLists_skbuild.txt +++ b/doc/source/f2py/code/CMakeLists_skbuild.txt @@ -1,6 +1,5 @@ ### setup project ### -cmake_minimum_required(VERSION 3.17.3) -set(CMAKE_CXX_STANDARD_REQUIRED ON) +cmake_minimum_required(VERSION 3.9) project(fibby VERSION 1.0 @@ -16,74 +15,81 @@ if(PROJECT_SOURCE_DIR STREQUAL PROJECT_BINARY_DIR) ) endif() -# Grab Python -find_package(Python3 3.9 REQUIRED - COMPONENTS Interpreter Development) - # Ensure scikit-build modules if (NOT SKBUILD) - # Kanged -->https://github.com/Kitware/torch_liberator/blob/master/CMakeLists.txt + find_package(PythonInterp 3.8 REQUIRED) + # Kanged --> https://github.com/Kitware/torch_liberator/blob/master/CMakeLists.txt # If skbuild is not the driver; include its utilities in CMAKE_MODULE_PATH execute_process( - COMMAND "${Python3_EXECUTABLE}" - -c "import os, skbuild; print(os.path.dirname(skbuild.__file__))" - OUTPUT_VARIABLE SKBLD_DIR - OUTPUT_STRIP_TRAILING_WHITESPACE + COMMAND "${PYTHON_EXECUTABLE}" + -c "import os, skbuild; print(os.path.dirname(skbuild.__file__))" + OUTPUT_VARIABLE SKBLD_DIR + OUTPUT_STRIP_TRAILING_WHITESPACE ) - set(SKBLD_CMAKE_DIR "${SKBLD_DIR}/resources/cmake") - list(APPEND CMAKE_MODULE_PATH ${SKBLD_CMAKE_DIR}) + list(APPEND CMAKE_MODULE_PATH "${SKBLD_DIR}/resources/cmake") + message(STATUS "Looking in ${SKBLD_DIR}/resources/cmake for CMake modules") endif() # scikit-build style includes find_package(PythonExtensions REQUIRED) # for ${PYTHON_EXTENSION_MODULE_SUFFIX} -find_package(NumPy REQUIRED) # for ${NumPy_INCLUDE_DIRS} -find_package(F2PY REQUIRED) # for ${F2PY_INCLUDE_DIR} + +# Grab the variables from a local Python installation +# NumPy headers +execute_process( + COMMAND "${PYTHON_EXECUTABLE}" + -c "import numpy; print(numpy.get_include())" + OUTPUT_VARIABLE NumPy_INCLUDE_DIRS + OUTPUT_STRIP_TRAILING_WHITESPACE +) +# F2PY headers +execute_process( + COMMAND "${PYTHON_EXECUTABLE}" + -c "import numpy.f2py; print(numpy.f2py.get_include())" + OUTPUT_VARIABLE F2PY_INCLUDE_DIR + OUTPUT_STRIP_TRAILING_WHITESPACE +) # Prepping the module set(f2py_module_name "fibby") set(fortran_src_file "${CMAKE_SOURCE_DIR}/fib1.f") -set(generated_module_file ${f2py_module_name}${PYTHON_EXTENSION_MODULE_SUFFIX}) +set(f2py_module_c "${f2py_module_name}module.c") # Target for enforcing dependencies -add_custom_target(${f2py_module_name} ALL +add_custom_target(genpyf DEPENDS "${fortran_src_file}" - ) - -# Custom command for generating .c +) add_custom_command( - OUTPUT "${f2py_module_name}module.c" - COMMAND ${F2PY_EXECUTABLE} - -m ${f2py_module_name} - ${fortran_src_file} - --lower - WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} - DEPENDS ${fortran_src_file} - ) + OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${f2py_module_c}" + COMMAND ${PYTHON_EXECUTABLE} -m "numpy.f2py" + "${fortran_src_file}" + -m "fibby" + --lower # Important + DEPENDS fib1.f # Fortran source +) -add_library(${generated_module_file} MODULE +add_library(${CMAKE_PROJECT_NAME} MODULE "${f2py_module_name}module.c" "${F2PY_INCLUDE_DIR}/fortranobject.c" "${fortran_src_file}") -target_include_directories(${generated_module_file} PUBLIC - ${F2PY_INCLUDE_DIRS} +target_include_directories(${CMAKE_PROJECT_NAME} PUBLIC + ${F2PY_INCLUDE_DIR} + ${NumPy_INCLUDE_DIRS} ${PYTHON_INCLUDE_DIRS}) -set_target_properties(${generated_module_file} PROPERTIES SUFFIX "") -set_target_properties(${generated_module_file} PROPERTIES PREFIX "") +set_target_properties(${CMAKE_PROJECT_NAME} PROPERTIES SUFFIX "${PYTHON_EXTENSION_MODULE_SUFFIX}") +set_target_properties(${CMAKE_PROJECT_NAME} PROPERTIES PREFIX "") # Linker fixes if (UNIX) if (APPLE) - set_target_properties(${generated_module_file} PROPERTIES + set_target_properties(${CMAKE_PROJECT_NAME} PROPERTIES LINK_FLAGS '-Wl,-dylib,-undefined,dynamic_lookup') else() - set_target_properties(${generated_module_file} PROPERTIES + set_target_properties(${CMAKE_PROJECT_NAME} PROPERTIES LINK_FLAGS '-Wl,--allow-shlib-undefined') endif() endif() -if (SKBUILD) - install(TARGETS ${generated_module_file} DESTINATION fibby) -else() - install(TARGETS ${generated_module_file} DESTINATION ${CMAKE_SOURCE_DIR}/fibby) -endif() +add_dependencies(${CMAKE_PROJECT_NAME} genpyf) + +install(TARGETS ${CMAKE_PROJECT_NAME} DESTINATION fibby) diff --git a/doc/source/f2py/code/add-edited.pyf b/doc/source/f2py/code/add-edited.pyf new file mode 100644 index 000000000000..4d2047274093 --- /dev/null +++ b/doc/source/f2py/code/add-edited.pyf @@ -0,0 +1,6 @@ +subroutine zadd(a,b,c,n) ! in :add:add.f + double complex dimension(n) :: a + double complex dimension(n) :: b + double complex intent(out),dimension(n) :: c + integer intent(hide),depend(a) :: n=len(a) +end subroutine zadd \ No newline at end of file diff --git a/doc/source/f2py/code/add-improved.f b/doc/source/f2py/code/add-improved.f new file mode 100644 index 000000000000..65f70c9bc46c --- /dev/null +++ b/doc/source/f2py/code/add-improved.f @@ -0,0 +1,16 @@ +C + SUBROUTINE ZADD(A,B,C,N) +C +CF2PY INTENT(OUT) :: C +CF2PY INTENT(HIDE) :: N +CF2PY DOUBLE COMPLEX :: A(N) +CF2PY DOUBLE COMPLEX :: B(N) +CF2PY DOUBLE COMPLEX :: C(N) + DOUBLE COMPLEX A(*) + DOUBLE COMPLEX B(*) + DOUBLE COMPLEX C(*) + INTEGER N + DO 20 J = 1, N + C(J) = A(J) + B(J) + 20 CONTINUE + END \ No newline at end of file diff --git a/doc/source/f2py/code/add-test.f b/doc/source/f2py/code/add-test.f new file mode 100644 index 000000000000..1d52e47bbb7b --- /dev/null +++ b/doc/source/f2py/code/add-test.f @@ -0,0 +1,10 @@ + subroutine addb(k) + real(8), intent(inout) :: k(:) + k=k+1 + endsubroutine + + subroutine addc(w,k) + real(8), intent(in) :: w(:) + real(8), intent(out) :: k(size(w)) + k=w+1 + endsubroutine \ No newline at end of file diff --git a/doc/source/f2py/code/add.f b/doc/source/f2py/code/add.f new file mode 100644 index 000000000000..5e7556b284c7 --- /dev/null +++ b/doc/source/f2py/code/add.f @@ -0,0 +1,11 @@ +C + SUBROUTINE ZADD(A,B,C,N) +C + DOUBLE COMPLEX A(*) + DOUBLE COMPLEX B(*) + DOUBLE COMPLEX C(*) + INTEGER N + DO 20 J = 1, N + C(J) = A(J)+B(J) + 20 CONTINUE + END diff --git a/doc/source/f2py/code/add.pyf b/doc/source/f2py/code/add.pyf new file mode 100644 index 000000000000..d2583e33352a --- /dev/null +++ b/doc/source/f2py/code/add.pyf @@ -0,0 +1,6 @@ +subroutine zadd(a,b,c,n) ! in :add:add.f + double complex dimension(*) :: a + double complex dimension(*) :: b + double complex dimension(*) :: c + integer :: n +end subroutine zadd \ No newline at end of file diff --git a/doc/source/f2py/code/asterisk1.f90 b/doc/source/f2py/code/asterisk1.f90 new file mode 100644 index 000000000000..2631490d05bc --- /dev/null +++ b/doc/source/f2py/code/asterisk1.f90 @@ -0,0 +1,5 @@ +subroutine foo1(s) + character*(*), intent(out) :: s + !f2py character(f2py_len=12) s + s = "123456789A12" +end subroutine foo1 diff --git a/doc/source/f2py/code/asterisk2.f90 b/doc/source/f2py/code/asterisk2.f90 new file mode 100644 index 000000000000..278e02b4a4a9 --- /dev/null +++ b/doc/source/f2py/code/asterisk2.f90 @@ -0,0 +1,6 @@ +subroutine foo2(s, n) + character(len=*), intent(out) :: s + integer, intent(in) :: n + !f2py character(f2py_len=n), depend(n) :: s + s = "123456789A123456789B"(1:n) +end subroutine foo2 diff --git a/doc/source/f2py/code/f2cmap_demo.f b/doc/source/f2py/code/f2cmap_demo.f new file mode 100644 index 000000000000..3f0e12c76833 --- /dev/null +++ b/doc/source/f2py/code/f2cmap_demo.f @@ -0,0 +1,9 @@ + subroutine func1(n, x, res) + use, intrinsic :: iso_fortran_env, only: int64, real64 + implicit none + integer(int64), intent(in) :: n + real(real64), intent(in) :: x(n) + real(real64), intent(out) :: res +Cf2py intent(hide) :: n + res = sum(x) + end diff --git a/doc/source/f2py/code/filter.f b/doc/source/f2py/code/filter.f new file mode 100644 index 000000000000..fb44343fa254 --- /dev/null +++ b/doc/source/f2py/code/filter.f @@ -0,0 +1,19 @@ +C + SUBROUTINE DFILTER2D(A,B,M,N) +C + DOUBLE PRECISION A(M,N) + DOUBLE PRECISION B(M,N) + INTEGER N, M +CF2PY INTENT(OUT) :: B +CF2PY INTENT(HIDE) :: N +CF2PY INTENT(HIDE) :: M + DO 20 I = 2,M-1 + DO 40 J = 2,N-1 + B(I,J) = A(I,J) + + & (A(I-1,J)+A(I+1,J) + + & A(I,J-1)+A(I,J+1) )*0.5D0 + + & (A(I-1,J-1) + A(I-1,J+1) + + & A(I+1,J-1) + A(I+1,J+1))*0.25D0 + 40 CONTINUE + 20 CONTINUE + END diff --git a/doc/source/f2py/code/meson.build b/doc/source/f2py/code/meson.build index b756abf8f59a..04276a176610 100644 --- a/doc/source/f2py/code/meson.build +++ b/doc/source/f2py/code/meson.build @@ -20,19 +20,12 @@ incdir_f2py = run_command(py3, check : true ).stdout().strip() -fibby_source = custom_target('fibbymodule.c', - input : ['fib1.f'], - output : ['fibbymodule.c'], - command : [ py3, '-m', 'numpy.f2py', '@INPUT@', - '-m', 'fibby', '--lower' ] - ) - inc_np = include_directories(incdir_numpy, incdir_f2py) -py3.extension_module('fibby', +py3.extension_module('fib2', 'fib1.f', - fibby_source, + 'fib2module.c', incdir_f2py+'/fortranobject.c', include_directories: inc_np, dependencies : py3_dep, - install : true) + install : true) \ No newline at end of file diff --git a/doc/source/f2py/code/meson_upd.build b/doc/source/f2py/code/meson_upd.build index 97bd8d175c7c..44d69d18222a 100644 --- a/doc/source/f2py/code/meson_upd.build +++ b/doc/source/f2py/code/meson_upd.build @@ -21,10 +21,10 @@ incdir_f2py = run_command(py3, ).stdout().strip() fibby_source = custom_target('fibbymodule.c', - input : ['fib1.f'], - output : ['fibbymodule.c'], + input : ['fib1.f'], # .f so no F90 wrappers + output : ['fibbymodule.c', 'fibby-f2pywrappers.f'], command : [ py3, '-m', 'numpy.f2py', '@INPUT@', - '-m', 'fibby', '--lower' ]) + '-m', 'fibby', '--lower']) inc_np = include_directories(incdir_numpy, incdir_f2py) diff --git a/doc/source/f2py/code/myroutine-edited.pyf b/doc/source/f2py/code/myroutine-edited.pyf new file mode 100644 index 000000000000..14e455416cca --- /dev/null +++ b/doc/source/f2py/code/myroutine-edited.pyf @@ -0,0 +1,17 @@ +! -*- f90 -*- +! Note: the context of this file is case sensitive. + +python module myroutine ! in + interface ! in :myroutine + subroutine s(n,m,c,x) ! in :myroutine:myroutine.f90 + integer intent(in) :: n + integer intent(in) :: m + real(kind=8) dimension(:),intent(in) :: c + real(kind=8) dimension(n,m),intent(out) :: x + end subroutine s + end interface +end python module myroutine + +! This file was auto-generated with f2py (version:1.23.0.dev0+120.g4da01f42d). +! See: +! https://web.archive.org/web/20140822061353/http://cens.ioc.ee/projects/f2py2e \ No newline at end of file diff --git a/doc/source/f2py/code/myroutine.f90 b/doc/source/f2py/code/myroutine.f90 new file mode 100644 index 000000000000..592796a6a380 --- /dev/null +++ b/doc/source/f2py/code/myroutine.f90 @@ -0,0 +1,10 @@ +subroutine s(n, m, c, x) + implicit none + integer, intent(in) :: n, m + real(kind=8), intent(out), dimension(n,m) :: x + real(kind=8), intent(in) :: c(:) + + x = 0.0d0 + x(1, 1) = c(1) + +end subroutine s \ No newline at end of file diff --git a/doc/source/f2py/code/myroutine.pyf b/doc/source/f2py/code/myroutine.pyf new file mode 100644 index 000000000000..ef8f16789665 --- /dev/null +++ b/doc/source/f2py/code/myroutine.pyf @@ -0,0 +1,17 @@ +! -*- f90 -*- +! Note: the context of this file is case sensitive. + +python module myroutine ! in + interface ! in :myroutine + subroutine s(n,m,c,x) ! in :myroutine:myroutine.f90 + integer intent(in) :: n + integer intent(in) :: m + real(kind=8) dimension(:),intent(in) :: c + real(kind=8) dimension(n,m),intent(out),depend(m,n) :: x + end subroutine s + end interface +end python module myroutine + +! This file was auto-generated with f2py (version:1.23.0.dev0+120.g4da01f42d). +! See: +! https://web.archive.org/web/20140822061353/http://cens.ioc.ee/projects/f2py2e \ No newline at end of file diff --git a/doc/source/f2py/code/pyproj_skbuild.toml b/doc/source/f2py/code/pyproj_skbuild.toml index 6686d1736015..bcd6ae99cbfb 100644 --- a/doc/source/f2py/code/pyproj_skbuild.toml +++ b/doc/source/f2py/code/pyproj_skbuild.toml @@ -1,5 +1,3 @@ -[project] -requires-python = ">=3.7" - [build-system] -requires = ["setuptools>=42", "wheel", "scikit-build", "cmake>=3.18", "numpy>=1.21"] +requires = ["setuptools>=42", "wheel", "scikit-build", "cmake>=3.9", "numpy>=1.21"] +build-backend = "setuptools.build_meta" diff --git a/doc/source/f2py/code/results/asterisk1_session.dat b/doc/source/f2py/code/results/asterisk1_session.dat new file mode 100644 index 000000000000..8aa9c5ba0783 --- /dev/null +++ b/doc/source/f2py/code/results/asterisk1_session.dat @@ -0,0 +1,3 @@ +>>> import asterisk1 +>>> asterisk1.foo1() +b'123456789A12' diff --git a/doc/source/f2py/code/results/asterisk2_session.dat b/doc/source/f2py/code/results/asterisk2_session.dat new file mode 100644 index 000000000000..5fb8bef8b052 --- /dev/null +++ b/doc/source/f2py/code/results/asterisk2_session.dat @@ -0,0 +1,6 @@ +>>> import asterisk +>>> asterisk.foo2(2) +b'12' +>>> asterisk.foo2(12) +b'123456789A12' +>>> diff --git a/doc/source/f2py/code/setup_skbuild.py b/doc/source/f2py/code/setup_skbuild.py index 4dfc6af8b76d..28dcdcb1f884 100644 --- a/doc/source/f2py/code/setup_skbuild.py +++ b/doc/source/f2py/code/setup_skbuild.py @@ -6,5 +6,5 @@ description="a minimal example package (fortran version)", license="MIT", packages=['fibby'], - cmake_args=['-DSKBUILD=ON'] + python_requires=">=3.7", ) diff --git a/doc/source/f2py/f2py-examples.rst b/doc/source/f2py/f2py-examples.rst new file mode 100644 index 000000000000..8dcdec075a44 --- /dev/null +++ b/doc/source/f2py/f2py-examples.rst @@ -0,0 +1,245 @@ +.. _f2py-examples: + +F2PY examples +============= + +Below are some examples of F2PY usage. This list is not comprehensive, but can +be used as a starting point when wrapping your own code. + +F2PY walkthrough: a basic extension module +------------------------------------------ + +Creating source for a basic extension module +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Consider the following subroutine, contained in a file named :file:`add.f` + +.. literalinclude:: ./code/add.f + :language: fortran + +This routine simply adds the elements in two contiguous arrays and places the +result in a third. The memory for all three arrays must be provided by the +calling routine. A very basic interface to this routine can be automatically +generated by f2py:: + + python -m numpy.f2py -m add add.f + +This command will produce an extension module named :file:`addmodule.c` in the +current directory. This extension module can now be compiled and used from +Python just like any other extension module. + +Creating a compiled extension module +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +.. note:: + + This usage depends heavily on ``numpy.distutils``, see :ref:`f2py-bldsys` + for more details. + +You can also get f2py to both compile :file:`add.f` along with the produced +extension module leaving only a shared-library extension file that can +be imported from Python:: + + python -m numpy.f2py -c -m add add.f + +This command produces a Python extension module compatible with your platform. +This module may then be imported from Python. It will contain a method for each +subroutine in ``add``. The docstring of each method contains information about +how the module method may be called: + +.. code-block:: python + + >>> import add + >>> print(add.zadd.__doc__) + zadd(a,b,c,n) + + Wrapper for ``zadd``. + + Parameters + ---------- + a : input rank-1 array('D') with bounds (*) + b : input rank-1 array('D') with bounds (*) + c : input rank-1 array('D') with bounds (*) + n : input int + +Improving the basic interface +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +The default interface is a very literal translation of the Fortran code into +Python. The Fortran array arguments are converted to NumPy arrays and the +integer argument should be mapped to a ``C`` integer. The interface will attempt +to convert all arguments to their required types (and shapes) and issue an error +if unsuccessful. However, because ``f2py`` knows nothing about the semantics of +the arguments (such that ``C`` is an output and ``n`` should really match the +array sizes), it is possible to abuse this function in ways that can cause +Python to crash. For example: + +.. code-block:: python + + >>> add.zadd([1, 2, 3], [1, 2], [3, 4], 1000) + +will cause a program crash on most systems. Under the hood, the lists are being +converted to arrays but then the underlying ``add`` function is told to cycle +way beyond the borders of the allocated memory. + +In order to improve the interface, ``f2py`` supports directives. This is +accomplished by constructing a signature file. It is usually best to start from +the interfaces that ``f2py`` produces in that file, which correspond to the +default behavior. To get ``f2py`` to generate the interface file use the ``-h`` +option:: + + python -m numpy.f2py -h add.pyf -m add add.f + +This command creates the ``add.pyf`` file in the current directory. The section +of this file corresponding to ``zadd`` is: + +.. literalinclude:: ./code/add.pyf + :language: fortran + +By placing intent directives and checking code, the interface can be cleaned up +quite a bit so the Python module method is both easier to use and more robust to +malformed inputs. + +.. literalinclude:: ./code/add-edited.pyf + :language: fortran + +The intent directive, intent(out) is used to tell f2py that ``c`` is +an output variable and should be created by the interface before being +passed to the underlying code. The intent(hide) directive tells f2py +to not allow the user to specify the variable, ``n``, but instead to +get it from the size of ``a``. The depend( ``a`` ) directive is +necessary to tell f2py that the value of n depends on the input a (so +that it won't try to create the variable n until the variable a is +created). + +After modifying ``add.pyf``, the new Python module file can be generated +by compiling both ``add.f`` and ``add.pyf``:: + + python -m numpy.f2py -c add.pyf add.f + +The new interface's docstring is: + +.. code-block:: python + + >>> import add + >>> print(add.zadd.__doc__) + c = zadd(a,b) + + Wrapper for ``zadd``. + + Parameters + ---------- + a : input rank-1 array('D') with bounds (n) + b : input rank-1 array('D') with bounds (n) + + Returns + ------- + c : rank-1 array('D') with bounds (n) + +Now, the function can be called in a much more robust way: + +.. code-block:: + + >>> add.zadd([1, 2, 3], [4, 5, 6]) + array([5.+0.j, 7.+0.j, 9.+0.j]) + +Notice the automatic conversion to the correct format that occurred. + +Inserting directives in Fortran source +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +The robust interface of the previous section can also be generated automatically +by placing the variable directives as special comments in the original Fortran +code. + +.. note:: + + For projects where the Fortran code is being actively developed, this may be + preferred. + +Thus, if the source code is modified to contain: + +.. literalinclude:: ./code/add-improved.f + :language: fortran + +Then, one can compile the extension module using:: + + python -m numpy.f2py -c -m add add.f + +The resulting signature for the function add.zadd is exactly the same +one that was created previously. If the original source code had +contained ``A(N)`` instead of ``A(*)`` and so forth with ``B`` and ``C``, +then nearly the same interface can be obtained by placing the +``INTENT(OUT) :: C`` comment line in the source code. The only difference +is that ``N`` would be an optional input that would default to the length +of ``A``. + +A filtering example +------------------- + +This example shows a function that filters a two-dimensional array of double +precision floating-point numbers using a fixed averaging filter. The advantage +of using Fortran to index into multi-dimensional arrays should be clear from +this example. + +.. literalinclude:: ./code/filter.f + :language: fortran + +This code can be compiled and linked into an extension module named +filter using:: + + python -m numpy.f2py -c -m filter filter.f + +This will produce an extension module in the current directory with a method +named ``dfilter2d`` that returns a filtered version of the input. + + +``depends`` keyword example +--------------------------- + +Consider the following code, saved in the file ``myroutine.f90``: + +.. literalinclude:: ./code/myroutine.f90 + :language: fortran + +Wrapping this with ``python -m numpy.f2py -c myroutine.f90 -m myroutine``, we +can do the following in Python:: + + >>> import numpy as np + >>> import myroutine + >>> x = myroutine.s(2, 3, np.array([5, 6, 7])) + >>> x + array([[5., 0., 0.], + [0., 0., 0.]]) + +Now, instead of generating the extension module directly, we will create a +signature file for this subroutine first. This is a common pattern for +multi-step extension module generation. In this case, after running + +.. code-block:: python + + python -m numpy.f2py myroutine.f90 -h myroutine.pyf + +the following signature file is generated: + +.. literalinclude:: ./code/myroutine.pyf + :language: fortran + +Now, if we run ``python -m numpy.f2py -c myroutine.pyf myroutine.f90`` we see an +error; note that the signature file included a ``depend(m,n)`` statement for +``x`` which is not necessary. Indeed, editing the file above to read + +.. literalinclude:: ./code/myroutine-edited.pyf + :language: fortran + +and running ``f2py -c myroutine.pyf myroutine.f90`` yields correct results. + + +Read more +--------- + +* `Wrapping C codes using f2py `_ +* `F2py section on the SciPy Cookbook `_ +* `F2py example: Interactive System for Ice sheet Simulation `_ +* `"Interfacing With Other Languages" section on the SciPy Cookbook. + `_ diff --git a/doc/source/f2py/f2py-reference.rst b/doc/source/f2py/f2py-reference.rst new file mode 100644 index 000000000000..70912bdad3e2 --- /dev/null +++ b/doc/source/f2py/f2py-reference.rst @@ -0,0 +1,13 @@ +.. _f2py-reference: + +F2PY reference manual +===================== + +.. toctree:: + :maxdepth: 2 + + signature-file + python-usage + buildtools/index + advanced + f2py-testing diff --git a/doc/source/f2py/f2py-testing.rst b/doc/source/f2py/f2py-testing.rst new file mode 100644 index 000000000000..88fc26ce132c --- /dev/null +++ b/doc/source/f2py/f2py-testing.rst @@ -0,0 +1,80 @@ +.. _f2py-testing: + +=============== +F2PY test suite +=============== + +F2PY's test suite is present in the directory ``numpy/f2py/tests``. Its aim +is to ensure that Fortran language features are correctly translated to Python. +For example, the user can specify starting and ending indices of arrays in +Fortran. This behaviour is translated to the generated CPython library where +the arrays strictly start from 0 index. + +The directory of the test suite looks like the following:: + + ./tests/ + ├── __init__.py + ├── src + │ ├── abstract_interface + │ ├── array_from_pyobj + │ ├── // ... several test folders + │ └── string + ├── test_abstract_interface.py + ├── test_array_from_pyobj.py + ├── // ... several test files + ├── test_symbolic.py + └── util.py + +Files starting with ``test_`` contain tests for various aspects of f2py from parsing +Fortran files to checking modules' documentation. ``src`` directory contains the +Fortran source files upon which we do the testing. ``util.py`` contains utility +functions for building and importing Fortran modules during test time using a +temporary location. + +Adding a test +============== + +F2PY's current test suite predates ``pytest`` and therefore does not use fixtures. +Instead, the test files contain test classes that inherit from ``F2PyTest`` +class present in ``util.py``. + +.. literalinclude:: ../../../numpy/f2py/tests/util.py + :language: python + :lines: 327-336 + :linenos: + +This class many helper functions for parsing and compiling test source files. Its child +classes can override its ``sources`` data member to provide their own source files. +This superclass will then compile the added source files upon object creation andtheir +functions will be appended to ``self.module`` data member. Thus, the child classes will +be able to access the fortran functions specified in source file by calling +``self.module.[fortran_function_name]``. + +Example +~~~~~~~ + +Consider the following subroutines, contained in a file named :file:`add-test.f` + +.. literalinclude:: ./code/add-test.f + :language: fortran + +The first routine `addb` simply takes an array and increases its elements by 1. +The second subroutine `addc` assigns a new array `k` with elements greater that +the elements of the input array `w` by 1. + +A test can be implemented as follows:: + + class TestAdd(util.F2PyTest): + sources = [util.getpath("add-test.f")] + + def test_module(self): + k = np.array([1, 2, 3], dtype=np.float64) + w = np.array([1, 2, 3], dtype=np.float64) + self.module.subb(k) + assert np.allclose(k, w + 1) + self.module.subc([w, k]) + assert np.allclose(k, w + 1) + +We override the ``sources`` data member to provide the source file. The source files +are compiled and subroutines are attached to module data member when the class object +is created. The ``test_module`` function calls the subroutines and tests their results. \ No newline at end of file diff --git a/doc/source/f2py/f2py-user.rst b/doc/source/f2py/f2py-user.rst new file mode 100644 index 000000000000..70d4aedd0c76 --- /dev/null +++ b/doc/source/f2py/f2py-user.rst @@ -0,0 +1,11 @@ +.. _f2py-user: + +F2PY user guide +=============== + +.. toctree:: + :maxdepth: 2 + + f2py.getting-started + usage + f2py-examples \ No newline at end of file diff --git a/doc/source/f2py/f2py.getting-started.rst b/doc/source/f2py/f2py.getting-started.rst index c1a006f6f2eb..da88b46f550d 100644 --- a/doc/source/f2py/f2py.getting-started.rst +++ b/doc/source/f2py/f2py.getting-started.rst @@ -7,15 +7,14 @@ Wrapping Fortran or C functions to Python using F2PY consists of the following steps: -* Creating the so-called signature file that contains descriptions of - wrappers to Fortran or C functions, also called the signatures of the - functions. For Fortran routines, F2PY can create an initial - signature file by scanning Fortran source codes and - tracking all relevant information needed to create wrapper - functions. +* Creating the so-called :doc:`signature file ` that contains + descriptions of wrappers to Fortran or C functions, also called the signatures + of the functions. For Fortran routines, F2PY can create an initial signature + file by scanning Fortran source codes and tracking all relevant information + needed to create wrapper functions. - * Optionally, F2PY created signature files can be edited to optimize - wrapper functions, to make them "smarter" and more "Pythonic". + * Optionally, F2PY-created signature files can be edited to optimize wrapper + functions, which can make them "smarter" and more "Pythonic". * F2PY reads a signature file and writes a Python C/API module containing Fortran/C/Python bindings. @@ -24,7 +23,8 @@ following steps: * In building the extension modules, F2PY uses ``numpy_distutils`` which supports a number of Fortran 77/90/95 compilers, including Gnu, Intel, Sun - Fortran, SGI MIPSpro, Absoft, NAG, Compaq etc. + Fortran, SGI MIPSpro, Absoft, NAG, Compaq etc. For different build systems, + see :ref:`f2py-bldsys`. Depending on the situation, these steps can be carried out in a single composite command or step-by-step; in which case some steps can be omitted or combined @@ -40,6 +40,13 @@ illustration, save it as ``fib1.f``: .. literalinclude:: ./code/fib1.f :language: fortran +.. note:: + + F2PY parses Fortran/C signatures to build wrapper functions to be used with + Python. However, it is not a compiler, and does not check for additional + errors in source code, nor does it implement the entire language standards. + Some errors may pass silently (or as warnings) and need to be verified by the + user. The quick way ============== @@ -51,6 +58,18 @@ run python -m numpy.f2py -c fib1.f -m fib1 +or, alternatively, if the ``f2py`` command-line tool is available, + +:: + + f2py -c fib1.f -m fib1 + +.. note:: + + Because the ``f2py`` command might not be available in all system, notably on + Windows, we will use the ``python -m numpy.f2py`` command throughout this + guide. + This command compiles and wraps ``fib1.f`` (``-c``) to create the extension module ``fib1.so`` (``-m``) in the current directory. A list of command line options can be seen by executing ``python -m numpy.f2py``. Now, in Python the @@ -103,15 +122,15 @@ Fortran subroutine ``FIB`` is accessible via ``fib1.fib``:: F2PY implements basic compatibility checks between related arguments in order to avoid unexpected crashes. - * When a NumPy array, that is Fortran contiguous and has a ``dtype`` - corresponding to a presumed Fortran type, is used as an input array - argument, then its C pointer is directly passed to Fortran. + * When a NumPy array that is :term:`Fortran ` + :term:`contiguous` and has a ``dtype`` corresponding to a presumed Fortran + type is used as an input array argument, then its C pointer is directly + passed to Fortran. - Otherwise F2PY makes a contiguous copy (with the proper ``dtype``) of - the input array and passes a C pointer of the copy to the Fortran - subroutine. As a result, any possible changes to the (copy of) - input array have no effect to the original argument, as - demonstrated below:: + Otherwise, F2PY makes a contiguous copy (with the proper ``dtype``) of the + input array and passes a C pointer of the copy to the Fortran subroutine. As + a result, any possible changes to the (copy of) input array have no effect + on the original argument, as demonstrated below:: >>> a = np.ones(8, 'i') >>> fib1.fib(a) @@ -121,11 +140,11 @@ Fortran subroutine ``FIB`` is accessible via ``fib1.fib``:: Clearly, this is unexpected, as Fortran typically passes by reference. That the above example worked with ``dtype=float`` is considered accidental. - F2PY provides an ``intent(inplace)`` attribute that modifies - the attributes of an input array so that any changes made by - Fortran routine will be reflected in the input argument. For example, - if one specifies the ``intent(inplace) a`` directive (see subsequent - sections on how), then the example above would read:: + F2PY provides an ``intent(inplace)`` attribute that modifies the attributes + of an input array so that any changes made by the Fortran routine will be + reflected in the input argument. For example, if one specifies the + ``intent(inplace) a`` directive (see :ref:`f2py-attributes` for details), + then the example above would read:: >>> a = np.ones(8, 'i') >>> fib1.fib(a) @@ -133,8 +152,8 @@ Fortran subroutine ``FIB`` is accessible via ``fib1.fib``:: [ 0. 1. 1. 2. 3. 5. 8. 13.] However, the recommended way to have changes made by Fortran subroutine - propagate to Python is to use the ``intent(out)`` attribute. That approach is - more efficient and also cleaner. + propagate to Python is to use the ``intent(out)`` attribute. That approach + is more efficient and also cleaner. * The usage of ``fib1.fib`` in Python is very similar to using ``FIB`` in Fortran. However, using *in situ* output arguments in Python is poor style, @@ -145,23 +164,23 @@ Fortran subroutine ``FIB`` is accessible via ``fib1.fib``:: may lead to difficult to find bugs, not to mention the fact that the codes will be less readable when all required type checks are implemented. - Though the approach to wrapping Fortran routines for Python discussed so far is - very straightforward, it has several drawbacks (see the comments above). + Though the approach to wrapping Fortran routines for Python discussed so far + is very straightforward, it has several drawbacks (see the comments above). The drawbacks are due to the fact that there is no way for F2PY to determine - the actual intention of the arguments; that is there is ambiguity in + the actual intention of the arguments; that is, there is ambiguity in distinguishing between input and output arguments. Consequently, F2PY assumes that all arguments are input arguments by default. - However, there are ways (see below) to remove this ambiguity by "teaching" - F2PY about the true intentions of function arguments, and F2PY is then able to - generate more explicit, easier to use, and less error prone wrappers for - Fortran functions. + There are ways (see below) to remove this ambiguity by "teaching" F2PY about + the true intentions of function arguments, and F2PY is then able to generate + more explicit, easier to use, and less error prone wrappers for Fortran + functions. The smart way ============== -Let us apply the steps for wrapping Fortran functions to Python one by -one. +If we want to have more control over how F2PY will treat the interface to our +Fortran code, we can apply the wrapping steps one by one. * First, we create a signature file from ``fib1.f`` by running: @@ -169,21 +188,21 @@ one. python -m numpy.f2py fib1.f -m fib2 -h fib1.pyf - The signature file is saved to ``fib1.pyf`` (see the ``-h`` flag) and - its contents are shown below. + The signature file is saved to ``fib1.pyf`` (see the ``-h`` flag) and its + contents are shown below. .. literalinclude:: ./code/fib1.pyf :language: fortran * Next, we'll teach F2PY that the argument ``n`` is an input argument (using the ``intent(in)`` attribute) and that the result, i.e., the contents of ``a`` - after calling the Fortran function ``FIB``, should be returned to Python (using - the ``intent(out)`` attribute). In addition, an array ``a`` should be created - dynamically using the size determined by the input argument ``n`` (using the - ``depend(n)`` attribute to indicate this dependence relation). + after calling the Fortran function ``FIB``, should be returned to Python + (using the ``intent(out)`` attribute). In addition, an array ``a`` should be + created dynamically using the size determined by the input argument ``n`` + (using the ``depend(n)`` attribute to indicate this dependence relation). The contents of a suitably modified version of ``fib1.pyf`` (saved as - ``fib2.pyf``) is as follows: + ``fib2.pyf``) are as follows: .. literalinclude:: ./code/fib2.pyf :language: fortran @@ -215,15 +234,18 @@ In Python:: .. note:: - * The signature of ``fib2.fib`` now more closely corresponds to the - intention of Fortran subroutine ``FIB``: given the number ``n``, - ``fib2.fib`` returns the first ``n`` Fibonacci numbers as a NumPy array. - The new Python signature ``fib2.fib`` also rules out the unexpected behaviour in ``fib1.fib``. + * The signature of ``fib2.fib`` now more closely corresponds to the intention + of the Fortran subroutine ``FIB``: given the number ``n``, ``fib2.fib`` + returns the first ``n`` Fibonacci numbers as a NumPy array. The new Python + signature ``fib2.fib`` also rules out the unexpected behaviour in + ``fib1.fib``. * Note that by default, using a single ``intent(out)`` also implies ``intent(hide)``. Arguments that have the ``intent(hide)`` attribute specified will not be listed in the argument list of a wrapper function. + For more details, see :doc:`signature-file`. + The quick and smart way ======================== diff --git a/doc/source/f2py/index.rst b/doc/source/f2py/index.rst index 56df31b4e752..dedfe3f644dd 100644 --- a/doc/source/f2py/index.rst +++ b/doc/source/f2py/index.rst @@ -5,10 +5,10 @@ F2PY user guide and reference manual ===================================== The purpose of the ``F2PY`` --*Fortran to Python interface generator*-- utility -is to provide a connection between Python and Fortran -languages. F2PY is a part of NumPy_ (``numpy.f2py``) and also available as a -standalone command line tool ``f2py`` when ``numpy`` is installed that -facilitates creating/building Python C/API extension modules that make it +is to provide a connection between Python and Fortran. F2PY is a part of NumPy_ +(``numpy.f2py``) and also available as a standalone command line tool. + +F2PY facilitates creating/building Python C/API extension modules that make it possible * to call Fortran 77/90/95 external subroutines and Fortran 90/95 @@ -18,15 +18,31 @@ possible from Python. +F2PY can be used either as a command line tool ``f2py`` or as a Python +module ``numpy.f2py``. While we try to provide the command line tool as part +of the numpy setup, some platforms like Windows make it difficult to +reliably put the executables on the ``PATH``. If the ``f2py`` command is not +available in your system, you may have to run it as a module:: + + python -m numpy.f2py + +If you run ``f2py`` with no arguments, and the line ``numpy Version`` at the +end matches the NumPy version printed from ``python -m numpy.f2py``, then you +can use the shorter version. If not, or if you cannot run ``f2py``, you should +replace all calls to ``f2py`` mentioned in this guide with the longer version. + .. toctree:: - :maxdepth: 2 + :maxdepth: 3 - usage f2py.getting-started + f2py-user + f2py-reference + usage python-usage signature-file buildtools/index advanced + windows/index .. _Python: https://www.python.org/ .. _NumPy: https://www.numpy.org/ diff --git a/doc/source/f2py/python-usage.rst b/doc/source/f2py/python-usage.rst index ef8ccd7dd657..db1ee1ec8c3b 100644 --- a/doc/source/f2py/python-usage.rst +++ b/doc/source/f2py/python-usage.rst @@ -2,41 +2,49 @@ Using F2PY bindings in Python ================================== -All wrappers for Fortran/C routines, common blocks, or for Fortran -90 module data generated by F2PY are exposed to Python as ``fortran`` -type objects. Routine wrappers are callable ``fortran`` type objects -while wrappers to Fortran data have attributes referring to data -objects. +In this page, you can find a full description and a few examples of common usage +patterns for F2PY with Python and different argument types. For more examples +and use cases, see :ref:`f2py-examples`. + +Fortran type objects +==================== + +All wrappers for Fortran/C routines, common blocks, or for Fortran 90 module +data generated by F2PY are exposed to Python as ``fortran`` type objects. +Routine wrappers are callable ``fortran`` type objects while wrappers to Fortran +data have attributes referring to data objects. All ``fortran`` type objects have an attribute ``_cpointer`` that contains a -``CObject`` referring to the C pointer of the corresponding Fortran/C function -or variable at the C level. Such ``CObjects`` can be used as a callback argument -for F2PY generated functions to bypass the Python C/API layer for calling Python -functions from Fortran or C when the computational aspects of such functions are -implemented in C or Fortran and wrapped with F2PY (or any other tool capable of -providing the ``CObject`` of a function). +:c:type:`PyCapsule` referring to the C pointer of the corresponding Fortran/C function +or variable at the C level. Such ``PyCapsule`` objects can be used as callback +arguments for F2PY generated functions to bypass the Python C/API layer for +calling Python functions from Fortran or C. This can be useful when the +computational aspects of such functions are implemented in C or Fortran and +wrapped with F2PY (or any other tool capable of providing the ``PyCapsule`` +containing a function). Consider a Fortran 77 file ```ftype.f``: - .. literalinclude:: ./code/ftype.f - :language: fortran +.. literalinclude:: ./code/ftype.f + :language: fortran and a wrapper built using ``f2py -c ftype.f -m ftype``. -In Python: +In Python, you can observe the types of ``foo`` and ``data``, and how to access +individual objects of the wrapped Fortran code. - .. literalinclude:: ./code/results/ftype_session.dat - :language: python +.. literalinclude:: ./code/results/ftype_session.dat + :language: python Scalar arguments ================= -In general, a scalar argument for a F2PY generated wrapper function can -be an ordinary Python scalar (integer, float, complex number) as well as -an arbitrary sequence object (list, tuple, array, string) of -scalars. In the latter case, the first element of the sequence object -is passed to Fortran routine as a scalar argument. +In general, a scalar argument for a F2PY generated wrapper function can be an +ordinary Python scalar (integer, float, complex number) as well as an arbitrary +sequence object (list, tuple, array, string) of scalars. In the latter case, the +first element of the sequence object is passed to the Fortran routine as a +scalar argument. .. note:: @@ -44,52 +52,57 @@ is passed to Fortran routine as a scalar argument. narrowing e.g. when type-casting float to integer or complex to float, F2PY *does not* raise an exception. - * For complex to real type-casting only the real part of a complex number is used. + * For complex to real type-casting only the real part of a complex number + is used. * ``intent(inout)`` scalar arguments are assumed to be array objects in order to have *in situ* changes be effective. It is recommended to use - arrays with proper type but also other types work. + arrays with proper type but also other types work. :ref:`Read more about + the intent attribute `. Consider the following Fortran 77 code: - .. literalinclude:: ./code/scalar.f - :language: fortran +.. literalinclude:: ./code/scalar.f + :language: fortran and wrap it using ``f2py -c -m scalar scalar.f``. In Python: - .. literalinclude:: ./code/results/scalar_session.dat - :language: python +.. literalinclude:: ./code/results/scalar_session.dat + :language: python String arguments ================= -F2PY generated wrapper functions accept almost any Python object as -a string argument, since ``str`` is applied for non-string objects. -Exceptions are NumPy arrays that must have type code ``'c'`` or -``'1'`` when used as string arguments. +F2PY generated wrapper functions accept almost any Python object as a string +argument, since ``str`` is applied for non-string objects. Exceptions are NumPy +arrays that must have type code ``'S1'`` or ``'b'`` (corresponding to the +outdated ``'c'`` or ``'1'`` typecodes, respectively) when used as string +arguments. See :ref:`arrays.scalars` for more information on these typecodes. -A string can have an arbitrary length when used as a string argument -for an F2PY generated wrapper function. If the length is greater than -expected, the string is truncated silently. If the length is smaller than -expected, additional memory is allocated and filled with ``\0``. +A string can have an arbitrary length when used as a string argument for an F2PY +generated wrapper function. If the length is greater than expected, the string +is truncated silently. If the length is smaller than expected, additional memory +is allocated and filled with ``\0``. -Because Python strings are immutable, an ``intent(inout)`` argument -expects an array version of a string in order to have *in situ* changes be effective. +.. TODO: review this section once https://github.com/numpy/numpy/pull/19388 is merged. + +Because Python strings are immutable, an ``intent(inout)`` argument expects an +array version of a string in order to have *in situ* changes be effective. Consider the following Fortran 77 code: - .. literalinclude:: ./code/string.f - :language: fortran +.. literalinclude:: ./code/string.f + :language: fortran and wrap it using ``f2py -c -m mystring string.f``. Python session: - .. literalinclude:: ./code/results/string_session.dat - :language: python +.. literalinclude:: ./code/results/string_session.dat + :language: python Array arguments @@ -99,40 +112,17 @@ In general, array arguments for F2PY generated wrapper functions accept arbitrary sequences that can be transformed to NumPy array objects. There are two notable exceptions: -* ``intent(inout)`` array arguments must always be proper-contiguous (defined below) and have a - compatible ``dtype``, otherwise an exception is raised. +* ``intent(inout)`` array arguments must always be + :term:`proper-contiguous ` and have a compatible ``dtype``, + otherwise an exception is raised. * ``intent(inplace)`` array arguments will be changed *in situ* if the argument - has a different type than expected (see the ``intent(inplace)`` attribute for - more information). - -In general, if a NumPy array is proper-contiguous and has a proper type then it -is directly passed to the wrapped Fortran/C function. Otherwise, an element-wise -copy of the input array is made and the copy, being proper-contiguous and with -proper type, is used as the array argument. - -There are two types of proper-contiguous NumPy arrays: - -* Fortran-contiguous arrays refer to data that is stored columnwise, - i.e. the indexing of data as stored in memory starts from the lowest - dimension; -* C-contiguous, or simply contiguous arrays, refer to data that is stored - rowwise, i.e. the indexing of data as stored in memory starts from the highest - dimension. - -For one-dimensional arrays these notions coincide. - -For example, a 2x2 array ``A`` is Fortran-contiguous if its elements -are stored in memory in the following order:: - - A[0,0] A[1,0] A[0,1] A[1,1] - -and C-contiguous if the order is as follows:: - - A[0,0] A[0,1] A[1,0] A[1,1] + has a different type than expected (see the ``intent(inplace)`` + :ref:`attribute ` for more information). -To test whether an array is C-contiguous, use the ``.flags.c_contiguous`` -attribute of NumPy arrays. To test for Fortran contiguity, use the -``.flags.f_contiguous`` attribute. +In general, if a NumPy array is :term:`proper-contiguous ` and has +a proper type then it is directly passed to the wrapped Fortran/C function. +Otherwise, an element-wise copy of the input array is made and the copy, being +proper-contiguous and with proper type, is used as the array argument. Usually there is no need to worry about how the arrays are stored in memory and whether the wrapped functions, being either Fortran or C functions, assume one @@ -144,19 +134,19 @@ physical memory in your computer, then care must be taken to ensure the usage of proper-contiguous and proper type arguments. To transform input arrays to column major storage order before passing -them to Fortran routines, use the function ``numpy.asfortranarray()``. +them to Fortran routines, use the function `numpy.asfortranarray`. Consider the following Fortran 77 code: - .. literalinclude:: ./code/array.f - :language: fortran +.. literalinclude:: ./code/array.f + :language: fortran and wrap it using ``f2py -c -m arr array.f -DF2PY_REPORT_ON_ARRAY_COPY=1``. In Python: - .. literalinclude:: ./code/results/array_session.dat - :language: python +.. literalinclude:: ./code/results/array_session.dat + :language: python .. _Call-back arguments: @@ -167,15 +157,15 @@ F2PY supports calling Python functions from Fortran or C codes. Consider the following Fortran 77 code: - .. literalinclude:: ./code/callback.f - :language: fortran +.. literalinclude:: ./code/callback.f + :language: fortran and wrap it using ``f2py -c -m callback callback.f``. In Python: - .. literalinclude:: ./code/results/callback_session.dat - :language: python +.. literalinclude:: ./code/results/callback_session.dat + :language: python In the above example F2PY was able to guess accurately the signature of the call-back function. However, sometimes F2PY cannot establish the @@ -183,13 +173,13 @@ appropriate signature; in these cases the signature of the call-back function must be explicitly defined in the signature file. To facilitate this, signature files may contain special modules (the names of -these modules contain the special ``__user__`` sub-string) that defines the +these modules contain the special ``__user__`` sub-string) that define the various signatures for call-back functions. Callback arguments in routine signatures have the ``external`` attribute (see also the ``intent(callback)`` -attribute). To relate a callback argument with its signature in a ``__user__`` -module block, a ``use`` statement can be utilized as illustrated below. The same -signature for a callback argument can be referred to in different routine -signatures. +:ref:`attribute `). To relate a callback argument with its +signature in a ``__user__`` module block, a ``use`` statement can be utilized as +illustrated below. The same signature for a callback argument can be referred to +in different routine signatures. We use the same Fortran 77 code as in the previous example but now we will pretend that F2PY was not able to guess the signatures of @@ -200,69 +190,67 @@ file ``callback2.pyf`` using F2PY:: Then modify it as follows - .. include:: ./code/callback2.pyf - :literal: +.. include:: ./code/callback2.pyf + :literal: -Finally, we build the extension module using ``f2py -c callback2.pyf callback.f``. +Finally, we build the extension module using +``f2py -c callback2.pyf callback.f``. An example Python session for this snippet would be identical to the previous example except that the argument names would differ. -Sometimes a Fortran package may require that users provide routines -that the package will use. F2PY can construct an interface to such -routines so that Python functions can be called from Fortran. +Sometimes a Fortran package may require that users provide routines that the +package will use. F2PY can construct an interface to such routines so that +Python functions can be called from Fortran. Consider the following Fortran 77 subroutine that takes an array as its input and applies a function ``func`` to its elements. - .. literalinclude:: ./code/calculate.f - :language: fortran +.. literalinclude:: ./code/calculate.f + :language: fortran The Fortran code expects that the function ``func`` has been defined externally. In order to use a Python function for ``func``, it must have an attribute -``intent(callback)`` and, it must be specified before the ``external`` statement. +``intent(callback)`` and it must be specified before the ``external`` statement. Finally, build an extension module using ``f2py -c -m foo calculate.f`` In Python: - .. literalinclude:: ./code/results/calculate_session.dat - :language: python +.. literalinclude:: ./code/results/calculate_session.dat + :language: python The function is included as an argument to the python function call to the Fortran subroutine even though it was *not* in the Fortran subroutine argument list. The "external" keyword refers to the C function generated by f2py, not the -python function itself. The python function is essentially being supplied to the +Python function itself. The python function is essentially being supplied to the C function. -The callback function may also be explicitly set in the module. -Then it is not necessary to pass the function in the argument list to -the Fortran function. This may be desired if the Fortran function calling -the python callback function is itself called by another Fortran function. +The callback function may also be explicitly set in the module. Then it is not +necessary to pass the function in the argument list to the Fortran function. +This may be desired if the Fortran function calling the Python callback function +is itself called by another Fortran function. Consider the following Fortran 77 subroutine: - .. literalinclude:: ./code/extcallback.f - :language: fortran +.. literalinclude:: ./code/extcallback.f + :language: fortran and wrap it using ``f2py -c -m pfromf extcallback.f``. In Python: - .. literalinclude:: ./code/results/extcallback_session.dat - :language: python +.. literalinclude:: ./code/results/extcallback_session.dat + :language: python Resolving arguments to call-back functions -=========================================== +------------------------------------------ -F2PY generated interfaces are very flexible with respect to call-back -arguments. For each call-back argument an additional optional -argument ``_extra_args`` is introduced by F2PY. This argument -can be used to pass extra arguments to user provided call-back -functions. +F2PY generated interfaces are very flexible with respect to call-back arguments. For each call-back argument an additional optional +argument ``_extra_args`` is introduced by F2PY. This argument can be used +to pass extra arguments to user provided call-back functions. -If a F2PY generated wrapper function expects the following call-back -argument:: +If a F2PY generated wrapper function expects the following call-back argument:: def fun(a_1,...,a_n): ... @@ -282,20 +270,20 @@ is provided by a user, and in addition, fun_extra_args = (e_1,...,e_p) -is used, then the following rules are applied when a Fortran or C -function evaluates the call-back argument ``gun``: +is used, then the following rules are applied when a Fortran or C function +evaluates the call-back argument ``gun``: * If ``p == 0`` then ``gun(a_1, ..., a_q)`` is called, here ``q = min(m, n)``. * If ``n + p <= m`` then ``gun(a_1, ..., a_n, e_1, ..., e_p)`` is called. -* If ``p <= m < n + p`` then ``gun(a_1, ..., a_q, e_1, ..., e_p)`` is called, here - ``q=m-p``. +* If ``p <= m < n + p`` then ``gun(a_1, ..., a_q, e_1, ..., e_p)`` is called, + and here ``q=m-p``. * If ``p > m`` then ``gun(e_1, ..., e_m)`` is called. -* If ``n + p`` is less than the number of required arguments to ``gun`` - then an exception is raised. +* If ``n + p`` is less than the number of required arguments to ``gun`` then an + exception is raised. -If the function ``gun`` may return any number of objects as a tuple; then -the following rules are applied: +If the function ``gun`` may return any number of objects as a tuple; then the +following rules are applied: * If ``k < l``, then ``y_{k + 1}, ..., y_l`` are ignored. * If ``k > l``, then only ``x_1, ..., x_l`` are set. @@ -304,48 +292,47 @@ the following rules are applied: Common blocks ============== -F2PY generates wrappers to ``common`` blocks defined in a routine -signature block. Common blocks are visible to all Fortran codes linked -to the current extension module, but not to other extension modules -(this restriction is due to the way Python imports shared libraries). In -Python, the F2PY wrappers to ``common`` blocks are ``fortran`` type -objects that have (dynamic) attributes related to the data members of -the common blocks. When accessed, these attributes return as NumPy array -objects (multidimensional arrays are Fortran-contiguous) which -directly link to data members in common blocks. Data members can be -changed by direct assignment or by in-place changes to the +F2PY generates wrappers to ``common`` blocks defined in a routine signature +block. Common blocks are visible to all Fortran codes linked to the current +extension module, but not to other extension modules (this restriction is due to +the way Python imports shared libraries). In Python, the F2PY wrappers to +``common`` blocks are ``fortran`` type objects that have (dynamic) attributes +related to the data members of the common blocks. When accessed, these +attributes return as NumPy array objects (multidimensional arrays are +Fortran-contiguous) which directly link to data members in common blocks. Data +members can be changed by direct assignment or by in-place changes to the corresponding array objects. Consider the following Fortran 77 code: - .. literalinclude:: ./code/common.f - :language: fortran +.. literalinclude:: ./code/common.f + :language: fortran and wrap it using ``f2py -c -m common common.f``. In Python: - .. literalinclude:: ./code/results/common_session.dat - :language: python +.. literalinclude:: ./code/results/common_session.dat + :language: python Fortran 90 module data ======================= -The F2PY interface to Fortran 90 module data is similar to the handling of Fortran 77 -common blocks. +The F2PY interface to Fortran 90 module data is similar to the handling of +Fortran 77 common blocks. Consider the following Fortran 90 code: - .. literalinclude:: ./code/moddata.f90 - :language: fortran +.. literalinclude:: ./code/moddata.f90 + :language: fortran and wrap it using ``f2py -c -m moddata moddata.f90``. In Python: - .. literalinclude:: ./code/results/moddata_session.dat - :language: python +.. literalinclude:: ./code/results/moddata_session.dat + :language: python Allocatable arrays @@ -355,12 +342,12 @@ F2PY has basic support for Fortran 90 module allocatable arrays. Consider the following Fortran 90 code: - .. literalinclude:: ./code/allocarr.f90 - :language: fortran +.. literalinclude:: ./code/allocarr.f90 + :language: fortran and wrap it using ``f2py -c -m allocarr allocarr.f90``. In Python: - .. literalinclude:: ./code/results/allocarr_session.dat - :language: python +.. literalinclude:: ./code/results/allocarr_session.dat + :language: python diff --git a/doc/source/f2py/signature-file.rst b/doc/source/f2py/signature-file.rst index b80b31509661..bf358528f558 100644 --- a/doc/source/f2py/signature-file.rst +++ b/doc/source/f2py/signature-file.rst @@ -2,28 +2,39 @@ Signature file ================== -The syntax specification for signature files (.pyf files) is modeled on the -Fortran 90/95 language specification. Almost all Fortran 90/95 standard -constructs are understood, both in free and fixed format (recall that Fortran 77 -is a subset of Fortran 90/95). F2PY introduces some extensions to the Fortran -90/95 language specification that help in the design of the Fortran to Python -interface, making it more "Pythonic". +The interface definition file (.pyf) is how you can fine-tune the interface +between Python and Fortran. The syntax specification for signature files +(``.pyf`` files) is modeled on the Fortran 90/95 language specification. Almost +all Fortran 90/95 standard constructs are understood, both in free and fixed +format (recall that Fortran 77 is a subset of Fortran 90/95). F2PY introduces +some extensions to the Fortran 90/95 language specification that help in the +design of the Fortran to Python interface, making it more "Pythonic". Signature files may contain arbitrary Fortran code so that any Fortran 90/95 -codes can be treated as signature files. F2PY silently ignores -Fortran constructs that are irrelevant for creating the interface. -However, this also means that syntax errors are not caught by F2PY and will only -be caught when the library is built. +codes can be treated as signature files. F2PY silently ignores Fortran +constructs that are irrelevant for creating the interface. However, this also +means that syntax errors are not caught by F2PY and will only be caught when the +library is built. + +.. note:: + + Currently, F2PY may fail with valid Fortran constructs, such as intrinsic + modules. If this happens, you can check the + `NumPy GitHub issue tracker `_ for + possible workarounds or work-in-progress ideas. In general, the contents of the signature files are case-sensitive. When -scanning Fortran codes to generate a signature file, F2PY lowers all -cases automatically except in multi-line blocks or when the ``--no-lower`` -option is used. +scanning Fortran codes to generate a signature file, F2PY lowers all cases +automatically except in multi-line blocks or when the ``--no-lower`` option is +used. The syntax of signature files is presented below. +Signature files syntax +====================== + Python module block -===================== +------------------- A signature file may contain one (recommended) or more ``python module`` blocks. The ``python module`` block describes the contents of @@ -63,7 +74,7 @@ previous section. Fortran/C routine signatures -============================= +---------------------------- The signature of a Fortran routine has the following structure:: @@ -93,8 +104,10 @@ The signature of a Fortran block data has the following structure:: [] end [ block data [] ] +.. _type-declarations: + Type declarations -================= +----------------- The definition of the ```` part is @@ -128,27 +141,27 @@ and * ```` is a comma separated list of dimension bounds; -* ```` is a `C expression`__; +* ```` is a :ref:`C expression `; * ```` may be negative integer for ``integer`` type specifications. In such cases ``integer*`` represents unsigned C integers; -__ `C expressions`_ - If an argument has no ````, its type is determined by applying ``implicit`` rules to its name. Statements -========== +---------- Attribute statements ^^^^^^^^^^^^^^^^^^^^^ -* The ```` is - ```` without ````. -* In addition, in an attribute statement one cannot use other - attributes, also ```` can be only a list of names. +The ```` is similar to the +````, but without ````. + +An attribute statement cannot contain other attributes, and ```` can +be only a list of names. See :ref:`f2py-attributes` for more details on the +attributes that can be used by F2PY. Use statements ^^^^^^^^^^^^^^^ @@ -165,9 +178,8 @@ Use statements := => [ , ] -* Currently F2PY uses ``use`` statement only for linking call-back - modules and ``external`` arguments (call-back functions), see - :ref:`Call-back arguments`. +* Currently F2PY uses ``use`` statements only for linking call-back modules and + ``external`` arguments (call-back functions). See :ref:`Call-back arguments`. Common block statements ^^^^^^^^^^^^^^^^^^^^^^^ @@ -199,9 +211,7 @@ Other statements except the following: + ``call`` statements and function calls of ``external`` arguments - (`more details`__?); - - __ external_ + (see :ref:`more details on external arguments `); + ``include`` statements :: @@ -256,7 +266,7 @@ Other statements F2PY statements ^^^^^^^^^^^^^^^^ - In addition, F2PY introduces the following statements: +In addition, F2PY introduces the following statements: ``threadsafe`` Uses a ``Py_BEGIN_ALLOW_THREADS .. Py_END_ALLOW_THREADS`` block @@ -271,10 +281,9 @@ F2PY statements block>``. ``callprotoargument `` - When the ``callstatement`` statement is used then F2PY may not - generate proper prototypes for Fortran/C functions (because - ```` may contain any function calls and F2PY has no way - to determine what should be the proper prototype). + When the ``callstatement`` statement is used, F2PY may not generate proper + prototypes for Fortran/C functions (because ```` may contain function + calls, and F2PY has no way to determine what should be the proper prototype). With this statement you can explicitly specify the arguments of the corresponding prototype:: @@ -321,61 +330,64 @@ F2PY statements __ https://docs.python.org/extending/index.html +.. _f2py-attributes: + Attributes -============ +---------- -The following attributes are used by F2PY: +The following attributes can be used by F2PY. ``optional`` - The corresponding argument is moved to the end of ```` list. A default value for an optional argument can be - specified via ````, see the ``entitydecl`` definition. - + The corresponding argument is moved to the end of ```` + list. A default value for an optional argument can be specified via + ```` (see the ``entitydecl`` :ref:`definition `) .. note:: * The default value must be given as a valid C expression. - * Whenever ```` is used, ``optional`` attribute - is set automatically by F2PY. + * Whenever ```` is used, the ``optional`` attribute is set + automatically by F2PY. * For an optional array argument, all its dimensions must be bounded. ``required`` - The corresponding argument with this attribute considered mandatory. This is - the default. ``required`` should only be specified if there is a need to + The corresponding argument with this attribute is considered mandatory. This + is the default. ``required`` should only be specified if there is a need to disable the automatic ``optional`` setting when ```` is used. - If a Python ``None`` object is used as a required argument, the - argument is treated as optional. That is, in the case of array - argument, the memory is allocated. If ```` is given, then the - corresponding initialization is carried out. + If a Python ``None`` object is used as a required argument, the argument is + treated as optional. That is, in the case of array arguments, the memory is + allocated. If ```` is given, then the corresponding initialization + is carried out. ``dimension()`` The corresponding variable is considered as an array with dimensions given in ````. ``intent()`` - This specifies the "intention" of the corresponding - argument. ```` is a comma separated list of the - following keys: + This specifies the "intention" of the corresponding argument. ```` + is a comma separated list of the following keys: * ``in`` - The corresponding argument is considered to be input-only. This means that the value of - the argument is passed to a Fortran/C function and that the function is - expected to not change the value of this argument. + The corresponding argument is considered to be input-only. This means that + the value of the argument is passed to a Fortran/C function and that the + function is expected to not change the value of this argument. * ``inout`` - The corresponding argument is marked for input/output or as an *in situ* output - argument. ``intent(inout)`` arguments can be only "contiguous" NumPy - arrays with proper type and size. Here "contiguous" can be either in the - Fortran or C sense. The latter coincides with the default contiguous + The corresponding argument is marked for input/output or as an *in situ* + output argument. ``intent(inout)`` arguments can be only + :term:`contiguous` NumPy arrays (in either the Fortran or C sense) with + proper type and size. The latter coincides with the default contiguous concept used in NumPy and is effective only if ``intent(c)`` is used. F2PY assumes Fortran contiguous arguments by default. .. note:: - Using ``intent(inout)`` is generally not recommended, use ``intent(in,out)`` instead. + Using ``intent(inout)`` is generally not recommended, as it can cause + unexpected results. For example, scalar arguments using + ``intent(inout)`` are assumed to be array objects in order to have + *in situ* changes be effective. Use ``intent(in,out)`` instead. - See also the ``intent(inplace)`` attribute. + See also the ``intent(inplace)`` attribute. * ``inplace`` The corresponding argument is considered to be an input/output or *in situ* output @@ -586,15 +598,15 @@ The following attributes are used by F2PY: values. Extensions -============ +---------- F2PY directives ^^^^^^^^^^^^^^^^ -The F2PY directives allow using F2PY signature file constructs in -Fortran 77/90 source codes. With this feature one can (almost) completely skip -the intermediate signature file generation and apply F2PY directly to Fortran -source codes. +The F2PY directives allow using F2PY signature file constructs in Fortran 77/90 +source codes. With this feature one can (almost) completely skip the +intermediate signature file generation and apply F2PY directly to Fortran source +codes. F2PY directives have the following form:: @@ -613,6 +625,8 @@ For fixed format Fortran codes, ```` must be at the first column of a file, of course. For free format Fortran codes, the F2PY directives can appear anywhere in a file. +.. _c-expressions: + C expressions ^^^^^^^^^^^^^^ @@ -631,21 +645,20 @@ A C expression may contain: according to given dependence relations; * the following CPP macros: - * ``rank()`` + ``f2py_rank()`` Returns the rank of an array ````. - - * ``shape(,)`` + ``f2py_shape(, )`` Returns the ````-th dimension of an array ````. - - * ``len()`` + ``f2py_len()`` Returns the length of an array ````. - - * ``size()`` + ``f2py_size()`` Returns the size of an array ````. - - * ``slen()`` + ``f2py_itemsize()`` + Returns the itemsize of an array ````. + ``f2py_slen()`` Returns the length of a string ````. + For initializing an array ````, F2PY generates a loop over all indices and dimensions that executes the following pseudo-statement:: @@ -692,4 +705,15 @@ Currently, multi-line blocks can be used in the following constructs: * as a list of C arrays of the ``pymethoddef`` statement; -* as a documentation string. ++ as documentation string. + +Extended char-selector +----------------------- + +F2PY extends char-selector specification, usable within a signature +file or a F2PY directive, as follows:: + + := + | (f2py_len= ) + +See :ref:`Character Strings` for usage. diff --git a/doc/source/f2py/usage.rst b/doc/source/f2py/usage.rst index 596148799ba9..04f5a8c7d996 100644 --- a/doc/source/f2py/usage.rst +++ b/doc/source/f2py/usage.rst @@ -2,246 +2,296 @@ Using F2PY =========== -F2PY can be used either as a command line tool ``f2py`` or as a Python -module ``numpy.f2py``. While we try to provide the command line tool as part -of the numpy setup, some platforms like Windows make it difficult to -reliably put the executables on the ``PATH``. We will refer to ``f2py`` -in this document but you may have to run it as a module:: +This page contains a reference to all command-line options for the ``f2py`` +command, as well as a reference to internal functions of the ``numpy.f2py`` +module. - python -m numpy.f2py +Using ``f2py`` as a command-line tool +===================================== -If you run ``f2py`` with no arguments, and the line ``numpy Version`` at the -end matches the NumPy version printed from ``python -m numpy.f2py``, then you -can use the shorter version. If not, or if you cannot run ``f2py``, you should -replace all calls to ``f2py`` here with the longer version. +When used as a command-line tool, ``f2py`` has three major modes, distinguished +by the usage of ``-c`` and ``-h`` switches. -Command ``f2py`` -================= +1. Signature file generation +~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -When used as a command line tool, ``f2py`` has three major modes, -distinguished by the usage of ``-c`` and ``-h`` switches: +To scan Fortran sources and generate a signature file, use -Signature file generation -^^^^^^^^^^^^^^^^^^^^^^^^^^ +.. code-block:: sh -1. To scan Fortran sources and generate a signature file, use + f2py -h \ + [[ only: : ] \ + [ skip: : ]]... \ + [ ...] - .. code-block:: sh +.. note:: - f2py -h \ - [[ only: : ] \ - [ skip: : ]]... \ - [ ...] + A Fortran source file can contain many routines, and it is often not + necessary to allow all routines to be usable from Python. In such cases, + either specify which routines should be wrapped (in the ``only: .. :`` part) + or which routines F2PY should ignore (in the ``skip: .. :`` part). - .. note:: +If ```` is specified as ``stdout``, then signatures are written to +standard output instead of a file. - A Fortran source file can contain many routines, and it is often - not necessary to allow all routines be usable from Python. In such cases, - either specify which routines should be wrapped (in the ``only: .. :`` part) - or which routines F2PY should ignored (in the ``skip: .. :`` part). +Among other options (see below), the following can be used in this mode: - If ```` is specified as ``stdout`` then signatures - are written to standard output instead of a file. + ``--overwrite-signature`` + Overwrites an existing signature file. - Among other options (see below), the following can be used - in this mode: +2. Extension module construction +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - ``--overwrite-signature`` - Overwrites an existing signature file. +To construct an extension module, use -Extension module construction -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +.. code-block:: sh -2. To construct an extension module, use + f2py -m \ + [[ only: : ] \ + [ skip: : ]]... \ + [ ...] - .. code-block:: sh +The constructed extension module is saved as ``module.c`` to the +current directory. - f2py -m \ - [[ only: : ] \ - [ skip: : ]]... \ - [ ...] +Here ```` may also contain signature files. Among other options +(see below), the following options can be used in this mode: - The constructed extension module is saved as - ``module.c`` to the current directory. + ``--debug-capi`` + Adds debugging hooks to the extension module. When using this extension + module, various diagnostic information about the wrapper is written to the + standard output, for example, the values of variables, the steps taken, etc. - Here ```` may also contain signature files. - Among other options (see below), the following options can be used - in this mode: + ``-include''`` + Add a CPP ``#include`` statement to the extension module source. + ```` should be given in one of the following forms - ``--debug-capi`` - Adds debugging hooks to the extension module. When using this extension - module, various diagnostic information about the wrapper is written to - the standard output, for example, the values of variables, the steps taken, - etc. + .. code-block:: cpp - ``-include''`` - Add a CPP ``#include`` statement to the extension module source. - ```` should be given in one of the following forms + "filename.ext" + - .. code-block:: cpp + The include statement is inserted just before the wrapper functions. This + feature enables using arbitrary C functions (defined in ````) + in F2PY generated wrappers. - "filename.ext" - + .. note:: This option is deprecated. Use ``usercode`` statement to specify + C code snippets directly in signature files. - The include statement is inserted just before the wrapper - functions. This feature enables using arbitrary C functions - (defined in ````) in F2PY generated wrappers. + ``--[no-]wrap-functions`` + Create Fortran subroutine wrappers to Fortran functions. + ``--wrap-functions`` is default because it ensures maximum portability and + compiler independence. - .. note:: This option is deprecated. Use ``usercode`` statement to specify C code snippets directly in signature files. + ``--include-paths ::..`` + Search include files from given directories. - ``--[no-]wrap-functions`` - Create Fortran subroutine wrappers to Fortran functions. - ``--wrap-functions`` is default because it ensures maximum - portability and compiler independence. + ``--help-link []`` + List system resources found by ``numpy_distutils/system_info.py``. For + example, try ``f2py --help-link lapack_opt``. - ``--include-paths ::..`` - Search include files from given directories. +3. Building a module +~~~~~~~~~~~~~~~~~~~~ - ``--help-link []`` - List system resources found by ``numpy_distutils/system_info.py``. - For example, try ``f2py --help-link lapack_opt``. +To build an extension module, use -Building a module -^^^^^^^^^^^^^^^^^ +.. code-block:: sh -3. To build an extension module, use - - .. code-block:: sh - - f2py -c \ - [[ only: : ] \ - [ skip: : ]]... \ - [ ] [ <.o, .a, .so files> ] + f2py -c \ + [[ only: : ] \ + [ skip: : ]]... \ + [ ] [ <.o, .a, .so files> ] - If ```` contains a signature file, then the source for - an extension module is constructed, all Fortran and C sources are - compiled, and finally all object and library files are linked to the - extension module ``.so`` which is saved into the current - directory. - - If ```` does not contain a signature file, then an - extension module is constructed by scanning all Fortran source codes - for routine signatures, before proceeding to build the extension module. +If ```` contains a signature file, then the source for an +extension module is constructed, all Fortran and C sources are compiled, and +finally all object and library files are linked to the extension module +``.so`` which is saved into the current directory. + +If ```` does not contain a signature file, then an extension +module is constructed by scanning all Fortran source codes for routine +signatures, before proceeding to build the extension module. - Among other options (see below) and options described for previous - modes, the following options can be used in this mode: +Among other options (see below) and options described for previous modes, the +following options can be used in this mode: - ``--help-fcompiler`` - List the available Fortran compilers. - ``--help-compiler`` **[depreciated]** - List the available Fortran compilers. - ``--fcompiler=`` - Specify a Fortran compiler type by vendor. - ``--f77exec=`` - Specify the path to a F77 compiler - ``--fcompiler-exec=`` **[depreciated]** - Specify the path to a F77 compiler - ``--f90exec=`` - Specify the path to a F90 compiler - ``--f90compiler-exec=`` **[depreciated]** - Specify the path to a F90 compiler - ``--f77flags=`` - Specify F77 compiler flags - ``--f90flags=`` - Specify F90 compiler flags - ``--opt=`` - Specify optimization flags - ``--arch=`` - Specify architecture specific optimization flags - ``--noopt`` - Compile without optimization flags - ``--noarch`` - Compile without arch-dependent optimization flags - ``--debug`` - Compile with debugging information - ``-l`` - Use the library ```` when linking. - ``-D[=]`` - Define macro ```` as ````. - ``-U`` - Define macro ```` - ``-I`` - Append directory ```` to the list of directories searched for - include files. - ``-L`` - Add directory ```` to the list of directories to be searched - for ``-l``. - ``link-`` - Link the extension module with as defined by - ``numpy_distutils/system_info.py``. E.g. to link with optimized - LAPACK libraries (vecLib on MacOSX, ATLAS elsewhere), use - ``--link-lapack_opt``. See also ``--help-link`` switch. - - .. note:: The ``f2py -c`` option must be applied either to an existing ``.pyf`` file (plus the source/object/library files) or one must specify the ``-m `` option (plus the sources/object/library files). Use one of the following options: - - .. code-block:: sh - - f2py -c -m fib1 fib1.f - - or - - .. code-block:: sh - - f2py -m fib1 fib1.f -h fib1.pyf - f2py -c fib1.pyf fib1.f - - For more information, see the `Building C and C++ Extensions`__ Python documentation for details. + ``--help-fcompiler`` + List the available Fortran compilers. + ``--help-compiler`` **[depreciated]** + List the available Fortran compilers. + ``--fcompiler=`` + Specify a Fortran compiler type by vendor. + ``--f77exec=`` + Specify the path to a F77 compiler + ``--fcompiler-exec=`` **[depreciated]** + Specify the path to a F77 compiler + ``--f90exec=`` + Specify the path to a F90 compiler + ``--f90compiler-exec=`` **[depreciated]** + Specify the path to a F90 compiler + ``--f77flags=`` + Specify F77 compiler flags + ``--f90flags=`` + Specify F90 compiler flags + ``--opt=`` + Specify optimization flags + ``--arch=`` + Specify architecture specific optimization flags + ``--noopt`` + Compile without optimization flags + ``--noarch`` + Compile without arch-dependent optimization flags + ``--debug`` + Compile with debugging information + ``-l`` + Use the library ```` when linking. + ``-D[=]`` + Define macro ```` as ````. + ``-U`` + Define macro ```` + ``-I`` + Append directory ```` to the list of directories searched for include + files. + ``-L`` + Add directory ```` to the list of directories to be searched for + ``-l``. + ``link-`` + Link the extension module with as defined by + ``numpy_distutils/system_info.py``. E.g. to link with optimized LAPACK + libraries (vecLib on MacOSX, ATLAS elsewhere), use ``--link-lapack_opt``. + See also ``--help-link`` switch. + +.. note:: + + The ``f2py -c`` option must be applied either to an existing ``.pyf`` file + (plus the source/object/library files) or one must specify the + ``-m `` option (plus the sources/object/library files). Use one of + the following options: + + .. code-block:: sh + + f2py -c -m fib1 fib1.f + + or + + .. code-block:: sh + + f2py -m fib1 fib1.f -h fib1.pyf + f2py -c fib1.pyf fib1.f + + For more information, see the `Building C and C++ Extensions`__ Python + documentation for details. __ https://docs.python.org/3/extending/building.html - When building an extension module, a combination of the following - macros may be required for non-gcc Fortran compilers: +When building an extension module, a combination of the following macros may be +required for non-gcc Fortran compilers: - .. code-block:: sh +.. code-block:: sh - -DPREPEND_FORTRAN - -DNO_APPEND_FORTRAN - -DUPPERCASE_FORTRAN + -DPREPEND_FORTRAN + -DNO_APPEND_FORTRAN + -DUPPERCASE_FORTRAN - To test the performance of F2PY generated interfaces, use - ``-DF2PY_REPORT_ATEXIT``. Then a report of various timings is - printed out at the exit of Python. This feature may not work on - all platforms, currently only Linux platform is supported. +To test the performance of F2PY generated interfaces, use +``-DF2PY_REPORT_ATEXIT``. Then a report of various timings is printed out at the +exit of Python. This feature may not work on all platforms, and currently only +Linux is supported. - To see whether F2PY generated interface performs copies of array - arguments, use ``-DF2PY_REPORT_ON_ARRAY_COPY=``. When the size - of an array argument is larger than ````, a message about - the coping is sent to ``stderr``. +To see whether F2PY generated interface performs copies of array arguments, use +``-DF2PY_REPORT_ON_ARRAY_COPY=``. When the size of an array argument is +larger than ````, a message about the copying is sent to ``stderr``. Other options -^^^^^^^^^^^^^ - -``-m `` - Name of an extension module. Default is ``untitled``. - - .. warning:: Don't use this option if a signature file (\*.pyf) is used. -``--[no-]lower`` - Do [not] lower the cases in ````. By default, - ``--lower`` is assumed with ``-h`` switch, and ``--no-lower`` - without the ``-h`` switch. -``--build-dir `` - All F2PY generated files are created in ````. Default is - ``tempfile.mkdtemp()``. -``--quiet`` - Run quietly. -``--verbose`` - Run with extra verbosity. -``-v`` - Print the F2PY version and exit. - -Execute ``f2py`` without any options to get an up-to-date list of -available options. +~~~~~~~~~~~~~ + + ``-m `` + Name of an extension module. Default is ``untitled``. + + .. warning:: Don't use this option if a signature file (``*.pyf``) is used. + + ``--[no-]lower`` + Do [not] lower the cases in ````. By default, ``--lower`` is + assumed with ``-h`` switch, and ``--no-lower`` without the ``-h`` switch. + ``-include
`` + Writes additional headers in the C wrapper, can be passed multiple times, + generates #include
each time. Note that this is meant to be passed + in single quotes and without spaces, for example ``'-include'`` + ``--build-dir `` + All F2PY generated files are created in ````. Default is + ``tempfile.mkdtemp()``. + ``--f2cmap `` + Load Fortran-to-C ``KIND`` specifications from the given file. + ``--quiet`` + Run quietly. + ``--verbose`` + Run with extra verbosity. + ``--skip-empty-wrappers`` + Do not generate wrapper files unless required by the inputs. + This is a backwards compatibility flag to restore pre 1.22.4 behavior. + ``-v`` + Print the F2PY version and exit. + +Execute ``f2py`` without any options to get an up-to-date list of available +options. Python module ``numpy.f2py`` ============================ -.. warning:: +The f2py program is written in Python and can be run from inside your code +to compile Fortran code at runtime, as follows: + +.. code-block:: python - The current Python interface to the ``f2py`` module is not mature and - may change in the future. + from numpy import f2py + with open("add.f") as sourcefile: + sourcecode = sourcefile.read() + f2py.compile(sourcecode, modulename='add') + import add + +The source string can be any valid Fortran code. If you want to save +the extension-module source code then a suitable file-name can be +provided by the ``source_fn`` keyword to the compile function. + +When using ``numpy.f2py`` as a module, the following functions can be invoked. + +.. warning:: + The current Python interface to the ``f2py`` module is not mature and may + change in the future. .. automodule:: numpy.f2py :members: +Automatic extension module generation +===================================== + +If you want to distribute your f2py extension module, then you only +need to include the .pyf file and the Fortran code. The distutils +extensions in NumPy allow you to define an extension module entirely +in terms of this interface file. A valid ``setup.py`` file allowing +distribution of the ``add.f`` module (as part of the package +``f2py_examples`` so that it would be loaded as ``f2py_examples.add``) is: + +.. code-block:: python + + def configuration(parent_package='', top_path=None) + from numpy.distutils.misc_util import Configuration + config = Configuration('f2py_examples',parent_package, top_path) + config.add_extension('add', sources=['add.pyf','add.f']) + return config + + if __name__ == '__main__': + from numpy.distutils.core import setup + setup(**configuration(top_path='').todict()) + +Installation of the new package is easy using:: + + pip install . + +assuming you have the proper permissions to write to the main site- +packages directory for the version of Python you are using. For the +resulting package to work, you need to create a file named ``__init__.py`` +(in the same directory as ``add.pyf``). Notice the extension module is +defined entirely in terms of the ``add.pyf`` and ``add.f`` files. The +conversion of the .pyf file to a .c file is handled by `numpy.distutils`. diff --git a/doc/source/f2py/windows/conda.rst b/doc/source/f2py/windows/conda.rst new file mode 100644 index 000000000000..08a79b29dacd --- /dev/null +++ b/doc/source/f2py/windows/conda.rst @@ -0,0 +1,34 @@ +.. _f2py-win-conda: + +========================= +F2PY and Conda on Windows +========================= + +As a convenience measure, we will additionally assume the +existence of ``scoop``, which can be used to install tools without +administrative access. + +.. code-block:: powershell + + Invoke-Expression (New-Object System.Net.WebClient).DownloadString('https://get.scoop.sh') + +Now we will setup a ``conda`` environment. + +.. code-block:: powershell + + scoop install miniconda3 + # For conda activate / deactivate in powershell + conda install -n root -c pscondaenvs pscondaenvs + Powershell -c Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser + conda init powershell + # Open a new shell for the rest + +``conda`` pulls packages from ``msys2``, however, the UX is sufficiently different enough to warrant a separate discussion. + +.. warning:: + + As of 30-01-2022, the `MSYS2 binaries`_ shipped with ``conda`` are **outdated** and this approach is **not preferred**. + + + +.. _MSYS2 binaries: https://github.com/conda-forge/conda-forge.github.io/issues/1044 diff --git a/doc/source/f2py/windows/index.rst b/doc/source/f2py/windows/index.rst new file mode 100644 index 000000000000..c1e6b4128491 --- /dev/null +++ b/doc/source/f2py/windows/index.rst @@ -0,0 +1,208 @@ +.. _f2py-windows: + +================= +F2PY and Windows +================= + +.. warning:: + + F2PY support for Windows is not at par with Linux support, and + OS specific flags can be seen via ``python -m numpy.f2py`` + +Broadly speaking, there are two issues working with F2PY on Windows: + +- the lack of actively developed FOSS Fortran compilers, and, +- the linking issues related to the C runtime library for building Python-C extensions. + +The focus of this section is to establish a guideline for developing and +extending Fortran modules for Python natively, via F2PY on Windows. + +Overview +======== +From a user perspective, the most UNIX compatible Windows +development environment is through emulation, either via the Windows Subsystem +on Linux, or facilitated by Docker. In a similar vein, traditional +virtualization methods like VirtualBox are also reasonable methods to develop +UNIX tools on Windows. + +Native Windows support is typically stunted beyond the usage of commercial compilers. +However, as of 2022, most commercial compilers have free plans which are sufficient for +general use. Additionally, the Fortran language features supported by ``f2py`` +(partial coverage of Fortran 2003), means that newer toolchains are often not +required. Briefly, then, for an end user, in order of use: + +Classic Intel Compilers (commercial) + These are maintained actively, though licensing restrictions may apply as + further detailed in :ref:`f2py-win-intel`. + + Suitable for general use for those building native Windows programs by + building off of MSVC. + +MSYS2 (FOSS) + In conjunction with the ``mingw-w64`` project, ``gfortran`` and ``gcc`` + toolchains can be used to natively build Windows programs. + +Windows Subsystem for Linux + Assuming the usage of ``gfortran``, this can be used for cross-compiling + Windows applications, but is significantly more complicated. + +Conda + Windows support for compilers in ``conda`` is facilitated by pulling MSYS2 + binaries, however these `are outdated`_, and therefore not recommended (as of 30-01-2022). + +PGI Compilers (commercial) + Unmaintained but sufficient if an existing license is present. Works + natively, but has been superseded by the Nvidia HPC SDK, with no `native + Windows support`_. + +Cygwin (FOSS) + Can also be used for ``gfortran``. Howeve, the POSIX API compatibility layer provided by + Cygwin is meant to compile UNIX software on Windows, instead of building + native Windows programs. This means cross compilation is required. + +The compilation suites described so far are compatible with the `now +deprecated`_ ``np.distutils`` build backend which is exposed by the F2PY CLI. +Additional build system usage (``meson``, ``cmake``) as described in +:ref:`f2py-bldsys` allows for a more flexible set of compiler +backends including: + +Intel oneAPI + The newer Intel compilers (``ifx``, ``icx``) are based on LLVM and can be + used for native compilation. Licensing requirements can be onerous. + +Classic Flang (FOSS) + The backbone of the PGI compilers were cannibalized to form the "classic" or + `legacy version of Flang`_. This may be compiled from source and used + natively. `LLVM Flang`_ does not support Windows yet (30-01-2022). + +LFortran (FOSS) + One of two LLVM based compilers. Not all of F2PY supported Fortran can be + compiled yet (30-01-2022) but uses MSVC for native linking. + + +Baseline +======== + +For this document we will assume the following basic tools: + +- The IDE being considered is the community supported `Microsoft Visual Studio Code`_ +- The terminal being used is the `Windows Terminal`_ +- The shell environment is assumed to be `Powershell 7.x`_ +- Python 3.10 from `the Microsoft Store`_ and this can be tested with + ``Get-Command python.exe`` resolving to + ``C:\Users\$USERNAME\AppData\Local\Microsoft\WindowsApps\python.exe`` +- The Microsoft Visual C++ (MSVC) toolset + +With this baseline configuration, we will further consider a configuration +matrix as follows: + +.. _table-f2py-winsup-mat: + +.. table:: Support matrix, exe implies a Windows installer + + +----------------------+--------------------+-------------------+ + | **Fortran Compiler** | **C/C++ Compiler** | **Source** | + +======================+====================+===================+ + | Intel Fortran | MSVC / ICC | exe | + +----------------------+--------------------+-------------------+ + | GFortran | MSVC | MSYS2/exe | + +----------------------+--------------------+-------------------+ + | GFortran | GCC | WSL | + +----------------------+--------------------+-------------------+ + | Classic Flang | MSVC | Source / Conda | + +----------------------+--------------------+-------------------+ + | Anaconda GFortran | Anaconda GCC | exe | + +----------------------+--------------------+-------------------+ + +For an understanding of the key issues motivating the need for such a matrix +`Pauli Virtanen's in-depth post on wheels with Fortran for Windows`_ is an +excellent resource. An entertaining explanation of an application binary +interface (ABI) can be found in this post by `JeanHeyd Meneide`_. + +Powershell and MSVC +==================== + +MSVC is installed either via the Visual Studio Bundle or the lighter (preferred) +`Build Tools for Visual Studio`_ with the ``Desktop development with C++`` +setting. + +.. note:: + + This can take a significant amount of time as it includes a download of around + 2GB and requires a restart. + +It is possible to use the resulting environment from a `standard command +prompt`_. However, it is more pleasant to use a `developer powershell`_, +with a `profile in Windows Terminal`_. This can be achieved by adding the +following block to the ``profiles->list`` section of the JSON file used to +configure Windows Terminal (see ``Settings->Open JSON file``): + +.. code-block:: json + + { + "name": "Developer PowerShell for VS 2019", + "commandline": "powershell.exe -noe -c \"$vsPath = (Join-Path ${env:ProgramFiles(x86)} -ChildPath 'Microsoft Visual Studio\\2019\\BuildTools'); Import-Module (Join-Path $vsPath 'Common7\\Tools\\Microsoft.VisualStudio.DevShell.dll'); Enter-VsDevShell -VsInstallPath $vsPath -SkipAutomaticLocation\"", + "icon": "ms-appx:///ProfileIcons/{61c54bbd-c2c6-5271-96e7-009a87ff44bf}.png" + } + +Now, testing the compiler toolchain could look like: + +.. code-block:: powershell + + # New Windows Developer Powershell instance / tab + # or + $vsPath = (Join-Path ${env:ProgramFiles(x86)} -ChildPath 'Microsoft Visual Studio\\2019\\BuildTools'); + Import-Module (Join-Path $vsPath 'Common7\\Tools\\Microsoft.VisualStudio.DevShell.dll'); + Enter-VsDevShell -VsInstallPath $vsPath -SkipAutomaticLocation + ********************************************************************** + ** Visual Studio 2019 Developer PowerShell v16.11.9 + ** Copyright (c) 2021 Microsoft Corporation + ********************************************************************** + cd $HOME + echo "#include" > blah.cpp; echo 'int main(){printf("Hi");return 1;}' >> blah.cpp + cl blah.cpp + .\blah.exe + # Hi + rm blah.cpp + +It is also possible to check that the environment has been updated correctly +with ``$ENV:PATH``. + + +Windows Store Python Paths +========================== + +The MS Windows version of Python discussed here installs to a non-deterministic +path using a hash. This needs to be added to the ``PATH`` variable. + +.. code-block:: powershell + + $Env:Path += ";$env:LOCALAPPDATA\packages\pythonsoftwarefoundation.python.3.10_qbz5n2kfra8p0\localcache\local-packages\python310\scripts" + +.. toctree:: + :maxdepth: 2 + + intel + msys2 + conda + pgi + + +.. _the Microsoft Store: https://www.microsoft.com/en-us/p/python-310/9pjpw5ldxlz5 +.. _Microsoft Visual Studio Code: https://code.visualstudio.com/Download +.. _more complete POSIX environment: https://www.cygwin.com/ +.. _This MSYS2 document: https://www.msys2.org/wiki/How-does-MSYS2-differ-from-Cygwin/ +.. _Build Tools for Visual Studio: https://visualstudio.microsoft.com/downloads/#build-tools-for-visual-studio-2019 +.. _Windows Terminal: https://www.microsoft.com/en-us/p/windows-terminal/9n0dx20hk701?activetab=pivot:overviewtab +.. _Powershell 7.x: https://docs.microsoft.com/en-us/powershell/scripting/install/installing-powershell-on-windows?view=powershell-7.1 +.. _standard command prompt: https://docs.microsoft.com/en-us/cpp/build/building-on-the-command-line?view=msvc-160#developer_command_file_locations +.. _developer powershell: https://docs.microsoft.com/en-us/visualstudio/ide/reference/command-prompt-powershell?view=vs-2019 +.. _profile in Windows Terminal: https://techcommunity.microsoft.com/t5/microsoft-365-pnp-blog/add-developer-powershell-and-developer-command-prompt-for-visual/ba-p/2243078 +.. _Pauli Virtanen's in-depth post on wheels with Fortran for Windows: https://pav.iki.fi/blog/2017-10-08/pywingfortran.html#building-python-wheels-with-fortran-for-windows +.. _Nvidia HPC SDK: https://www.pgroup.com/index.html +.. _JeanHeyd Meneide: https://thephd.dev/binary-banshees-digital-demons-abi-c-c++-help-me-god-please +.. _legacy version of Flang: https://github.com/flang-compiler/flang +.. _native Windows support: https://developer.nvidia.com/nvidia-hpc-sdk-downloads#collapseFour +.. _are outdated: https://github.com/conda-forge/conda-forge.github.io/issues/1044 +.. _now deprecated: https://github.com/numpy/numpy/pull/20875 +.. _LLVM Flang: https://releases.llvm.org/11.0.0/tools/flang/docs/ReleaseNotes.html diff --git a/doc/source/f2py/windows/intel.rst b/doc/source/f2py/windows/intel.rst new file mode 100644 index 000000000000..ab0cea219e70 --- /dev/null +++ b/doc/source/f2py/windows/intel.rst @@ -0,0 +1,57 @@ +.. _f2py-win-intel: + +============================== +F2PY and Windows Intel Fortran +============================== + +As of NumPy 1.23, only the classic Intel compilers (``ifort``) are supported. + +.. note:: + + The licensing restrictions for beta software `have been relaxed`_ during + the transition to the LLVM backed ``ifx/icc`` family of compilers. + However this document does not endorse the usage of Intel in downstream + projects due to the issues pertaining to `disassembly of components and + liability`_. + + Neither the Python Intel installation nor the `Classic Intel C/C++ + Compiler` are required. + +- The `Intel Fortran Compilers`_ come in a combined installer providing both + Classic and Beta versions; these also take around a gigabyte and a half or so. + +We will consider the classic example of the generation of Fibonnaci numbers, +``fib1.f``, given by: + +.. literalinclude:: ../code/fib1.f + :language: fortran + +For ``cmd.exe`` fans, using the Intel oneAPI command prompt is the easiest approach, as +it loads the required environment for both ``ifort`` and ``msvc``. Helper batch +scripts are also provided. + +.. code-block:: bat + + # cmd.exe + "C:\Program Files (x86)\Intel\oneAPI\setvars.bat" + python -m numpy.f2py -c fib1.f -m fib1 + python -c "import fib1; import numpy as np; a=np.zeros(8); fib1.fib(a); print(a)" + +Powershell usage is a little less pleasant, and this configuration now works with MSVC as: + +.. code-block:: powershell + + # Powershell + python -m numpy.f2py -c fib1.f -m fib1 --f77exec='C:\Program Files (x86)\Intel\oneAPI\compiler\latest\windows\bin\intel64\ifort.exe' --f90exec='C:\Program Files (x86)\Intel\oneAPI\compiler\latest\windows\bin\intel64\ifort.exe' -L'C:\Program Files (x86)\Intel\oneAPI\compiler\latest\windows\compiler\lib\ia32' + python -c "import fib1; import numpy as np; a=np.zeros(8); fib1.fib(a); print(a)" + # Alternatively, set environment and reload Powershell in one line + cmd.exe /k '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell' + python -m numpy.f2py -c fib1.f -m fib1 + python -c "import fib1; import numpy as np; a=np.zeros(8); fib1.fib(a); print(a)" + +Note that the actual path to your local installation of `ifort` may vary, and the command above will need to be updated accordingly. + +.. _have been relaxed: https://www.intel.com/content/www/us/en/developer/articles/release-notes/oneapi-fortran-compiler-release-notes.html +.. _disassembly of components and liability: https://software.sintel.com/content/www/us/en/develop/articles/end-user-license-agreement.html +.. _Intel Fortran Compilers: https://www.intel.com/content/www/us/en/developer/articles/tool/oneapi-standalone-components.html#inpage-nav-6-1 +.. _Classic Intel C/C++ Compiler: https://www.intel.com/content/www/us/en/developer/articles/tool/oneapi-standalone-components.html#inpage-nav-6-undefined \ No newline at end of file diff --git a/doc/source/f2py/windows/msys2.rst b/doc/source/f2py/windows/msys2.rst new file mode 100644 index 000000000000..68c4353111c9 --- /dev/null +++ b/doc/source/f2py/windows/msys2.rst @@ -0,0 +1,19 @@ +.. _f2py-win-msys2: + +=========================== +F2PY and Windows with MSYS2 +=========================== + +Follow the standard `installation instructions`_. Then, to grab the requisite Fortran compiler with ``MVSC``: + +.. code-block:: bash + + # Assuming a fresh install + pacman -Syu # Restart the terminal + pacman -Su # Update packages + # Get the toolchains + pacman -S --needed base-devel gcc-fortran + pacman -S mingw-w64-x86_64-toolchain + + +.. _`installation instructions`: https://www.msys2.org/ diff --git a/doc/source/f2py/windows/pgi.rst b/doc/source/f2py/windows/pgi.rst new file mode 100644 index 000000000000..644259abe8c6 --- /dev/null +++ b/doc/source/f2py/windows/pgi.rst @@ -0,0 +1,28 @@ +.. _f2py-win-pgi: + +=============================== +F2PY and PGI Fortran on Windows +=============================== + +A variant of these are part of the so called "classic" Flang, however, +as classic Flang requires a custom LLVM and compilation from sources. + +.. warning:: + + Since the proprietary compilers are no longer available for + usage they are not recommended and will not be ported to the + new ``f2py`` CLI. + + + +.. note:: + + **As of November 2021** + + As of 29-01-2022, `PGI compiler toolchains`_ have been superseded by the Nvidia + HPC SDK, with no `native Windows support`_. + +However, + +.. _PGI compiler toolchains: https://www.pgroup.com/index.html +.. _native Windows support: https://developer.nvidia.com/nvidia-hpc-sdk-downloads#collapseFour diff --git a/doc/source/getting_started.rst b/doc/source/getting_started.rst new file mode 100644 index 000000000000..cd7a66317ad8 --- /dev/null +++ b/doc/source/getting_started.rst @@ -0,0 +1,4 @@ +:orphan: + +Getting started +=============== \ No newline at end of file diff --git a/doc/source/glossary.rst b/doc/source/glossary.rst index aa2dc13dff1f..eebebd9dc555 100644 --- a/doc/source/glossary.rst +++ b/doc/source/glossary.rst @@ -166,10 +166,10 @@ Glossary array scalar - An :doc:`array scalar ` is an instance of the types/classes float32, float64, - etc.. For uniformity in handling operands, NumPy treats a scalar as - an array of zero dimension. In contrast, a 0-dimensional array is an :doc:`ndarray ` instance - containing precisely one value. + An :doc:`array scalar ` is an instance of the types/classes float32, float64, + etc.. For uniformity in handling operands, NumPy treats a scalar as + an array of zero dimension. In contrast, a 0-dimensional array is an :doc:`ndarray ` instance + containing precisely one value. axis @@ -280,10 +280,36 @@ Glossary contiguous - An array is contiguous if - * it occupies an unbroken block of memory, and - * array elements with higher indexes occupy higher addresses (that - is, no :term:`stride` is negative). + + An array is contiguous if: + + - it occupies an unbroken block of memory, and + - array elements with higher indexes occupy higher addresses (that + is, no :term:`stride` is negative). + + There are two types of proper-contiguous NumPy arrays: + + - Fortran-contiguous arrays refer to data that is stored column-wise, + i.e. the indexing of data as stored in memory starts from the + lowest dimension; + - C-contiguous, or simply contiguous arrays, refer to data that is + stored row-wise, i.e. the indexing of data as stored in memory + starts from the highest dimension. + + For one-dimensional arrays these notions coincide. + + For example, a 2x2 array ``A`` is Fortran-contiguous if its elements are + stored in memory in the following order:: + + A[0,0] A[1,0] A[0,1] A[1,1] + + and C-contiguous if the order is as follows:: + + A[0,0] A[0,1] A[1,0] A[1,1] + + To test whether an array is C-contiguous, use the ``.flags.c_contiguous`` + attribute of NumPy arrays. To test for Fortran contiguity, use the + ``.flags.f_contiguous`` attribute. copy @@ -395,7 +421,7 @@ Glossary both flatten an ndarray. ``ravel`` will return a view if possible; ``flatten`` always returns a copy. - Flattening collapses a multimdimensional array to a single dimension; + Flattening collapses a multidimensional array to a single dimension; details of how this is done (for instance, whether ``a[n+1]`` should be the next row or next column) are parameters. diff --git a/doc/source/index.rst b/doc/source/index.rst index aac820a6f00b..f31e730d71b8 100644 --- a/doc/source/index.rst +++ b/doc/source/index.rst @@ -11,6 +11,107 @@ NumPy documentation User Guide API reference Development + release + + +**Version**: |version| + +**Download documentation**: +`PDF Version `_ | +`Historical versions of documentation `_ + +**Useful links**: +`Installation `_ | +`Source Repository `_ | +`Issue Tracker `_ | +`Q&A Support `_ | +`Mailing List `_ + +NumPy is the fundamental package for scientific computing in Python. It is a +Python library that provides a multidimensional array object, various derived +objects (such as masked arrays and matrices), and an assortment of routines for +fast operations on arrays, including mathematical, logical, shape manipulation, +sorting, selecting, I/O, discrete Fourier transforms, basic linear algebra, +basic statistical operations, random simulation and much more. + + + +.. grid:: 2 + + .. grid-item-card:: + :img-top: ../source/_static/index-images/getting_started.svg + + Getting Started + ^^^^^^^^^^^^^^^ + + New to NumPy? Check out the Absolute Beginner's Guide. It contains an + introduction to NumPy's main concepts and links to additional tutorials. + + +++ + + .. button-ref:: user/absolute_beginners + :expand: + :color: secondary + :click-parent: + + To the absolute beginner's guide + + .. grid-item-card:: + :img-top: ../source/_static/index-images/user_guide.svg + + User Guide + ^^^^^^^^^^ + + The user guide provides in-depth information on the + key concepts of NumPy with useful background information and explanation. + + +++ + + .. button-ref:: user + :expand: + :color: secondary + :click-parent: + + To the user guide + + .. grid-item-card:: + :img-top: ../source/_static/index-images/api.svg + + API Reference + ^^^^^^^^^^^^^ + + The reference guide contains a detailed description of the functions, + modules, and objects included in NumPy. The reference describes how the + methods work and which parameters can be used. It assumes that you have an + understanding of the key concepts. + + +++ + + .. button-ref:: reference + :expand: + :color: secondary + :click-parent: + + To the reference guide + + .. grid-item-card:: + :img-top: ../source/_static/index-images/contributor.svg + + Contributor's Guide + ^^^^^^^^^^^^^^^^^^^ + + Want to add to the codebase? Can help add translation or a flowchart to the + documentation? The contributing guidelines will guide you through the + process of improving NumPy. + + +++ + + .. button-ref:: devindex + :expand: + :color: secondary + :click-parent: + + To the contributor's guide .. This is not really the index page, that is found in _templates/indexcontent.html The toctree content here will be added to the diff --git a/doc/source/reference/array_api.rst b/doc/source/reference/array_api.rst new file mode 100644 index 000000000000..6982ef31066d --- /dev/null +++ b/doc/source/reference/array_api.rst @@ -0,0 +1,819 @@ +.. _array_api: + +******************************** +Array API Standard Compatibility +******************************** + +.. note:: + + The ``numpy.array_api`` module is still experimental. See `NEP 47 + `__. + +NumPy includes a reference implementation of the `array API standard +`__ in ``numpy.array_api``. `NEP 47 +`__ describes the +motivation and scope for implementing the array API standard in NumPy. + +The ``numpy.array_api`` module serves as a minimal, reference implementation +of the array API standard. In being minimal, the module only implements those +things that are explicitly required by the specification. Certain things are +allowed by the specification but are explicitly disallowed in +``numpy.array_api``. This is so that the module can serve as a reference +implementation for users of the array API standard. Any consumer of the array +API can test their code against ``numpy.array_api`` and be sure that they +aren't using any features that aren't guaranteed by the spec, and which may +not be present in other conforming libraries. + +The ``numpy.array_api`` module is not documented here. For a listing of the +functions present in the array API specification, refer to the `array API +standard `__. The ``numpy.array_api`` +implementation is functionally complete, so all functionality described in the +standard is implemented. + +.. _array_api-differences: + +Table of Differences between ``numpy.array_api`` and ``numpy`` +============================================================== + +This table outlines the primary differences between ``numpy.array_api`` from +the main ``numpy`` namespace. There are three types of differences: + +1. **Strictness**. Things that are only done so that ``numpy.array_api`` is a + strict, minimal implementation. They aren't actually required by the spec, + and other conforming libraries may not follow them. In most cases, spec + does not specify or require any behavior outside of the given domain. The + main ``numpy`` namespace would not need to change in any way to be + spec-compatible for these. + +2. **Compatible**. Things that could be added to the main ``numpy`` namespace + without breaking backwards compatibility. + +3. **Breaking**. Things that would break backwards compatibility if + implemented in the main ``numpy`` namespace. + +Name Differences +---------------- + +Many functions have been renamed in the spec from NumPy. These are otherwise +identical in behavior, and are thus all **compatible** changes, unless +otherwise noted. + +.. _array_api-name-changes: + +Function Name Changes +~~~~~~~~~~~~~~~~~~~~~ + +The following functions are named differently in the array API + +.. list-table:: + :header-rows: 1 + + * - Array API name + - NumPy namespace name + - Notes + * - ``acos`` + - ``arccos`` + - + * - ``acosh`` + - ``arccosh`` + - + * - ``asin`` + - ``arcsin`` + - + * - ``asinh`` + - ``arcsinh`` + - + * - ``atan`` + - ``arctan`` + - + * - ``atan2`` + - ``arctan2`` + - + * - ``atanh`` + - ``arctanh`` + - + * - ``bitwise_left_shift`` + - ``left_shift`` + - + * - ``bitwise_invert`` + - ``invert`` + - + * - ``bitwise_right_shift`` + - ``right_shift`` + - + * - ``bool`` + - ``bool_`` + - This is **breaking** because ``np.bool`` is currently a deprecated + alias for the built-in ``bool``. + * - ``concat`` + - ``concatenate`` + - + * - ``matrix_norm`` and ``vector_norm`` + - ``norm`` + - ``matrix_norm`` and ``vector_norm`` each do a limited subset of what + ``np.norm`` does. + * - ``permute_dims`` + - ``transpose`` + - Unlike ``np.transpose``, the ``axis`` keyword-argument to + ``permute_dims`` is required. + * - ``pow`` + - ``power`` + - + * - ``unique_all``, ``unique_counts``, ``unique_inverse``, and + ``unique_values`` + - ``unique`` + - Each is equivalent to ``np.unique`` with certain flags set. + + +Function instead of method +~~~~~~~~~~~~~~~~~~~~~~~~~~ + +- ``astype`` is a function in the array API, whereas it is a method on + ``ndarray`` in ``numpy``. + + +``linalg`` Namespace Differences +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +These functions are in the ``linalg`` sub-namespace in the array API, but are +only in the top-level namespace in NumPy: + +- ``cross`` +- ``diagonal`` +- ``matmul`` (*) +- ``outer`` +- ``tensordot`` (*) +- ``trace`` + +(*): These functions are also in the top-level namespace in the array API. + +Keyword Argument Renames +~~~~~~~~~~~~~~~~~~~~~~~~ + +The following functions have keyword arguments that have been renamed. The +functionality of the keyword argument is identical unless otherwise stated. +Renamed keyword arguments with the same semantic definition may be considered +either **compatible** or **breaking**, depending on how the change is +implemented. + +Note, this page does not list function keyword arguments that are in the main +``numpy`` namespace but not in the array API. Such keyword arguments are +omitted from ``numpy.array_api`` for **strictness**, as the spec allows +functions to include additional keyword arguments from those required. + +.. list-table:: + :header-rows: 1 + + * - Function + - Array API keyword name + - NumPy keyword name + - Notes + * - ``argsort`` and ``sort`` + - ``stable`` + - ``kind`` + - The definitions of ``stable`` and ``kind`` differ, as do the default + values. The change of the default value makes this **breaking**. See + :ref:`array_api-set-functions-differences`. + * - ``matrix_rank`` + - ``rtol`` + - ``tol`` + - The definitions of ``rtol`` and ``tol`` differ, as do the default + values. The change of the default value makes this **breaking**. See + :ref:`array_api-linear-algebra-differences`. + * - ``pinv`` + - ``rtol`` + - ``rcond`` + - The definitions of ``rtol`` and ``rcond`` are the same, but their + default values differ, making this **breaking**. See + :ref:`array_api-linear-algebra-differences`. + * - ``std`` and ``var`` + - ``correction`` + - ``ddof`` + - + * - ``reshape`` + - ``shape`` + - ``newshape`` + - The argument may be passed as a positional or keyword argument for both + NumPy and the array API. + +.. _array_api-type-promotion-differences: + +Type Promotion Differences +-------------------------- + +Type promotion is the biggest area where NumPy deviates from the spec. The +most notable difference is that NumPy does value-based casting in many cases. +The spec explicitly disallows value-based casting. In the array API, the +result type of any operation is always determined entirely by the input types, +independently of values or shapes. + +.. list-table:: + :header-rows: 1 + + * - Feature + - Type + - Notes + * - Limited set of dtypes. + - **Strictness** + - ``numpy.array_api`` only implements those `dtypes that are required by + the spec + `__. + * - Operators (like ``+``) with Python scalars only accept matching + scalar types. + - **Strictness** + - For example, `` + 1.0`` is not allowed. See `the spec + rules for mixing arrays and Python scalars + `__. + * - Operators (like ``+``) with Python scalars always return the same dtype + as the array. + - **Breaking** + - For example, ``numpy.array_api.asarray(0., dtype=float32) + 1e64`` is a + ``float32`` array. + * - In-place operators are disallowed when the left-hand side would be + promoted. + - **Breaking** + - Example: ``a = np.array(1, dtype=np.int8); a += np.array(1, dtype=np.int16)``. The spec explicitly disallows this. + * - In-place operators are disallowed when the right-hand side operand + cannot broadcast to the shape of the left-hand side operand. + - **Strictness** + - This so-called "reverse broadcasting" should not be allowed. Example: + ``a = np.empty((2, 3, 4)); a += np.empty((3, 4))`` should error. See + https://github.com/numpy/numpy/issues/10404. + * - ``int`` promotion for operators is only specified for integers within + the bounds of the dtype. + - **Strictness** + - ``numpy.array_api`` fallsback to ``np.ndarray`` behavior (either + cast or raise ``OverflowError``). + * - ``__pow__`` and ``__rpow__`` do not do value-based casting for 0-D + arrays. + - **Breaking** + - For example, ``np.array(0., dtype=float32)**np.array(0., + dtype=float64)`` is ``float32``. Note that this is value-based casting + on 0-D arrays, not scalars. + * - No cross-kind casting. + - **Strictness** + - Namely, boolean, integer, and floating-point data types do not cast to + each other, except explicitly with ``astype`` (this is separate from + the behavior with Python scalars). + * - No casting unsigned integer dtypes to floating dtypes (e.g., ``int64 + + uint64 -> float64``. + - **Strictness** + - + * - ``can_cast`` and ``result_type`` are restricted. + - **Strictness** + - The ``numpy.array_api`` implementations disallow cross-kind casting. + * - ``sum`` and ``prod`` always upcast ``float32`` to ``float64`` when + ``dtype=None``. + - **Breaking** + - + +Indexing Differences +-------------------- + +The spec requires only a subset of indexing, but all indexing rules in the +spec are compatible with NumPy's more broad indexing rules. + +.. list-table:: + :header-rows: 1 + + * - Feature + - Type + - Notes + * - No implicit ellipses (``...``). + - **Strictness** + - If an index does not include an ellipsis, all axes must be indexed. + * - The start and stop of a slice may not be out of bounds. + - **Strictness** + - For a slice ``i:j:k``, only the following are allowed: + + - ``i`` or ``j`` omitted (``None``). + - ``-n <= i <= max(0, n - 1)``. + - For ``k > 0`` or ``k`` omitted (``None``), ``-n <= j <= n``. + - For ``k < 0``, ``-n - 1 <= j <= max(0, n - 1)``. + * - Boolean array indices are only allowed as the sole index. + - **Strictness** + - + * - Integer array indices are not allowed at all. + - **Strictness** + - With the exception of 0-D arrays, which are treated like integers. + +.. _array_api-type-strictness: + +Type Strictness +--------------- + +Functions in ``numpy.array_api`` restrict their inputs to only those dtypes +that are explicitly required by the spec, even when the wrapped corresponding +NumPy function would allow a broader set. Here, we list each function and the +dtypes that are allowed in ``numpy.array_api``. These are **strictness** +differences because the spec does not require that other dtypes result in an +error. The categories here are defined as follows: + +- **Floating-point**: ``float32`` or ``float64``. +- **Integer**: Any signed or unsigned integer dtype (``int8``, ``int16``, + ``int32``, ``int64``, ``uint8``, ``uint16``, ``uint32``, or ``uint64``). +- **Boolean**: ``bool``. +- **Integer or boolean**: Any signed or unsigned integer dtype, or ``bool``. + For two-argument functions, both arguments must be integer or both must be + ``bool``. +- **Numeric**: Any integer or floating-point dtype. For two-argument + functions, both arguments must be integer or both must be + floating-point. +- **All**: Any of the above dtype categories. For two-argument functions, both + arguments must be the same kind (integer, floating-point, or boolean). + +In all cases, the return dtype is chosen according to `the rules outlined in +the spec +`__, +and does not differ from NumPy's return dtype for any of the allowed input +dtypes, except in the cases mentioned specifically in the subsections below. + +Elementwise Functions +~~~~~~~~~~~~~~~~~~~~~ + +.. list-table:: + :header-rows: 1 + + * - Function Name + - Dtypes + * - ``abs`` + - Numeric + * - ``acos`` + - Floating-point + * - ``acosh`` + - Floating-point + * - ``add`` + - Numeric + * - ``asin`` (*) + - Floating-point + * - ``asinh`` (*) + - Floating-point + * - ``atan`` (*) + - Floating-point + * - ``atan2`` (*) + - Floating-point + * - ``atanh`` (*) + - Floating-point + * - ``bitwise_and`` + - Integer or boolean + * - ``bitwise_invert`` + - Integer or boolean + * - ``bitwise_left_shift`` (*) + - Integer + * - ``bitwise_or`` + - Integer or boolean + * - ``bitwise_right_shift`` (*) + - Integer + * - ``bitwise_xor`` + - Integer or boolean + * - ``ceil`` + - Numeric + * - ``cos`` + - Floating-point + * - ``cosh`` + - Floating-point + * - ``divide`` + - Floating-point + * - ``equal`` + - All + * - ``exp`` + - Floating-point + * - ``expm1`` + - Floating-point + * - ``floor`` + - Numeric + * - ``floor_divide`` + - Numeric + * - ``greater`` + - Numeric + * - ``greater_equal`` + - Numeric + * - ``isfinite`` + - Numeric + * - ``isinf`` + - Numeric + * - ``isnan`` + - Numeric + * - ``less`` + - Numeric + * - ``less_equal`` + - Numeric + * - ``log`` + - Floating-point + * - ``logaddexp`` + - Floating-point + * - ``log10`` + - Floating-point + * - ``log1p`` + - Floating-point + * - ``log2`` + - Floating-point + * - ``logical_and`` + - Boolean + * - ``logical_not`` + - Boolean + * - ``logical_or`` + - Boolean + * - ``logical_xor`` + - Boolean + * - ``multiply`` + - Numeric + * - ``negative`` + - Numeric + * - ``not_equal`` + - All + * - ``positive`` + - Numeric + * - ``pow`` (*) + - Numeric + * - ``remainder`` + - Numeric + * - ``round`` + - Numeric + * - ``sign`` + - Numeric + * - ``sin`` + - Floating-point + * - ``sinh`` + - Floating-point + * - ``sqrt`` + - Floating-point + * - ``square`` + - Numeric + * - ``subtract`` + - Numeric + * - ``tan`` + - Floating-point + * - ``tanh`` + - Floating-point + * - ``trunc`` + - Numeric + +(*) These functions have different names from the main ``numpy`` namespace. +See :ref:`array_api-name-changes`. + +Creation Functions +~~~~~~~~~~~~~~~~~~ + +.. list-table:: + :header-rows: 1 + + * - Function Name + - Dtypes + * - ``meshgrid`` + - Any (all input dtypes must be the same) + + +Linear Algebra Functions +~~~~~~~~~~~~~~~~~~~~~~~~ + +.. list-table:: + :header-rows: 1 + + * - Function Name + - Dtypes + * - ``cholesky`` + - Floating-point + * - ``cross`` + - Numeric + * - ``det`` + - Floating-point + * - ``diagonal`` + - Any + * - ``eigh`` + - Floating-point + * - ``eighvals`` + - Floating-point + * - ``inv`` + - Floating-point + * - ``matmul`` + - Numeric + * - ``matrix_norm`` (*) + - Floating-point + * - ``matrix_power`` + - Floating-point + * - ``matrix_rank`` + - Floating-point + * - ``matrix_transpose`` (**) + - Any + * - ``outer`` + - Numeric + * - ``pinv`` + - Floating-point + * - ``qr`` + - Floating-point + * - ``slogdet`` + - Floating-point + * - ``solve`` + - Floating-point + * - ``svd`` + - Floating-point + * - ``svdvals`` (**) + - Floating-point + * - ``tensordot`` + - Numeric + * - ``trace`` + - Numeric + * - ``vecdot`` (**) + - Numeric + * - ``vector_norm`` (*) + - Floating-point + +(*) These functions are split from ``norm`` from the main ``numpy`` namespace. +See :ref:`array_api-name-changes`. + +(**) These functions are new in the array API and are not in the main +``numpy`` namespace. + +Array Object +~~~~~~~~~~~~ + +All the special ``__operator__`` methods on the array object behave +identically to their corresponding functions (see `the spec +`__ +for a list of which methods correspond to which functions). The exception is +that operators explicitly allow Python scalars according to the `rules +outlined in the spec +`__ +(see :ref:`array_api-type-promotion-differences`). + + +Array Object Differences +------------------------ + +.. list-table:: + :header-rows: 1 + + * - Feature + - Type + - Notes + * - No array scalars + - **Strictness** + - The spec does not have array scalars, only 0-D arrays. However, other + than the promotion differences outlined in + :ref:`array_api-type-promotion-differences`, scalars duck type as 0-D + arrays for the purposes of the spec. The are immutable, but the spec + `does not require mutability + `__. + * - ``bool()``, ``int()``, and ``float()`` only work on 0-D arrays. + - **Strictness** + - See https://github.com/numpy/numpy/issues/10404. + * - ``__imatmul__`` + - **Compatible** + - ``np.ndarray`` does not currently implement ``__imatmul``. Note that + ``a @= b`` should only defined when it does not change the shape of + ``a``. + * - The ``mT`` attribute for matrix transpose. + - **Compatible** + - See `the spec definition + `__ + for ``mT``. + * - The ``T`` attribute should error if the input is not 2-dimensional. + - **Breaking** + - See `the note in the spec + `__. + * - New method ``to_device`` and attribute ``device`` + - **Compatible** + - The methods would effectively not do anything since NumPy is CPU only + +Creation Functions Differences +------------------------------ + +.. list-table:: + :header-rows: 1 + + * - Feature + - Type + - Notes + * - ``copy`` keyword argument to ``asarray`` + - **Compatible** + - + * - New ``device`` keyword argument to all array creation functions + (``asarray``, ``arange``, ``empty``, ``empty_like``, ``eye``, ``full``, + ``full_like``, ``linspace``, ``ones``, ``ones_like``, ``zeros``, and + ``zeros_like``). + - **Compatible** + - ``device`` would effectively do nothing, since NumPy is CPU only. + +Elementwise Functions Differences +--------------------------------- + +.. list-table:: + :header-rows: 1 + + * - Feature + - Type + - Notes + * - Various functions have been renamed. + - **Compatible** + - See :ref:`array_api-name-changes`. + * - Elementwise functions are only defined for given input type + combinations. + - **Strictness** + - See :ref:`array_api-type-strictness`. + * - ``bitwise_left_shift`` and ``bitwise_right_shift`` are only defined for + ``x2`` nonnegative. + - **Strictness** + - + * - ``ceil``, ``floor``, and ``trunc`` return an integer with integer + input. + - **Breaking** + - ``np.ceil``, ``np.floor``, and ``np.trunc`` return a floating-point + dtype on integer dtype input. + +.. _array_api-linear-algebra-differences: + +Linear Algebra Differences +-------------------------- + +.. list-table:: + :header-rows: 1 + + * - Feature + - Type + - Notes + * - ``cholesky`` includes an ``upper`` keyword argument. + - **Compatible** + - + * - ``cross`` does not allow size 2 vectors (only size 3). + - **Breaking** + - + * - ``diagonal`` operates on the last two axes. + - **Breaking** + - Strictly speaking this can be **compatible** because ``diagonal`` is + moved to the ``linalg`` namespace. + * - ``eigh``, ``qr``, ``slogdet`` and ``svd`` return a named tuple. + - **Compatible** + - The corresponding ``numpy`` functions return a ``tuple``, with the + resulting arrays in the same order. + * - New functions ``matrix_norm`` and ``vector_norm``. + - **Compatible** + - The ``norm`` function has been omitted from the array API and split + into ``matrix_norm`` for matrix norms and ``vector_norm`` for vector + norms. Note that ``vector_norm`` supports any number of axes, whereas + ``np.linalg.norm`` only supports a single axis for vector norms. + * - ``matrix_rank`` has an ``rtol`` keyword argument instead of ``tol``. + - **Breaking** + - In the array API, ``rtol`` filters singular values smaller than + ``rtol * largest_singular_value``. In ``np.linalg.matrix_rank``, + ``tol`` filters singular values smaller than ``tol``. Furthermore, the + default value for ``rtol`` is ``max(M, N) * eps``, whereas the default + value of ``tol`` in ``np.linalg.matrix_rank`` is ``S.max() * + max(M, N) * eps``, where ``S`` is the singular values of the input. The + new flag name is compatible but the default change is breaking + * - ``matrix_rank`` does not support 1-dimensional arrays. + - **Breaking** + - + * - New function ``matrix_transpose``. + - **Compatible** + - Unlike ``np.transpose``, ``matrix_transpose`` only transposes the last + two axes. See `the spec definition + `__ + * - ``outer`` only supports 1-dimensional arrays. + - **Breaking** + - The spec currently only specifies behavior on 1-D arrays but future + behavior will likely be to broadcast, rather than flatten, which is + what ``np.outer`` does. + * - ``pinv`` has an ``rtol`` keyword argument instead of ``rcond`` + - **Breaking** + - The meaning of ``rtol`` and ``rcond`` is the same, but the default + value for ``rtol`` is ``max(M, N) * eps``, whereas the default value + for ``rcond`` is ``1e-15``. The new flag name is compatible but the + default change is breaking. + * - ``solve`` only accepts ``x2`` as a vector when it is exactly + 1-dimensional. + - **Breaking** + - The ``np.linalg.solve`` behavior is ambiguous. See `this numpy issue + `__ and `this array API + specification issue + `__ for more + details. + * - New function ``svdvals``. + - **Compatible** + - Equivalent to ``np.linalg.svd(compute_uv=False)``. + * - The ``axis`` keyword to ``tensordot`` must be a tuple. + - **Compatible** + - In ``np.tensordot``, it can also be an array or array-like. + * - ``trace`` operates on the last two axes. + - **Breaking** + - ``np.trace`` operates on the first two axes by default. Note that the + array API ``trace`` does not allow specifying which axes to operate on. + +Manipulation Functions Differences +---------------------------------- + +.. list-table:: + :header-rows: 1 + + * - Feature + - Type + - Notes + * - Various functions have been renamed + - **Compatible** + - See :ref:`array_api-name-changes`. + * - ``concat`` has different default casting rules from ``np.concatenate`` + - **Strictness** + - No cross-kind casting. No value-based casting on scalars (when axis=None). + * - ``stack`` has different default casting rules from ``np.stack`` + - **Strictness** + - No cross-kind casting. + * - New function ``permute_dims``. + - **Compatible** + - Unlike ``np.transpose``, the ``axis`` keyword argument to + ``permute_dims`` is required. + * - ``reshape`` function has a ``copy`` keyword argument + - **Compatible** + - See https://github.com/numpy/numpy/issues/9818. + +Set Functions Differences +------------------------- + +.. list-table:: + :header-rows: 1 + + * - Feature + - Type + - Notes + * - New functions ``unique_all``, ``unique_counts``, ``unique_inverse``, + and ``unique_values``. + - **Compatible** + - See :ref:`array_api-name-changes`. + * - The four ``unique_*`` functions return a named tuple. + - **Compatible** + - + * - ``unique_all`` and ``unique_indices`` return indices with the same + shape as ``x``. + - **Compatible** + - See https://github.com/numpy/numpy/issues/20638. + +.. _array_api-set-functions-differences: + +Set Functions Differences +------------------------- + +.. list-table:: + :header-rows: 1 + + * - Feature + - Type + - Notes + * - ``argsort`` and ``sort`` have a ``stable`` keyword argument instead of + ``kind``. + - **Breaking** + - ``stable`` is a boolean keyword argument, defaulting to ``True``. + ``kind`` takes a string, defaulting to ``"quicksort"``. ``stable=True`` + is equivalent to ``kind="stable"`` and ``kind=False`` is equivalent to + ``kind="quicksort"``, although any sorting algorithm is allowed by the + spec when ``stable=False``. The new flag name is compatible but the + default change is breaking. + * - ``argsort`` and ``sort`` have a ``descending`` keyword argument. + - **Compatible** + - + +Statistical Functions Differences +--------------------------------- + +.. list-table:: + :header-rows: 1 + + * - Feature + - Type + - Notes + * - ``sum`` and ``prod`` always upcast ``float32`` to ``float64`` when + ``dtype=None``. + - **Breaking** + - + * - The ``std`` and ``var`` functions have a ``correction`` keyword + argument instead of ``ddof``. + - **Compatible** + - + +Other Differences +----------------- + +.. list-table:: + :header-rows: 1 + + * - Feature + - Type + - Notes + * - Dtypes can only be spelled as dtype objects. + - **Strictness** + - For example, ``numpy.array_api.asarray([0], dtype='int32')`` is not + allowed. + * - ``asarray`` is not implicitly called in any function. + - **Strictness** + - The exception is Python operators, which accept Python scalars in + certain cases (see :ref:`array_api-type-promotion-differences`). + * - ``tril`` and ``triu`` require the input to be at least 2-D. + - **Strictness** + - + * - finfo() return type uses ``float`` for the various attributes. + - **Strictness** + - The spec allows duck typing, so ``finfo`` returning dtype + scalars is considered type compatible with ``float``. + * - Positional arguments in every function are positional-only. + - **Breaking** + - See the spec for the exact signature of each function. Note that NumPy + ufuncs already use positional-only arguments, but non-ufuncs like + ``asarray`` generally do not. diff --git a/doc/source/reference/arrays.classes.rst b/doc/source/reference/arrays.classes.rst index 92c271f6b964..2f40423eeea5 100644 --- a/doc/source/reference/arrays.classes.rst +++ b/doc/source/reference/arrays.classes.rst @@ -7,7 +7,6 @@ Standard array subclasses .. currentmodule:: numpy .. for doctests - >>> import numpy as np >>> np.random.seed(1) .. note:: @@ -42,6 +41,7 @@ however, of why your subroutine may not be able to handle an arbitrary subclass of an array is that matrices redefine the "*" operator to be matrix-multiplication, rather than element-by-element multiplication. +.. _special-attributes-and-methods: Special attributes and methods ============================== diff --git a/doc/source/reference/arrays.datetime.rst b/doc/source/reference/arrays.datetime.rst index 63c93821b6b4..356ccce337a5 100644 --- a/doc/source/reference/arrays.datetime.rst +++ b/doc/source/reference/arrays.datetime.rst @@ -9,23 +9,51 @@ Datetimes and Timedeltas .. versionadded:: 1.7.0 Starting in NumPy 1.7, there are core array data types which natively -support datetime functionality. The data type is called "datetime64", -so named because "datetime" is already taken by the datetime library -included in Python. +support datetime functionality. The data type is called :class:`datetime64`, +so named because :class:`~datetime.datetime` is already taken by the Python standard library. + +Datetime64 Conventions and Assumptions +====================================== + +Similar to the Python `~datetime.date` class, dates are expressed in the current +Gregorian Calendar, indefinitely extended both in the future and in the past. +[#]_ Contrary to Python `~datetime.date`, which supports only years in the 1 AD — 9999 +AD range, `datetime64` allows also for dates BC; years BC follow the `Astronomical +year numbering `_ +convention, i.e. year 2 BC is numbered −1, year 1 BC is numbered 0, year 1 AD is +numbered 1. + +Time instants, say 16:23:32.234, are represented counting hours, minutes, +seconds and fractions from midnight: i.e. 00:00:00.000 is midnight, 12:00:00.000 +is noon, etc. Each calendar day has exactly 86400 seconds. This is a "naive" +time, with no explicit notion of timezones or specific time scales (UT1, UTC, TAI, +etc.). [#]_ + +.. [#] The calendar obtained by extending the Gregorian calendar before its + official adoption on Oct. 15, 1582 is called `Proleptic Gregorian Calendar + `_ + +.. [#] The assumption of 86400 seconds per calendar day is not valid for UTC, + the present day civil time scale. In fact due to the presence of + `leap seconds `_ on rare occasions + a day may be 86401 or 86399 seconds long. On the contrary the 86400s day + assumption holds for the TAI timescale. An explicit support for TAI and + TAI to UTC conversion, accounting for leap seconds, is proposed but not + yet implemented. See also the `shortcomings`_ section below. Basic Datetimes =============== -The most basic way to create datetimes is from strings in ISO 8601 date -or datetime format. It is also possible to create datetimes from an integer by +The most basic way to create datetimes is from strings in ISO 8601 date +or datetime format. It is also possible to create datetimes from an integer by offset relative to the Unix epoch (00:00:00 UTC on 1 January 1970). -The unit for internal storage is automatically selected from the +The unit for internal storage is automatically selected from the form of the string, and can be either a :ref:`date unit ` or a :ref:`time unit `. The date units are years ('Y'), months ('M'), weeks ('W'), and days ('D'), while the time units are hours ('h'), minutes ('m'), seconds ('s'), milliseconds ('ms'), and -some additional SI-prefix seconds-based units. The datetime64 data type +some additional SI-prefix seconds-based units. The `datetime64` data type also accepts the string "NAT", in any combination of lowercase/uppercase letters, for a "Not A Time" value. @@ -35,11 +63,11 @@ letters, for a "Not A Time" value. >>> np.datetime64('2005-02-25') numpy.datetime64('2005-02-25') - + From an integer and a date unit, 1 year since the UNIX epoch: >>> np.datetime64(1, 'Y') - numpy.datetime64('1971') + numpy.datetime64('1971') Using months for the unit: @@ -122,19 +150,19 @@ because the moment of time is still being represented exactly. NumPy does not store timezone information. For backwards compatibility, datetime64 still parses timezone offsets, which it handles by converting to - UTC. This behaviour is deprecated and will raise an error in the + UTC±00:00 (Zulu time). This behaviour is deprecated and will raise an error in the future. Datetime and Timedelta Arithmetic ================================= -NumPy allows the subtraction of two Datetime values, an operation which +NumPy allows the subtraction of two datetime values, an operation which produces a number with a time unit. Because NumPy doesn't have a physical -quantities system in its core, the timedelta64 data type was created -to complement datetime64. The arguments for timedelta64 are a number, +quantities system in its core, the `timedelta64` data type was created +to complement `datetime64`. The arguments for `timedelta64` are a number, to represent the number of units, and a date/time unit, such as -(D)ay, (M)onth, (Y)ear, (h)ours, (m)inutes, or (s)econds. The timedelta64 +(D)ay, (M)onth, (Y)ear, (h)ours, (m)inutes, or (s)econds. The `timedelta64` data type also accepts the string "NAT" in place of the number for a "Not A Time" value. .. admonition:: Example @@ -199,9 +227,8 @@ The Datetime and Timedelta data types support a large number of time units, as well as generic units which can be coerced into any of the other units based on input data. -Datetimes are always stored based on POSIX time (though having a TAI -mode which allows for accounting of leap-seconds is proposed), with -an epoch of 1970-01-01T00:00Z. This means the supported dates are +Datetimes are always stored with +an epoch of 1970-01-01T00:00. This means the supported dates are always a symmetric interval around the epoch, called "time span" in the table below. @@ -327,8 +354,8 @@ an object :class:`busdaycalendar` which stores the data necessary in an optimized form. np.is_busday(): -``````````````` -To test a datetime64 value to see if it is a valid day, use :func:`is_busday`. +--------------- +To test a `datetime64` value to see if it is a valid day, use :func:`is_busday`. .. admonition:: Example @@ -343,7 +370,7 @@ To test a datetime64 value to see if it is a valid day, use :func:`is_busday`. array([ True, True, True, True, True, False, False]) np.busday_count(): -`````````````````` +------------------ To find how many valid days there are in a specified range of datetime64 dates, use :func:`busday_count`: @@ -384,3 +411,69 @@ Some examples:: weekmask = "Mon Tue Wed Thu Fri" # any amount of whitespace is allowed; abbreviations are case-sensitive. weekmask = "MonTue Wed Thu\tFri" + + +.. _shortcomings: + +Datetime64 shortcomings +======================= + +The assumption that all days are exactly 86400 seconds long makes `datetime64` +largely compatible with Python `datetime` and "POSIX time" semantics; therefore +they all share the same well known shortcomings with respect to the UTC +timescale and historical time determination. A brief non exhaustive summary is +given below. + +- It is impossible to parse valid UTC timestamps occurring during a positive + leap second. + + .. admonition:: Example + + "2016-12-31 23:59:60 UTC" was a leap second, therefore "2016-12-31 + 23:59:60.450 UTC" is a valid timestamp which is not parseable by + `datetime64`: + + >>> np.datetime64("2016-12-31 23:59:60.450") + Traceback (most recent call last): + File "", line 1, in + ValueError: Seconds out of range in datetime string "2016-12-31 23:59:60.450" + +- Timedelta64 computations between two UTC dates can be wrong by an integer + number of SI seconds. + + .. admonition:: Example + + Compute the number of SI seconds between "2021-01-01 12:56:23.423 UTC" and + "2001-01-01 00:00:00.000 UTC": + + >>> ( + ... np.datetime64("2021-01-01 12:56:23.423") + ... - np.datetime64("2001-01-01") + ... ) / np.timedelta64(1, "s") + 631198583.423 + + however correct answer is `631198588.423` SI seconds because there were 5 + leap seconds between 2001 and 2021. + +- Timedelta64 computations for dates in the past do not return SI seconds, as + one would expect. + + .. admonition:: Example + + Compute the number of seconds between "000-01-01 UT" and "1600-01-01 UT", + where UT is `universal time + `_: + + >>> a = np.datetime64("0000-01-01", "us") + >>> b = np.datetime64("1600-01-01", "us") + >>> b - a + numpy.timedelta64(50491123200000000,'us') + + The computed results, `50491123200` seconds, is obtained as the elapsed + number of days (`584388`) times `86400` seconds; this is the number of + seconds of a clock in sync with earth rotation. The exact value in SI + seconds can only be estimated, e.g using data published in `Measurement of + the Earth's rotation: 720 BC to AD 2015, 2016, Royal Society's Proceedings + A 472, by Stephenson et.al. `_. A + sensible estimate is `50491112870 ± 90` seconds, with a difference of 10330 + seconds. diff --git a/doc/source/reference/arrays.indexing.rst b/doc/source/reference/arrays.indexing.rst index 100d22e029d0..1e413469115c 100644 --- a/doc/source/reference/arrays.indexing.rst +++ b/doc/source/reference/arrays.indexing.rst @@ -68,3 +68,4 @@ Iterating over arrays nested_iters flatiter lib.Arrayterator + iterable diff --git a/doc/source/reference/arrays.interface.rst b/doc/source/reference/arrays.interface.rst index 6a8c5f9c4d09..74432c8a7d2e 100644 --- a/doc/source/reference/arrays.interface.rst +++ b/doc/source/reference/arrays.interface.rst @@ -4,18 +4,18 @@ .. _arrays.interface: -******************* -The Array Interface -******************* +**************************** +The array interface protocol +**************************** .. note:: - This page describes the numpy-specific API for accessing the contents of - a numpy array from other C extensions. :pep:`3118` -- + This page describes the NumPy-specific API for accessing the contents of + a NumPy array from other C extensions. :pep:`3118` -- :c:func:`The Revised Buffer Protocol ` introduces similar, standardized API to Python 2.6 and 3.0 for any extension module to use. Cython__'s buffer array support - uses the :pep:`3118` API; see the `Cython numpy + uses the :pep:`3118` API; see the `Cython NumPy tutorial`__. Cython provides a way to write code that supports the buffer protocol with Python versions older than 2.6 because it has a backward-compatible implementation utilizing the array interface @@ -81,7 +81,8 @@ This approach to the interface consists of the object having an ===== ================================================================ ``t`` Bit field (following integer gives the number of bits in the bit field). - ``b`` Boolean (integer type where all values are only True or False) + ``b`` Boolean (integer type where all values are only ``True`` or + ``False``) ``i`` Integer ``u`` Unsigned integer ``f`` Floating point @@ -90,7 +91,7 @@ This approach to the interface consists of the object having an ``M`` Datetime ``O`` Object (i.e. the memory contains a pointer to :c:type:`PyObject`) ``S`` String (fixed-length sequence of char) - ``U`` Unicode (fixed-length sequence of :c:type:`Py_UNICODE`) + ``U`` Unicode (fixed-length sequence of :c:type:`Py_UCS4`) ``V`` Other (void \* -- each item is a fixed-size chunk of memory) ===== ================================================================ @@ -124,9 +125,15 @@ This approach to the interface consists of the object having an **Default**: ``[('', typestr)]`` **data** (optional) - A 2-tuple whose first argument is an integer (a long integer - if necessary) that points to the data-area storing the array - contents. This pointer must point to the first element of + A 2-tuple whose first argument is a :doc:`Python integer ` + that points to the data-area storing the array contents. + + .. note:: + When converting from C/C++ via ``PyLong_From*`` or high-level + bindings such as Cython or pybind11, make sure to use an integer + of sufficiently large bitness. + + This pointer must point to the first element of data (in other words any offset is always ignored in this case). The second entry in the tuple is a read-only flag (true means the data area is read-only). @@ -141,11 +148,11 @@ This approach to the interface consists of the object having an must be stored by the new object if the memory area is to be secured. - **Default**: None + **Default**: ``None`` **strides** (optional) Either ``None`` to indicate a C-style contiguous array or - a Tuple of strides which provides the number of bytes needed + a tuple of strides which provides the number of bytes needed to jump to the next array element in the corresponding dimension. Each entry must be an integer (a Python :py:class:`int`). As with shape, the values may @@ -156,26 +163,26 @@ This approach to the interface consists of the object having an memory buffer. In this model, the last dimension of the array varies the fastest. For example, the default strides tuple for an object whose array entries are 8 bytes long and whose - shape is ``(10, 20, 30)`` would be ``(4800, 240, 8)`` + shape is ``(10, 20, 30)`` would be ``(4800, 240, 8)``. **Default**: ``None`` (C-style contiguous) **mask** (optional) - None or an object exposing the array interface. All + ``None`` or an object exposing the array interface. All elements of the mask array should be interpreted only as true or not true indicating which elements of this array are valid. The shape of this object should be `"broadcastable" ` to the shape of the original array. - **Default**: None (All array values are valid) + **Default**: ``None`` (All array values are valid) **offset** (optional) An integer offset into the array data region. This can only be used when data is ``None`` or returns a :class:`buffer` object. - **Default**: 0. + **Default**: ``0``. **version** (required) An integer showing the version of the interface (i.e. 3 for @@ -243,6 +250,12 @@ flag is present. returning the :c:type:`PyCapsule`, and configure a destructor to decref this reference. +.. note:: + + :obj:`__array_struct__` is considered legacy and should not be used for new + code. Use the :doc:`buffer protocol ` or the DLPack protocol + `numpy.from_dlpack` instead. + Type description examples ========================= diff --git a/doc/source/reference/arrays.ndarray.rst b/doc/source/reference/arrays.ndarray.rst index 0f703b4754de..5d467d9d9fa6 100644 --- a/doc/source/reference/arrays.ndarray.rst +++ b/doc/source/reference/arrays.ndarray.rst @@ -54,13 +54,13 @@ objects implementing the :class:`buffer` or :ref:`array >>> y = x[:,1] >>> y - array([2, 5]) + array([2, 5], dtype=int32) >>> y[0] = 9 # this also changes the corresponding element in x >>> y - array([9, 5]) + array([9, 5], dtype=int32) >>> x array([[1, 9, 3], - [4, 5, 6]]) + [4, 5, 6]], dtype=int32) Constructing arrays @@ -161,28 +161,17 @@ An array is considered aligned if the memory offsets for all elements and the base offset itself is a multiple of `self.itemsize`. Understanding `memory-alignment` leads to better performance on most hardware. -.. note:: - - Points (1) and (2) can currently be disabled by the compile time - environmental variable ``NPY_RELAXED_STRIDES_CHECKING=0``, - which was the default before NumPy 1.10. - No users should have to do this. ``NPY_RELAXED_STRIDES_DEBUG=1`` - can be used to help find errors when incorrectly relying on the strides - in C-extension code (see below warning). - - You can check whether this option was enabled when your NumPy was - built by looking at the value of ``np.ones((10,1), - order='C').flags.f_contiguous``. If this is ``True``, then your - NumPy has relaxed strides checking enabled. - .. warning:: It does *not* generally hold that ``self.strides[-1] == self.itemsize`` for C-style contiguous arrays or ``self.strides[0] == self.itemsize`` for Fortran-style contiguous arrays is true. -Data in new :class:`ndarrays ` is in the :term:`row-major` -(C) order, unless otherwise specified, but, for example, :ref:`basic + ``NPY_RELAXED_STRIDES_DEBUG=1`` can be used to help find errors when + incorrectly relying on the strides in C-extension code (see below warning). + +Data in new :class:`ndarrays ` is in the :term:`row-major` (C) +order, unless otherwise specified, but, for example, :ref:`basic array slicing ` often produces :term:`views ` in a different scheme. diff --git a/doc/source/reference/arrays.nditer.cython.rst b/doc/source/reference/arrays.nditer.cython.rst index 43aad99275c7..66485fc8a449 100644 --- a/doc/source/reference/arrays.nditer.cython.rst +++ b/doc/source/reference/arrays.nditer.cython.rst @@ -49,7 +49,7 @@ Here's how this looks. ... >>> a = np.arange(6).reshape(2,3) >>> sum_squares_py(a) - array(55.0) + array(55.) >>> sum_squares_py(a, axis=-1) array([ 5., 50.]) @@ -117,11 +117,11 @@ as our native Python/NumPy code did. .. admonition:: Example - >>> from sum_squares import sum_squares_cy + >>> from sum_squares import sum_squares_cy #doctest: +SKIP >>> a = np.arange(6).reshape(2,3) - >>> sum_squares_cy(a) + >>> sum_squares_cy(a) #doctest: +SKIP array(55.0) - >>> sum_squares_cy(a, axis=-1) + >>> sum_squares_cy(a, axis=-1) #doctest: +SKIP array([ 5., 50.]) Doing a little timing in IPython shows that the reduced overhead and diff --git a/doc/source/reference/arrays.nditer.rst b/doc/source/reference/arrays.nditer.rst index 72a04f73e8d1..8cabc1a061a6 100644 --- a/doc/source/reference/arrays.nditer.rst +++ b/doc/source/reference/arrays.nditer.rst @@ -1,9 +1,5 @@ .. currentmodule:: numpy -.. for doctests - The last section on Cython is 'included' at the end of this file. The tests - for that section are disabled. - .. _arrays.nditer: ********************* @@ -489,9 +485,9 @@ reasons. >>> b = np.zeros((3,)) >>> square([1,2,3], out=b) - array([ 1., 4., 9.]) + array([1., 4., 9.]) >>> b - array([ 1., 4., 9.]) + array([1., 4., 9.]) >>> square(np.arange(6).reshape(2,3), out=b) Traceback (most recent call last): diff --git a/doc/source/reference/arrays.scalars.rst b/doc/source/reference/arrays.scalars.rst index c691e802ffd0..30d7be9f918e 100644 --- a/doc/source/reference/arrays.scalars.rst +++ b/doc/source/reference/arrays.scalars.rst @@ -102,7 +102,7 @@ Python Boolean scalar. :exclude-members: __init__ Integer types -~~~~~~~~~~~~~ +------------- .. autoclass:: numpy.integer :members: __init__ @@ -114,7 +114,7 @@ Integer types be subject to :ref:`overflow-errors`. Signed integer types -++++++++++++++++++++ +~~~~~~~~~~~~~~~~~~~~ .. autoclass:: numpy.signedinteger :members: __init__ @@ -141,7 +141,7 @@ Signed integer types :exclude-members: __init__ Unsigned integer types -++++++++++++++++++++++ +~~~~~~~~~~~~~~~~~~~~~~ .. autoclass:: numpy.unsignedinteger :members: __init__ @@ -168,7 +168,7 @@ Unsigned integer types :exclude-members: __init__ Inexact types -~~~~~~~~~~~~~ +------------- .. autoclass:: numpy.inexact :members: __init__ @@ -209,7 +209,7 @@ Inexact types (0.1, 0.1, 0.1) Floating-point types -++++++++++++++++++++ +~~~~~~~~~~~~~~~~~~~~ .. autoclass:: numpy.floating :members: __init__ @@ -232,7 +232,7 @@ Floating-point types :exclude-members: __init__ Complex floating-point types -++++++++++++++++++++++++++++ +~~~~~~~~~~~~~~~~~~~~~~~~~~~~ .. autoclass:: numpy.complexfloating :members: __init__ @@ -251,7 +251,7 @@ Complex floating-point types :exclude-members: __init__ Other types -~~~~~~~~~~~ +----------- .. autoclass:: numpy.bool_ :members: __init__ @@ -321,7 +321,7 @@ elements the data type consists of.) .. _sized-aliases: Sized aliases -~~~~~~~~~~~~~ +------------- Along with their (mostly) C-derived names, the integer, float, and complex data-types are also @@ -402,7 +402,7 @@ are also provided. The existence of these aliases depends on the platform. Other aliases -~~~~~~~~~~~~~ +------------- The first two of these are conveniences which resemble the names of the builtin types, in the same style as `bool_`, `int_`, `str_`, `bytes_`, and diff --git a/doc/source/reference/c-api/array.rst b/doc/source/reference/c-api/array.rst index bb440582548c..8772b494cf7d 100644 --- a/doc/source/reference/c-api/array.rst +++ b/doc/source/reference/c-api/array.rst @@ -127,8 +127,7 @@ and its sub-types). your own memory, you should use the function :c:func:`PyArray_SetBaseObject` to set the base to an object which owns the memory. - If the (deprecated) :c:data:`NPY_ARRAY_UPDATEIFCOPY` or the - :c:data:`NPY_ARRAY_WRITEBACKIFCOPY` flags are set, it has a different + If the :c:data:`NPY_ARRAY_WRITEBACKIFCOPY` flag is set, it has a different meaning, namely base is the array into which the current array will be copied upon copy resolution. This overloading of the base property for two functions is likely to change in a future version of NumPy. @@ -153,7 +152,7 @@ and its sub-types). .. c:function:: int PyArray_FinalizeFunc(PyArrayObject* arr, PyObject* obj) - The function pointed to by the CObject + The function pointed to by the :c:type:`PyCapsule` :obj:`~numpy.class.__array_finalize__`. The first argument is the newly created sub-type. The second argument (if not NULL) is the "parent" array (if the array was created using @@ -163,7 +162,7 @@ and its sub-types). Data access -^^^^^^^^^^^ +~~~~~~~~~~~ These functions and macros provide easy access to elements of the ndarray from C. These work for all arrays. You may need to take care @@ -209,7 +208,7 @@ Creating arrays From scratch -^^^^^^^^^^^^ +~~~~~~~~~~~~ .. c:function:: PyObject* PyArray_NewFromDescr( \ PyTypeObject* subtype, PyArray_Descr* descr, int nd, npy_intp const* dims, \ @@ -237,8 +236,7 @@ From scratch If *data* is not ``NULL``, then it is assumed to point to the memory to be used for the array and the *flags* argument is used as the new flags for the array (except the state of :c:data:`NPY_ARRAY_OWNDATA`, - :c:data:`NPY_ARRAY_WRITEBACKIFCOPY` and :c:data:`NPY_ARRAY_UPDATEIFCOPY` - flags of the new array will be reset). + :c:data:`NPY_ARRAY_WRITEBACKIFCOPY` flag of the new array will be reset). In addition, if *data* is non-NULL, then *strides* can also be provided. If *strides* is ``NULL``, then the array strides @@ -406,7 +404,7 @@ From scratch to another value. From other objects -^^^^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~~~~ .. c:function:: PyObject* PyArray_FromAny( \ PyObject* op, PyArray_Descr* dtype, int min_depth, int max_depth, \ @@ -487,13 +485,6 @@ From other objects will be made writeable again. If *op* is not writeable to begin with, or if it is not already an array, then an error is raised. - .. c:macro:: NPY_ARRAY_UPDATEIFCOPY - - Deprecated. Use :c:data:`NPY_ARRAY_WRITEBACKIFCOPY`, which is similar. - This flag "automatically" copies the data back when the returned - array is deallocated, which is not supported in all python - implementations. - .. c:macro:: NPY_ARRAY_BEHAVED :c:data:`NPY_ARRAY_ALIGNED` \| :c:data:`NPY_ARRAY_WRITEABLE` @@ -550,14 +541,12 @@ From other objects .. c:macro:: NPY_ARRAY_INOUT_ARRAY :c:data:`NPY_ARRAY_C_CONTIGUOUS` \| :c:data:`NPY_ARRAY_WRITEABLE` \| - :c:data:`NPY_ARRAY_ALIGNED` \| :c:data:`NPY_ARRAY_WRITEBACKIFCOPY` \| - :c:data:`NPY_ARRAY_UPDATEIFCOPY` + :c:data:`NPY_ARRAY_ALIGNED` \| :c:data:`NPY_ARRAY_WRITEBACKIFCOPY` .. c:macro:: NPY_ARRAY_INOUT_FARRAY :c:data:`NPY_ARRAY_F_CONTIGUOUS` \| :c:data:`NPY_ARRAY_WRITEABLE` \| - :c:data:`NPY_ARRAY_ALIGNED` \| :c:data:`NPY_ARRAY_WRITEBACKIFCOPY` \| - :c:data:`NPY_ARRAY_UPDATEIFCOPY` + :c:data:`NPY_ARRAY_ALIGNED` \| :c:data:`NPY_ARRAY_WRITEBACKIFCOPY` .. c:function:: int PyArray_GetArrayParamsFromObject( \ PyObject* op, PyArray_Descr* requested_dtype, npy_bool writeable, \ @@ -773,8 +762,7 @@ From other objects :c:data:`NPY_ARRAY_C_CONTIGUOUS`, :c:data:`NPY_ARRAY_F_CONTIGUOUS`, :c:data:`NPY_ARRAY_ALIGNED`, :c:data:`NPY_ARRAY_WRITEABLE`, :c:data:`NPY_ARRAY_NOTSWAPPED`, :c:data:`NPY_ARRAY_ENSURECOPY`, - :c:data:`NPY_ARRAY_WRITEBACKIFCOPY`, :c:data:`NPY_ARRAY_UPDATEIFCOPY`, - :c:data:`NPY_ARRAY_FORCECAST`, and + :c:data:`NPY_ARRAY_WRITEBACKIFCOPY`, :c:data:`NPY_ARRAY_FORCECAST`, and :c:data:`NPY_ARRAY_ENSUREARRAY`. Standard combinations of flags can also be used: @@ -817,7 +805,7 @@ Dealing with types General check of Python Type -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~~~~~~~~~~~~~~ .. c:function:: int PyArray_Check(PyObject *op) @@ -889,7 +877,7 @@ General check of Python Type Data-type checking -^^^^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~~~~ For the typenum macros, the argument is an integer representing an enumerated array data type. For the array type checking macros the @@ -1060,7 +1048,7 @@ argument must be a :c:expr:`PyObject *` that can be directly interpreted as a Converting data types -^^^^^^^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~~~~~~~ .. c:function:: PyObject* PyArray_Cast(PyArrayObject* arr, int typenum) @@ -1280,7 +1268,7 @@ Converting data types User-defined data types -^^^^^^^^^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~~~~~~~~~ .. c:function:: void PyArray_InitArrFuncs(PyArray_ArrFuncs* f) @@ -1333,7 +1321,30 @@ User-defined data types Only works for user-defined data-types. Special functions for NPY_OBJECT -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +.. warning:: + + When working with arrays or buffers filled with objects NumPy tries to + ensure such buffers are filled with ``None`` before any data may be read. + However, code paths may existed where an array is only initialized to + ``NULL``. + NumPy itself accepts ``NULL`` as an alias for ``None``, but may ``assert`` + non-``NULL`` when compiled in debug mode. + + Because NumPy is not yet consistent about initialization with None, + users **must** expect a value of ``NULL`` when working with buffers created + by NumPy. Users **should** also ensure to pass fully initialized buffers + to NumPy, since NumPy may make this a strong requirement in the future. + + There is currently an intention to ensure that NumPy always initializes + object arrays before they may be read. Any failure to do so will be + regarded as a bug. + In the future, users may be able to rely on non-NULL values when reading + from any array, although exceptions for writing to freshly created arrays + may remain (e.g. for output arrays in ufunc code). As of NumPy 1.23 + known code paths exists where proper filling is not done. + .. c:function:: int PyArray_INCREF(PyArrayObject* op) @@ -1375,15 +1386,6 @@ Special functions for NPY_OBJECT decrement all the items in the object array prior to calling this function. -.. c:function:: int PyArray_SetUpdateIfCopyBase(PyArrayObject* arr, PyArrayObject* base) - - Precondition: ``arr`` is a copy of ``base`` (though possibly with different - strides, ordering, etc.) Set the UPDATEIFCOPY flag and ``arr->base`` so - that when ``arr`` is destructed, it will copy any changes back to ``base``. - DEPRECATED, use :c:func:`PyArray_SetWritebackIfCopyBase`. - - Returns 0 for success, -1 for failure. - .. c:function:: int PyArray_SetWritebackIfCopyBase(PyArrayObject* arr, PyArrayObject* base) Precondition: ``arr`` is a copy of ``base`` (though possibly with different @@ -1420,7 +1422,7 @@ PyArray_FromAny function. Basic Array Flags -^^^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~~~ An ndarray can have a data segment that is not a simple contiguous chunk of well-behaved memory you can manipulate. It may not be aligned @@ -1496,14 +1498,6 @@ of the constant names is deprecated in 1.7. would have returned an error because :c:data:`NPY_ARRAY_WRITEBACKIFCOPY` would not have been possible. -.. c:macro:: NPY_ARRAY_UPDATEIFCOPY - - A deprecated version of :c:data:`NPY_ARRAY_WRITEBACKIFCOPY` which - depends upon ``dealloc`` to trigger the writeback. For backwards - compatibility, :c:func:`PyArray_ResolveWritebackIfCopy` is called at - ``dealloc`` but relying - on that behavior is deprecated and not supported in PyPy. - :c:func:`PyArray_UpdateFlags` (obj, flags) will update the ``obj->flags`` for ``flags`` which can be any of :c:data:`NPY_ARRAY_C_CONTIGUOUS`, :c:data:`NPY_ARRAY_F_CONTIGUOUS`, :c:data:`NPY_ARRAY_ALIGNED`, or @@ -1511,7 +1505,7 @@ for ``flags`` which can be any of :c:data:`NPY_ARRAY_C_CONTIGUOUS`, Combinations of array flags -^^^^^^^^^^^^^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~~~~~~~~~~~~~ .. c:macro:: NPY_ARRAY_BEHAVED @@ -1543,7 +1537,7 @@ Combinations of array flags Flag-like constants -^^^^^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~~~~~ These constants are used in :c:func:`PyArray_FromAny` (and its macro forms) to specify desired properties of the new array. @@ -1563,7 +1557,7 @@ specify desired properties of the new array. Flag checking -^^^^^^^^^^^^^ +~~~~~~~~~~~~~ For all of these macros *arr* must be an instance of a (subclass of) :c:data:`PyArray_Type`. @@ -1575,8 +1569,7 @@ For all of these macros *arr* must be an instance of a (subclass of) combinations of the possible flags an array can have: :c:data:`NPY_ARRAY_C_CONTIGUOUS`, :c:data:`NPY_ARRAY_F_CONTIGUOUS`, :c:data:`NPY_ARRAY_OWNDATA`, :c:data:`NPY_ARRAY_ALIGNED`, - :c:data:`NPY_ARRAY_WRITEABLE`, :c:data:`NPY_ARRAY_WRITEBACKIFCOPY`, - :c:data:`NPY_ARRAY_UPDATEIFCOPY`. + :c:data:`NPY_ARRAY_WRITEABLE`, :c:data:`NPY_ARRAY_WRITEBACKIFCOPY`. .. c:function:: int PyArray_IS_C_CONTIGUOUS(PyObject *arr) @@ -1653,13 +1646,24 @@ For all of these macros *arr* must be an instance of a (subclass of) calculations in NumPy that rely on the state of these flags do not repeat the calculation to update them. +.. c:function:: int PyArray_FailUnlessWriteable(PyArrayObject *obj, const char *name) + + This function does nothing and returns 0 if *obj* is writeable. + It raises an exception and returns -1 if *obj* is not writeable. + It may also do other house-keeping, such as issuing warnings on + arrays which are transitioning to become views. Always call this + function at some point before writing to an array. + + *name* is a name for the array, used to give better error messages. + It can be something like "assignment destination", "output array", + or even just "array". Array method alternative API ---------------------------- Conversion -^^^^^^^^^^ +~~~~~~~~~~ .. c:function:: PyObject* PyArray_GetField( \ PyArrayObject* self, PyArray_Descr* dtype, int offset) @@ -1768,7 +1772,7 @@ Conversion Shape Manipulation -^^^^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~~~~ .. c:function:: PyObject* PyArray_Newshape( \ PyArrayObject* self, PyArray_Dims* newshape, NPY_ORDER order) @@ -1852,7 +1856,7 @@ Shape Manipulation Item selection and manipulation -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ .. c:function:: PyObject* PyArray_TakeFrom( \ PyArrayObject* self, PyObject* indices, int axis, PyArrayObject* ret, \ @@ -2032,7 +2036,7 @@ Item selection and manipulation Calculation -^^^^^^^^^^^ +~~~~~~~~~~~ .. tip:: @@ -2192,11 +2196,11 @@ Functions Array Functions -^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~ .. c:function:: int PyArray_AsCArray( \ - PyObject** op, void* ptr, npy_intp* dims, int nd, int typenum, \ - int itemsize) + PyObject** op, void* ptr, npy_intp* dims, int nd, \ + PyArray_Descr* typedescr) Sometimes it is useful to access a multidimensional array as a C-style multi-dimensional array so that algorithms can be @@ -2226,14 +2230,11 @@ Array Functions The dimensionality of the array (1, 2, or 3). - :param typenum: - - The expected data type of the array. - - :param itemsize: + :param typedescr: - This argument is only needed when *typenum* represents a - flexible array. Otherwise it should be 0. + A :c:type:`PyArray_Descr` structure indicating the desired data-type + (including required byteorder). The call will steal a reference to + the parameter. .. note:: @@ -2346,7 +2347,7 @@ Array Functions Other functions -^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~ .. c:function:: npy_bool PyArray_CheckStrides( \ int elsize, int nd, npy_intp numbytes, npy_intp const* dims, \ @@ -2765,7 +2766,7 @@ Array mapping is the machinery behind advanced indexing. has memory overlap with any of the arrays in ``index`` and with ``extra_op``, and make copies as appropriate to avoid problems if the input is modified during the iteration. ``iter->array`` may contain a - copied array (UPDATEIFCOPY/WRITEBACKIFCOPY set). + copied array (WRITEBACKIFCOPY set). Array Scalars ------------- @@ -2991,7 +2992,7 @@ Conversion Utilities For use with :c:func:`PyArg_ParseTuple` -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ All of these functions can be used in :c:func:`PyArg_ParseTuple` (...) with the "O&" format specifier to automatically convert any Python object @@ -3046,14 +3047,14 @@ to. structure with base, ptr, len, and flags members. The :c:type:`PyArray_Chunk` structure is binary compatible with the Python's buffer object (through its len member on 32-bit platforms - and its ptr member on 64-bit platforms or in Python 2.5). On - return, the base member is set to *obj* (or its base if *obj* is - already a buffer object pointing to another object). If you need - to hold on to the memory be sure to INCREF the base member. The - chunk of memory is pointed to by *buf* ->ptr member and has length - *buf* ->len. The flags member of *buf* is :c:data:`NPY_ARRAY_ALIGNED` - with the :c:data:`NPY_ARRAY_WRITEABLE` flag set if *obj* has - a writeable buffer interface. + and its ptr member on 64-bit platforms). On return, the base member + is set to *obj* (or its base if *obj* is already a buffer object + pointing to another object). If you need to hold on to the memory + be sure to INCREF the base member. The chunk of memory is pointed + to by *buf* ->ptr member and has length *buf* ->len. The flags + member of *buf* is :c:data:`NPY_ARRAY_ALIGNED` with the + :c:data:`NPY_ARRAY_WRITEABLE` flag set if *obj* has a writeable + buffer interface. .. c:function:: int PyArray_AxisConverter(PyObject* obj, int* axis) @@ -3119,7 +3120,7 @@ to. to help functions allow a different clipmode for each dimension. Other conversions -^^^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~~~ .. c:function:: int PyArray_PyIntAsInt(PyObject* op) @@ -3160,7 +3161,7 @@ Miscellaneous Importing the API -^^^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~~~ In order to make use of the C-API from another extension module, the :c:func:`import_array` function must be called. If the extension module is @@ -3231,7 +3232,7 @@ the C-API is needed then some additional steps must be taken. #defined to. Checking the API Version -^^^^^^^^^^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~~~~~~~~~~ Because python extensions are not used in the same way as usual libraries on most platforms, some errors cannot be automatically detected at build time or @@ -3286,7 +3287,7 @@ extension with the lowest :c:data:`NPY_FEATURE_VERSION` as possible. function is added). A changed value does not always require a recompile. Internal Flexibility -^^^^^^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~~~~~~ .. c:function:: int PyArray_SetNumericOps(PyObject* dict) @@ -3343,7 +3344,7 @@ Internal Flexibility Memory management -^^^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~~~ .. c:function:: char* PyDataMem_NEW(size_t nbytes) @@ -3377,8 +3378,8 @@ Memory management .. c:function:: int PyArray_ResolveWritebackIfCopy(PyArrayObject* obj) - If ``obj.flags`` has :c:data:`NPY_ARRAY_WRITEBACKIFCOPY` or (deprecated) - :c:data:`NPY_ARRAY_UPDATEIFCOPY`, this function clears the flags, `DECREF` s + If ``obj.flags`` has :c:data:`NPY_ARRAY_WRITEBACKIFCOPY`, this function + clears the flags, `DECREF` s `obj->base` and makes it writeable, and sets ``obj->base`` to NULL. It then copies ``obj->data`` to `obj->base->data`, and returns the error state of the copy operation. This is the opposite of @@ -3390,7 +3391,7 @@ Memory management Returns 0 if nothing was done, -1 on error, and 1 if action was taken. Threading support -^^^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~~~ These macros are only meaningful if :c:data:`NPY_ALLOW_THREADS` evaluates True during compilation of the extension module. Otherwise, @@ -3497,7 +3498,7 @@ Group 2 Priority -^^^^^^^^ +~~~~~~~~ .. c:macro:: NPY_PRIORITY @@ -3520,7 +3521,7 @@ Priority Default buffers -^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~ .. c:macro:: NPY_BUFSIZE @@ -3536,7 +3537,7 @@ Default buffers Other constants -^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~ .. c:macro:: NPY_NUM_FLOATTYPE @@ -3570,7 +3571,7 @@ Other constants Miscellaneous Macros -^^^^^^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~~~~~~ .. c:function:: int PyArray_SAMESHAPE(PyArrayObject *a1, PyArrayObject *a2) @@ -3609,8 +3610,8 @@ Miscellaneous Macros .. c:function:: void PyArray_DiscardWritebackIfCopy(PyObject* obj) - If ``obj.flags`` has :c:data:`NPY_ARRAY_WRITEBACKIFCOPY` or (deprecated) - :c:data:`NPY_ARRAY_UPDATEIFCOPY`, this function clears the flags, `DECREF` s + If ``obj.flags`` has :c:data:`NPY_ARRAY_WRITEBACKIFCOPY`, this function + clears the flags, `DECREF` s `obj->base` and makes it writeable, and sets ``obj->base`` to NULL. In contrast to :c:func:`PyArray_DiscardWritebackIfCopy` it makes no attempt to copy the data from `obj->base` This undoes @@ -3623,8 +3624,8 @@ Miscellaneous Macros Deprecated in 1.14, use :c:func:`PyArray_DiscardWritebackIfCopy` followed by ``Py_XDECREF`` - DECREF's an array object which may have the (deprecated) - :c:data:`NPY_ARRAY_UPDATEIFCOPY` or :c:data:`NPY_ARRAY_WRITEBACKIFCOPY` + DECREF's an array object which may have the + :c:data:`NPY_ARRAY_WRITEBACKIFCOPY` flag set without causing the contents to be copied back into the original array. Resets the :c:data:`NPY_ARRAY_WRITEABLE` flag on the base object. This is useful for recovering from an error condition when @@ -3632,7 +3633,7 @@ Miscellaneous Macros Enumerated Types -^^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~~ .. c:enum:: NPY_SORTKIND diff --git a/doc/source/reference/c-api/config.rst b/doc/source/reference/c-api/config.rst index 87130699bbf8..963a106f8a76 100644 --- a/doc/source/reference/c-api/config.rst +++ b/doc/source/reference/c-api/config.rst @@ -118,14 +118,3 @@ Compiler directives .. c:macro:: NPY_LIKELY .. c:macro:: NPY_UNLIKELY .. c:macro:: NPY_UNUSED - - -Interrupt Handling ------------------- - -.. c:macro:: NPY_INTERRUPT_H -.. c:macro:: NPY_SIGSETJMP -.. c:macro:: NPY_SIGLONGJMP -.. c:macro:: NPY_SIGJMP_BUF -.. c:macro:: NPY_SIGINT_ON -.. c:macro:: NPY_SIGINT_OFF diff --git a/doc/source/reference/c-api/coremath.rst b/doc/source/reference/c-api/coremath.rst index e129fdd7769b..eb0990edb2cd 100644 --- a/doc/source/reference/c-api/coremath.rst +++ b/doc/source/reference/c-api/coremath.rst @@ -3,8 +3,6 @@ NumPy core libraries .. sectionauthor:: David Cournapeau -.. versionadded:: 1.3.0 - Starting from numpy 1.3.0, we are working on separating the pure C, "computational" code from the python dependent code. The goal is twofolds: making the code cleaner, and enabling code reuse by other extensions outside @@ -16,10 +14,19 @@ NumPy core math library The numpy core math library ('npymath') is a first step in this direction. This library contains most math-related C99 functionality, which can be used on platforms where C99 is not well supported. The core math functions have the -same API as the C99 ones, except for the npy_* prefix. +same API as the C99 ones, except for the ``npy_*`` prefix. + +The available functions are defined in ```` - please refer to +this header when in doubt. + +.. note:: -The available functions are defined in - please refer to this header when -in doubt. + An effort is underway to make ``npymath`` smaller (since C99 compatibility + of compilers has improved over time) and more easily vendorable or usable as + a header-only dependency. That will avoid problems with shipping a static + library built with a compiler which may not match the compiler used by a + downstream package or end user. See + `gh-20880 `__ for details. Floating point classification ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -75,8 +82,6 @@ Floating point classification as y. Works for any value, including inf and nan. Single and extended precisions are available with suffix f and l. - .. versionadded:: 1.4.0 - Useful math constants ~~~~~~~~~~~~~~~~~~~~~ @@ -140,8 +145,6 @@ Those can be useful for precise floating point comparison. floating point value from x in the direction of y. Single and extended precisions are available with suffix f and l. - .. versionadded:: 1.4.0 - .. c:function:: double npy_spacing(double x) This is a function equivalent to Fortran intrinsic. Return distance between @@ -149,32 +152,22 @@ Those can be useful for precise floating point comparison. eps. spacing of nan and +/- inf return nan. Single and extended precisions are available with suffix f and l. - .. versionadded:: 1.4.0 - .. c:function:: void npy_set_floatstatus_divbyzero() Set the divide by zero floating point exception - .. versionadded:: 1.6.0 - .. c:function:: void npy_set_floatstatus_overflow() Set the overflow floating point exception - .. versionadded:: 1.6.0 - .. c:function:: void npy_set_floatstatus_underflow() Set the underflow floating point exception - .. versionadded:: 1.6.0 - .. c:function:: void npy_set_floatstatus_invalid() Set the invalid floating point exception - .. versionadded:: 1.6.0 - .. c:function:: int npy_get_floatstatus() Get floating point status. Returns a bitmask with following possible flags: @@ -188,8 +181,6 @@ Those can be useful for precise floating point comparison. aggressive compiler optimizations reordering the call relative to the code setting the status, which could lead to incorrect results. - .. versionadded:: 1.9.0 - .. c:function:: int npy_get_floatstatus_barrier(char*) Get floating point status. A pointer to a local variable is passed in to @@ -214,8 +205,6 @@ Those can be useful for precise floating point comparison. prevents aggressive compiler optimizations reordering the call relative to the code setting the status, which could lead to incorrect results. - .. versionadded:: 1.9.0 - .. c:function:: int npy_clear_floatstatus_barrier(char*) Clears the floating point status. A pointer to a local variable is passed in to @@ -227,11 +216,10 @@ Those can be useful for precise floating point comparison. Complex functions ~~~~~~~~~~~~~~~~~ -.. versionadded:: 1.4.0 - C99-like complex functions have been added. Those can be used if you wish to implement portable C extensions. Since we still support platforms without C99 -complex type, you need to restrict to C90-compatible syntax, e.g.: +complex type (most importantly Windows, where MSVC doesn't support C99 complex +types as of Nov 2022), you need to restrict to C90-compatible syntax, e.g.: .. code-block:: c @@ -241,13 +229,31 @@ complex type, you need to restrict to C90-compatible syntax, e.g.: b = npy_log(a); +.. _linking-npymath: + Linking against the core math library in an extension ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -.. versionadded:: 1.4.0 +To use the core math library that NumPy ships as a static library in your own +Python extension, you need to add the npymath compile and link options to your +extension. The exact steps to take will depend on the build system you are using. +The generic steps to take are: + +1. Add the numpy include directory (= the value of ``np.get_include()``) to + your include directories, +2. The ``npymath`` static library resides in the ``lib`` directory right next + to numpy's include directory (i.e., ``pathlib.Path(np.get_include()) / '..' + / 'lib'``). Add that to your library search directories, +3. Link with ``libnpymath`` and ``libm``. -To use the core math library in your own extension, you need to add the npymath -compile and link options to your extension in your setup.py: +.. note:: + + Keep in mind that when you are cross compiling, you must use the ``numpy`` + for the platform you are building for, not the native one for the build + machine. Otherwise you pick up a static library built for the wrong + architecture. + +When you build with ``numpy.distutils`` (deprecated), then use this in your ``setup.py``: .. hidden in a comment so as to be included in refguide but not rendered documentation >>> import numpy.distutils.misc_util @@ -258,15 +264,37 @@ compile and link options to your extension in your setup.py: >>> info = get_info('npymath') >>> _ = config.add_extension('foo', sources=['foo.c'], extra_info=info) -In other words, the usage of info is exactly the same as when using blas_info -and co. +In other words, the usage of ``info`` is exactly the same as when using +``blas_info`` and co. + +When you are building with `Meson `__, use:: + + # Note that this will get easier in the future, when Meson has + # support for numpy built in; most of this can then be replaced + # by `dependency('numpy')`. + incdir_numpy = run_command(py3, + [ + '-c', + 'import os; os.chdir(".."); import numpy; print(numpy.get_include())' + ], + check: true + ).stdout().strip() + + inc_np = include_directories(incdir_numpy) + + cc = meson.get_compiler('c') + npymath_path = incdir_numpy / '..' / 'lib' + npymath_lib = cc.find_library('npymath', dirs: npymath_path) + + py3.extension_module('module_name', + ... + include_directories: inc_np, + dependencies: [npymath_lib], Half-precision functions ~~~~~~~~~~~~~~~~~~~~~~~~ -.. versionadded:: 1.6.0 - -The header file provides functions to work with +The header file ```` provides functions to work with IEEE 754-2008 16-bit floating point values. While this format is not typically used for numerical computations, it is useful for storing values which require floating point but do not need much precision. @@ -281,7 +309,7 @@ between the different signed zeros, you will get -0.0 != 0.0 (0x8000 != 0x0000), which is incorrect. For these reasons, NumPy provides an API to work with npy_half values -accessible by including and linking to 'npymath'. +accessible by including ```` and linking to ``npymath``. For functions that are not provided directly, such as the arithmetic operations, the preferred method is to convert to float or double and back again, as in the following example. diff --git a/doc/source/reference/c-api/data_memory.rst b/doc/source/reference/c-api/data_memory.rst index b779026b4551..2084ab5d083f 100644 --- a/doc/source/reference/c-api/data_memory.rst +++ b/doc/source/reference/c-api/data_memory.rst @@ -20,8 +20,8 @@ Historical overview Since version 1.7.0, NumPy has exposed a set of ``PyDataMem_*`` functions (:c:func:`PyDataMem_NEW`, :c:func:`PyDataMem_FREE`, :c:func:`PyDataMem_RENEW`) which are backed by `alloc`, `free`, `realloc` respectively. In that version -NumPy also exposed the `PyDataMem_EventHook` function described below, which -wrap the OS-level calls. +NumPy also exposed the `PyDataMem_EventHook` function (now deprecated) +described below, which wrap the OS-level calls. Since those early days, Python also improved its memory management capabilities, and began providing @@ -50,10 +50,10 @@ management routines can use :c:func:`PyDataMem_SetHandler`, which uses a :c:type:`PyDataMem_Handler` structure to hold pointers to functions used to manage the data memory. The calls are still wrapped by internal routines to call :c:func:`PyTraceMalloc_Track`, :c:func:`PyTraceMalloc_Untrack`, and will -use the :c:func:`PyDataMem_EventHookFunc` mechanism. Since the functions may -change during the lifetime of the process, each ``ndarray`` carries with it the -functions used at the time of its instantiation, and these will be used to -reallocate or free the data memory of the instance. +use the deprecated :c:func:`PyDataMem_EventHookFunc` mechanism. Since the +functions may change during the lifetime of the process, each ``ndarray`` +carries with it the functions used at the time of its instantiation, and these +will be used to reallocate or free the data memory of the instance. .. c:type:: PyDataMem_Handler @@ -119,7 +119,9 @@ For an example of setting up and using the PyDataMem_Handler, see the test in thread. The hook should be written to be reentrant, if it performs operations that might cause new allocation events (such as the creation/destruction numpy objects, or creating/destroying Python - objects which might cause a gc) + objects which might cause a gc). + + Deprecated in v1.23 What happens when deallocating if there is no policy set -------------------------------------------------------- diff --git a/doc/source/reference/c-api/dtype.rst b/doc/source/reference/c-api/dtype.rst index 382e45dc0aa7..642f62749dff 100644 --- a/doc/source/reference/c-api/dtype.rst +++ b/doc/source/reference/c-api/dtype.rst @@ -219,7 +219,7 @@ Defines ------- Max and min values for integers -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ``NPY_MAX_INT{bits}``, ``NPY_MAX_UINT{bits}``, ``NPY_MIN_INT{bits}`` These are defined for ``{bits}`` = 8, 16, 32, 64, 128, and 256 and provide @@ -238,7 +238,7 @@ Max and min values for integers Number of bits in data types -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~~~~~~~~~~~~~~ All ``NPY_SIZEOF_{CTYPE}`` constants have corresponding ``NPY_BITSOF_{CTYPE}`` constants defined. The ``NPY_BITSOF_{CTYPE}`` @@ -250,7 +250,7 @@ the available ``{CTYPE}s`` are Bit-width references to enumerated typenums -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ All of the numeric data types (integer, floating point, and complex) have constants that are defined to be a specific enumerated type @@ -265,7 +265,7 @@ types are available. Integer that can hold a pointer -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The constants **NPY_INTP** and **NPY_UINTP** refer to an enumerated integer type that is large enough to hold a pointer on the @@ -283,7 +283,7 @@ types. Boolean -^^^^^^^ +~~~~~~~ .. c:type:: npy_bool @@ -292,7 +292,7 @@ Boolean (Un)Signed Integer -^^^^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~~~~ Unsigned versions of the integers can be defined by pre-pending a 'u' to the front of the integer name. @@ -373,7 +373,7 @@ to the front of the integer name. (Complex) Floating point -^^^^^^^^^^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~~~~~~~~~~ .. c:type:: npy_half @@ -408,7 +408,7 @@ that order). Bit-width names -^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~ There are also typedefs for signed integers, unsigned integers, floating point, and complex floating point types of specific bit- diff --git a/doc/source/reference/c-api/iterator.rst b/doc/source/reference/c-api/iterator.rst index 83644d8b240b..07187e7f10b3 100644 --- a/doc/source/reference/c-api/iterator.rst +++ b/doc/source/reference/c-api/iterator.rst @@ -203,6 +203,66 @@ is used to control the memory layout of the allocated result, typically } +Multi Index Tracking Example +---------------------------- + +This example shows you how to work with the :c:data:`NPY_ITER_MULTI_INDEX` flag. For simplicity, we assume the argument is a two-dimensional array. + +.. code-block:: c + + int PrintMultiIndex(PyArrayObject *arr) { + NpyIter *iter; + NpyIter_IterNextFunc *iternext; + npy_intp multi_index[2]; + + iter = NpyIter_New( + arr, NPY_ITER_READONLY | NPY_ITER_MULTI_INDEX | NPY_ITER_REFS_OK, + NPY_KEEPORDER, NPY_NO_CASTING, NULL); + if (iter == NULL) { + return -1; + } + if (NpyIter_GetNDim(iter) != 2) { + NpyIter_Deallocate(iter); + PyErr_SetString(PyExc_ValueError, "Array must be 2-D"); + return -1; + } + if (NpyIter_GetIterSize(iter) != 0) { + iternext = NpyIter_GetIterNext(iter, NULL); + if (iternext == NULL) { + NpyIter_Deallocate(iter); + return -1; + } + NpyIter_GetMultiIndexFunc *get_multi_index = + NpyIter_GetGetMultiIndex(iter, NULL); + if (get_multi_index == NULL) { + NpyIter_Deallocate(iter); + return -1; + } + + do { + get_multi_index(iter, multi_index); + printf("multi_index is [%" NPY_INTP_FMT ", %" NPY_INTP_FMT "]\n", + multi_index[0], multi_index[1]); + } while (iternext(iter)); + } + if (!NpyIter_Deallocate(iter)) { + return -1; + } + return 0; + } + +When called with a 2x3 array, the above example prints: + +.. code-block:: sh + + multi_index is [0, 0] + multi_index is [0, 1] + multi_index is [0, 2] + multi_index is [1, 0] + multi_index is [1, 1] + multi_index is [1, 2] + + Iterator Data Types --------------------- @@ -653,7 +713,7 @@ Construction and Destruction may not be repeated. The following example is how normal broadcasting applies to a 3-D array, a 2-D array, a 1-D array and a scalar. - **Note**: Before NumPy 1.8 ``oa_ndim == 0` was used for signalling that + **Note**: Before NumPy 1.8 ``oa_ndim == 0` was used for signalling that ``op_axes`` and ``itershape`` are unused. This is deprecated and should be replaced with -1. Better backward compatibility may be achieved by using :c:func:`NpyIter_MultiNew` for this case. diff --git a/doc/source/reference/c-api/types-and-structures.rst b/doc/source/reference/c-api/types-and-structures.rst index 605a4ae718fb..34437bd303bb 100644 --- a/doc/source/reference/c-api/types-and-structures.rst +++ b/doc/source/reference/c-api/types-and-structures.rst @@ -144,9 +144,8 @@ PyArray_Type and PyArrayObject - If this array does not own its own memory, then base points to the Python object that owns it (perhaps another array object) - - If this array has the (deprecated) :c:data:`NPY_ARRAY_UPDATEIFCOPY` or - :c:data:`NPY_ARRAY_WRITEBACKIFCOPY` flag set, then this array is a working - copy of a "misbehaved" array. + - If this array has the :c:data:`NPY_ARRAY_WRITEBACKIFCOPY` flag set, + then this array is a working copy of a "misbehaved" array. When ``PyArray_ResolveWritebackIfCopy`` is called, the array pointed to by base will be updated with the contents of this array. @@ -169,7 +168,7 @@ PyArray_Type and PyArrayObject interpreted. Possible flags are :c:data:`NPY_ARRAY_C_CONTIGUOUS`, :c:data:`NPY_ARRAY_F_CONTIGUOUS`, :c:data:`NPY_ARRAY_OWNDATA`, :c:data:`NPY_ARRAY_ALIGNED`, :c:data:`NPY_ARRAY_WRITEABLE`, - :c:data:`NPY_ARRAY_WRITEBACKIFCOPY`, and :c:data:`NPY_ARRAY_UPDATEIFCOPY`. + :c:data:`NPY_ARRAY_WRITEBACKIFCOPY`. .. c:member:: PyObject *weakreflist @@ -286,6 +285,11 @@ PyArrayDescr_Type and PyArray_Descr array like behavior. Each bit in this member is a flag which are named as: + .. c:member:: int alignment + + Non-NULL if this type is an array (C-contiguous) of some other type + + .. dedented to allow internal linking, pending a refactoring diff --git a/doc/source/reference/c-api/ufunc.rst b/doc/source/reference/c-api/ufunc.rst index 95dc47839e4b..39447ae2403f 100644 --- a/doc/source/reference/c-api/ufunc.rst +++ b/doc/source/reference/c-api/ufunc.rst @@ -79,7 +79,7 @@ Types .. c:type:: PyUFuncGenericFunction - pointers to functions that actually implement the underlying + Pointers to functions that actually implement the underlying (element-by-element) function :math:`N` times with the following signature: @@ -107,7 +107,10 @@ Types Arbitrary data (extra arguments, function names, *etc.* ) that can be stored with the ufunc and will be passed in - when it is called. + when it is called. May be ``NULL``. + + .. versionchanged:: 1.23.0 + Accepts ``NULL`` `data` in addition to array of ``NULL`` values. This is an example of a func specialized for addition of doubles returning doubles. @@ -154,20 +157,21 @@ Functions ufunc object is alive. :param func: - Must to an array of length *ntypes* containing - :c:type:`PyUFuncGenericFunction` items. + Must point to an array containing *ntypes* + :c:type:`PyUFuncGenericFunction` elements. :param data: - Should be ``NULL`` or a pointer to an array of size *ntypes* - . This array may contain arbitrary extra-data to be passed to - the corresponding loop function in the func array. + Should be ``NULL`` or a pointer to an array of size *ntypes*. + This array may contain arbitrary extra-data to be passed to + the corresponding loop function in the func array, including + ``NULL``. :param types: Length ``(nin + nout) * ntypes`` array of ``char`` encoding the `numpy.dtype.num` (built-in only) that the corresponding function in the ``func`` array accepts. For instance, for a comparison ufunc with three ``ntypes``, two ``nin`` and one ``nout``, where the - first function accepts `numpy.int32` and the the second + first function accepts `numpy.int32` and the second `numpy.int64`, with both returning `numpy.bool_`, ``types`` would be ``(char[]) {5, 5, 0, 7, 7, 0}`` since ``NPY_INT32`` is 5, ``NPY_INT64`` is 7, and ``NPY_BOOL`` is 0. diff --git a/doc/source/reference/distutils.rst b/doc/source/reference/distutils.rst index f201ba66865b..a5991f2c11cd 100644 --- a/doc/source/reference/distutils.rst +++ b/doc/source/reference/distutils.rst @@ -4,6 +4,19 @@ Packaging (:mod:`numpy.distutils`) .. module:: numpy.distutils +.. warning:: + + ``numpy.distutils`` is deprecated, and will be removed for + Python >= 3.12. For more details, see :ref:`distutils-status-migration` + +.. warning:: + + Note that ``setuptools`` does major releases often and those may contain + changes that break ``numpy.distutils``, which will *not* be updated anymore + for new ``setuptools`` versions. It is therefore recommended to set an + upper version bound in your build configuration for the last known version + of ``setuptools`` that works with your build. + NumPy provides enhanced distutils functionality to make it easier to build and install sub-packages, auto-generate code, and extension modules that use Fortran-compiled libraries. To use features of NumPy @@ -188,6 +201,8 @@ Info are easily retrieved from the `get_info` function in >>> info = np.distutils.misc_util.get_info('npymath') >>> config.add_extension('foo', sources=['foo.c'], extra_info=info) + + An additional list of paths to look for .ini files can be given to `get_info`. diff --git a/doc/source/reference/distutils_guide.rst b/doc/source/reference/distutils_guide.rst index 081719d16428..a72a9c4d6979 100644 --- a/doc/source/reference/distutils_guide.rst +++ b/doc/source/reference/distutils_guide.rst @@ -3,5 +3,11 @@ NumPy Distutils - Users Guide ============================= -.. include:: ../../DISTUTILS.rst.txt +.. warning:: + + ``numpy.distutils`` is deprecated, and will be removed for + Python >= 3.12. For more details, see :ref:`distutils-status-migration` + + +.. include:: ../../DISTUTILS.rst :start-line: 6 diff --git a/doc/source/reference/distutils_status_migration.rst b/doc/source/reference/distutils_status_migration.rst new file mode 100644 index 000000000000..eda4790b51bb --- /dev/null +++ b/doc/source/reference/distutils_status_migration.rst @@ -0,0 +1,138 @@ +.. _distutils-status-migration: + +Status of ``numpy.distutils`` and migration advice +================================================== + +`numpy.distutils` has been deprecated in NumPy ``1.23.0``. It will be removed +for Python 3.12; for Python <= 3.11 it will not be removed until 2 years after +the Python 3.12 release (Oct 2025). + + +.. warning:: + + ``numpy.distutils`` is only tested with ``setuptools < 60.0``, newer + versions may break. See :ref:`numpy-setuptools-interaction` for details. + + +Migration advice +---------------- + +It is **not necessary** to migrate immediately - the release date for Python 3.12 +is October 2023. It may be beneficial to wait with migrating until there are +examples from other projects to follow (see below). + +There are several build systems which are good options to migrate to. Assuming +you have compiled code in your package (if not, we recommend using Flit_) and +you want to be using a well-designed, modern and reliable build system, we +recommend: + +1. Meson_ +2. CMake_ (or scikit-build_ as an interface to CMake) + +If you have modest needs (only simple Cython/C extensions, and perhaps nested +``setup.py`` files) and have been happy with ``numpy.distutils`` so far, you +can also consider switching to ``setuptools``. Note that most functionality of +``numpy.distutils`` is unlikely to be ported to ``setuptools``. + + +Moving to Meson +~~~~~~~~~~~~~~~ + +SciPy is moving to Meson for its 1.9.0 release, planned for July 2022. During +this process, any remaining issues with Meson's Python support and achieving +feature parity with ``numpy.distutils`` will be resolved. *Note: parity means a +large superset, but right now some BLAS/LAPACK support is missing and there are +a few open issues related to Cython.* SciPy uses almost all functionality that +``numpy.distutils`` offers, so if SciPy has successfully made a release with +Meson as the build system, there should be no blockers left to migrate, and +SciPy will be a good reference for other packages who are migrating. +For more details about the SciPy migration, see: + +- `RFC: switch to Meson as a build system `__ +- `Tracking issue for Meson support `__ + +NumPy itself will very likely migrate to Meson as well, once the SciPy +migration is done. + + +Moving to CMake / scikit-build +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +See the `scikit-build documentation `__ +for how to use scikit-build. Please note that as of Feb 2022, scikit-build +still relies on setuptools, so it's probably not quite ready yet for a +post-distutils world. How quickly this changes depends on funding, the current +(Feb 2022) estimate is that if funding arrives then a viable ``numpy.distutils`` +replacement will be ready at the end of 2022, and a very polished replacement +mid-2023. For more details on this, see +`this blog post by Henry Schreiner `__. + + +Moving to ``setuptools`` +~~~~~~~~~~~~~~~~~~~~~~~~ + +For projects that only use ``numpy.distutils`` for historical reasons, and do +not actually use features beyond those that ``setuptools`` also supports, +moving to ``setuptools`` is likely the solution which costs the least effort. +To assess that, there are the ``numpy.distutils`` features that are *not* +present in ``setuptools``: + +- Nested ``setup.py`` files +- Fortran build support +- BLAS/LAPACK library support (OpenBLAS, MKL, ATLAS, Netlib LAPACK/BLAS, BLIS, 64-bit ILP interface, etc.) +- Support for a few other scientific libraries, like FFTW and UMFPACK +- Better MinGW support +- Per-compiler build flag customization (e.g. `-O3` and `SSE2` flags are default) +- a simple user build config system, see [site.cfg.example](https://github.com/numpy/numpy/blob/master/site.cfg.example) +- SIMD intrinsics support + +The most widely used feature is nested ``setup.py`` files. This feature will +likely be ported to ``setuptools`` (see +`gh-18588 `__ for status). +Projects only using that feature could move to ``setuptools`` after that is +done. In case a project uses only a couple of ``setup.py`` files, it also could +make sense to simply aggregate all the content of those files into a single +``setup.py`` file and then move to ``setuptools``. This involves dropping all +``Configuration`` instances, and using ``Extension`` instead. E.g.,:: + + from distutils.core import setup + from distutils.extension import Extension + setup(name='foobar', + version='1.0', + ext_modules=[ + Extension('foopkg.foo', ['foo.c']), + Extension('barpkg.bar', ['bar.c']), + ], + ) + +For more details, see the +`setuptools documentation `__ + + +.. _numpy-setuptools-interaction: + +Interaction of ``numpy.distutils`` with ``setuptools`` +------------------------------------------------------ + +It is recommended to use ``setuptools < 60.0``. Newer versions may work, but +are not guaranteed to. The reason for this is that ``setuptools`` 60.0 enabled +a vendored copy of ``distutils``, including backwards incompatible changes that +affect some functionality in ``numpy.distutils``. + +If you are using only simple Cython or C extensions with minimal use of +``numpy.distutils`` functionality beyond nested ``setup.py`` files (its most +popular feature, see :class:`Configuration `), +then latest ``setuptools`` is likely to continue working. In case of problems, +you can also try ``SETUPTOOLS_USE_DISTUTILS=stdlib`` to avoid the backwards +incompatible changes in ``setuptools``. + +Whatever you do, it is recommended to put an upper bound on your ``setuptools`` +build requirement in ``pyproject.toml`` to avoid future breakage - see +:ref:`for-downstream-package-authors`. + + +.. _Flit: https://flit.readthedocs.io +.. _CMake: https://cmake.org/ +.. _Meson: https://mesonbuild.com/ +.. _scikit-build: https://scikit-build.readthedocs.io/ + diff --git a/doc/source/reference/global_state.rst b/doc/source/reference/global_state.rst index 20874ceaae49..81685ec7d836 100644 --- a/doc/source/reference/global_state.rst +++ b/doc/source/reference/global_state.rst @@ -70,19 +70,15 @@ Debugging-Related Options Relaxed Strides Checking ------------------------ -The *compile-time* environment variables:: +The *compile-time* environment variable:: NPY_RELAXED_STRIDES_DEBUG=0 - NPY_RELAXED_STRIDES_CHECKING=1 - -control how NumPy reports contiguity for arrays. -The default that it is enabled and the debug mode is disabled. -This setting should always be enabled. Setting the -debug option can be interesting for testing code written -in C which iterates through arrays that may or may not be -contiguous in memory. -Most users will have no reason to change these; for details -see the :ref:`memory layout ` documentation. + +can be set to help debug code written in C which iteraters through arrays +manually. When an array is contiguous and iterated in a contiguous manner, +its ``strides`` should not be queried. This option can help find errors where +the ``strides`` are incorrectly used. +For details see the :ref:`memory layout ` documentation. Warn if no memory allocation policy when deallocating data diff --git a/doc/source/reference/index.rst b/doc/source/reference/index.rst index a18211cca782..8e4a81436911 100644 --- a/doc/source/reference/index.rst +++ b/doc/source/reference/index.rst @@ -1,7 +1,7 @@ -.. _reference: - .. module:: numpy +.. _reference: + ############### NumPy Reference ############### @@ -18,6 +18,7 @@ For learning how to use NumPy, see the :ref:`complete documentation >> import numpy as np >>> from numpy import ma .. _numpy.ma.constants: @@ -36,13 +35,14 @@ defines several constants. is not needed. It is represented internally as ``np.False_``. -.. data:: masked_print_options +.. data:: masked_print_option String used in lieu of missing data when a masked array is printed. By default, this string is ``'--'``. - - + Use ``set_display()`` to change the default string. + Example usage: ``numpy.ma.masked_print_option.set_display('X')`` + replaces missing data with ``'X'``. .. _maskedarray.baseclass: diff --git a/doc/source/reference/maskedarray.generic.rst b/doc/source/reference/maskedarray.generic.rst index d3849c50deec..29fc2fe07452 100644 --- a/doc/source/reference/maskedarray.generic.rst +++ b/doc/source/reference/maskedarray.generic.rst @@ -467,7 +467,7 @@ Suppose now that we wish to print that same data, but with the missing values replaced by the average value. >>> print(mx.filled(mx.mean())) - [ 0. 1. 2. 3. 4.] + [0. 1. 2. 3. 4.] Numerical operations diff --git a/doc/source/reference/random/bit_generators/index.rst b/doc/source/reference/random/bit_generators/index.rst index 211f0d60e2b8..d93f38d0b61a 100644 --- a/doc/source/reference/random/bit_generators/index.rst +++ b/doc/source/reference/random/bit_generators/index.rst @@ -1,7 +1,7 @@ .. currentmodule:: numpy.random Bit Generators --------------- +============== The random values produced by :class:`~Generator` originate in a BitGenerator. The BitGenerators do not directly provide @@ -11,7 +11,7 @@ low-level wrappers for consumption by code that can efficiently access the functions provided, e.g., `numba `_. Supported BitGenerators -======================= +----------------------- The included BitGenerators are: @@ -51,7 +51,7 @@ The included BitGenerators are: SFC64 Seeding and Entropy -------------------- +=================== A BitGenerator provides a stream of random values. In order to generate reproducible streams, BitGenerators support setting their initial state via a diff --git a/doc/source/reference/random/bit_generators/mt19937.rst b/doc/source/reference/random/bit_generators/mt19937.rst index d05ea7c6f09a..e85234d10245 100644 --- a/doc/source/reference/random/bit_generators/mt19937.rst +++ b/doc/source/reference/random/bit_generators/mt19937.rst @@ -1,5 +1,5 @@ Mersenne Twister (MT19937) --------------------------- +========================== .. currentmodule:: numpy.random @@ -8,7 +8,7 @@ Mersenne Twister (MT19937) :exclude-members: __init__ State -===== +----- .. autosummary:: :toctree: generated/ @@ -16,14 +16,14 @@ State ~MT19937.state Parallel generation -=================== +------------------- .. autosummary:: :toctree: generated/ ~MT19937.jumped Extending -========= +--------- .. autosummary:: :toctree: generated/ diff --git a/doc/source/reference/random/bit_generators/pcg64.rst b/doc/source/reference/random/bit_generators/pcg64.rst index 889965f77bc2..6ebd34f4a6c1 100644 --- a/doc/source/reference/random/bit_generators/pcg64.rst +++ b/doc/source/reference/random/bit_generators/pcg64.rst @@ -1,5 +1,5 @@ Permuted Congruential Generator (64-bit, PCG64) ------------------------------------------------ +=============================================== .. currentmodule:: numpy.random @@ -8,7 +8,7 @@ Permuted Congruential Generator (64-bit, PCG64) :exclude-members: __init__ State -===== +----- .. autosummary:: :toctree: generated/ @@ -16,7 +16,7 @@ State ~PCG64.state Parallel generation -=================== +------------------- .. autosummary:: :toctree: generated/ @@ -24,7 +24,7 @@ Parallel generation ~PCG64.jumped Extending -========= +--------- .. autosummary:: :toctree: generated/ diff --git a/doc/source/reference/random/bit_generators/pcg64dxsm.rst b/doc/source/reference/random/bit_generators/pcg64dxsm.rst index e37efa5d39da..99e4d15c9250 100644 --- a/doc/source/reference/random/bit_generators/pcg64dxsm.rst +++ b/doc/source/reference/random/bit_generators/pcg64dxsm.rst @@ -1,5 +1,5 @@ Permuted Congruential Generator (64-bit, PCG64 DXSM) ----------------------------------------------------- +==================================================== .. currentmodule:: numpy.random @@ -8,7 +8,7 @@ Permuted Congruential Generator (64-bit, PCG64 DXSM) :exclude-members: __init__ State -===== +----- .. autosummary:: :toctree: generated/ @@ -16,7 +16,7 @@ State ~PCG64DXSM.state Parallel generation -=================== +------------------- .. autosummary:: :toctree: generated/ @@ -24,7 +24,7 @@ Parallel generation ~PCG64DXSM.jumped Extending -========= +--------- .. autosummary:: :toctree: generated/ diff --git a/doc/source/reference/random/bit_generators/philox.rst b/doc/source/reference/random/bit_generators/philox.rst index 3c2fa4cc5aa1..4df36465359d 100644 --- a/doc/source/reference/random/bit_generators/philox.rst +++ b/doc/source/reference/random/bit_generators/philox.rst @@ -1,5 +1,5 @@ Philox Counter-based RNG ------------------------- +======================== .. currentmodule:: numpy.random @@ -8,7 +8,7 @@ Philox Counter-based RNG :exclude-members: __init__ State -===== +----- .. autosummary:: :toctree: generated/ @@ -16,7 +16,7 @@ State ~Philox.state Parallel generation -=================== +------------------- .. autosummary:: :toctree: generated/ @@ -24,7 +24,7 @@ Parallel generation ~Philox.jumped Extending -========= +--------- .. autosummary:: :toctree: generated/ diff --git a/doc/source/reference/random/bit_generators/sfc64.rst b/doc/source/reference/random/bit_generators/sfc64.rst index 8cb255bc154d..6ea9593c21c5 100644 --- a/doc/source/reference/random/bit_generators/sfc64.rst +++ b/doc/source/reference/random/bit_generators/sfc64.rst @@ -1,5 +1,5 @@ SFC64 Small Fast Chaotic PRNG ------------------------------ +============================= .. currentmodule:: numpy.random @@ -8,7 +8,7 @@ SFC64 Small Fast Chaotic PRNG :exclude-members: __init__ State -===== +----- .. autosummary:: :toctree: generated/ @@ -16,7 +16,7 @@ State ~SFC64.state Extending -========= +--------- .. autosummary:: :toctree: generated/ diff --git a/doc/source/reference/random/c-api.rst b/doc/source/reference/random/c-api.rst index de403ce98673..2819c769cb44 100644 --- a/doc/source/reference/random/c-api.rst +++ b/doc/source/reference/random/c-api.rst @@ -8,8 +8,9 @@ C API for random Access to various distributions below is available via Cython or C-wrapper libraries like CFFI. All the functions accept a :c:type:`bitgen_t` as their first argument. To access these from Cython or C, you must link with the -``npyrandom`` library which is part of the NumPy distribution, located in -``numpy/random/lib``. +``npyrandom`` static library which is part of the NumPy distribution, located +in ``numpy/random/lib``. Note that you must *also* link with ``npymath``, +see :ref:`linking-npymath`. .. c:type:: bitgen_t diff --git a/doc/source/reference/random/extending.rst b/doc/source/reference/random/extending.rst index 2c506e94343f..6bb9414964e0 100644 --- a/doc/source/reference/random/extending.rst +++ b/doc/source/reference/random/extending.rst @@ -3,14 +3,14 @@ .. _extending: Extending ---------- +========= The BitGenerators have been designed to be extendable using standard tools for high-performance Python -- numba and Cython. The `~Generator` object can also be used with user-provided BitGenerators as long as these export a small set of required functions. Numba -===== +----- Numba can be used with either CTypes or CFFI. The current iteration of the BitGenerators all export a small set of functions through both interfaces. @@ -30,7 +30,7 @@ the `examples` section below. .. _random_cython: Cython -====== +------ Cython can be used to unpack the ``PyCapsule`` provided by a BitGenerator. This example uses `PCG64` and the example from above. The usual caveats @@ -61,7 +61,7 @@ See :ref:`extending_cython_example` for the complete listings of these examples and a minimal ``setup.py`` to build the c-extension modules. CFFI -==== +---- CFFI can be used to directly access the functions in ``include/numpy/random/distributions.h``. Some "massaging" of the header @@ -80,7 +80,7 @@ directly from the ``_generator`` shared object, using the `BitGenerator.cffi` in New Bit Generators -================== +------------------ `~Generator` can be used with user-provided `~BitGenerator`\ s. The simplest way to write a new BitGenerator is to examine the pyx file of one of the existing BitGenerators. The key structure that must be provided is the @@ -109,7 +109,7 @@ the next 64-bit unsigned integer function if not needed. Functions inside bitgen_state->next_uint64(bitgen_state->state) Examples -======== +-------- .. toctree:: Numba diff --git a/doc/source/reference/random/generator.rst b/doc/source/reference/random/generator.rst index 7934be98a6d4..dc71cb1f9304 100644 --- a/doc/source/reference/random/generator.rst +++ b/doc/source/reference/random/generator.rst @@ -1,7 +1,7 @@ .. currentmodule:: numpy.random Random Generator ----------------- +================ The `~Generator` provides access to a wide range of distributions, and served as a replacement for :class:`~numpy.random.RandomState`. The main difference between @@ -19,14 +19,14 @@ can be changed by passing an instantized BitGenerator to ``Generator``. :exclude-members: __init__ Accessing the BitGenerator -========================== +-------------------------- .. autosummary:: :toctree: generated/ ~numpy.random.Generator.bit_generator Simple random data -================== +------------------ .. autosummary:: :toctree: generated/ @@ -36,7 +36,7 @@ Simple random data ~numpy.random.Generator.bytes Permutations -============ +------------ The methods for randomly permuting a sequence are .. autosummary:: @@ -73,12 +73,12 @@ the value of the ``out`` parameter. For example, >>> rng = np.random.default_rng() >>> x = np.arange(0, 15).reshape(3, 5) - >>> x + >>> x #doctest: +SKIP array([[ 0, 1, 2, 3, 4], [ 5, 6, 7, 8, 9], [10, 11, 12, 13, 14]]) >>> y = rng.permuted(x, axis=1, out=x) - >>> x + >>> x #doctest: +SKIP array([[ 1, 0, 2, 4, 3], # random [ 6, 7, 8, 9, 5], [10, 14, 11, 13, 12]]) @@ -88,6 +88,8 @@ Note that when ``out`` is given, the return value is ``out``: >>> y is x True +.. _generator-handling-axis-parameter: + Handling the ``axis`` parameter ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ An important distinction for these methods is how they handle the ``axis`` @@ -103,7 +105,7 @@ array, and ``axis=1`` will rearrange the columns. For example array([[ 0, 1, 2, 3, 4], [ 5, 6, 7, 8, 9], [10, 11, 12, 13, 14]]) - >>> rng.permutation(x, axis=1) + >>> rng.permutation(x, axis=1) #doctest: +SKIP array([[ 1, 3, 2, 0, 4], # random [ 6, 8, 7, 5, 9], [11, 13, 12, 10, 14]]) @@ -116,7 +118,7 @@ how `numpy.sort` treats it. Each slice along the given axis is shuffled independently of the others. Compare the following example of the use of `Generator.permuted` to the above example of `Generator.permutation`: - >>> rng.permuted(x, axis=1) + >>> rng.permuted(x, axis=1) #doctest: +SKIP array([[ 1, 0, 2, 4, 3], # random [ 5, 7, 6, 9, 8], [10, 14, 12, 13, 11]]) @@ -134,11 +136,11 @@ For example, >>> rng = np.random.default_rng() >>> a = ['A', 'B', 'C', 'D', 'E'] >>> rng.shuffle(a) # shuffle the list in-place - >>> a + >>> a #doctest: +SKIP ['B', 'D', 'A', 'E', 'C'] # random Distributions -============= +------------- .. autosummary:: :toctree: generated/ diff --git a/doc/source/reference/random/index.rst b/doc/source/reference/random/index.rst index aaabc9b39278..83a27d80cd44 100644 --- a/doc/source/reference/random/index.rst +++ b/doc/source/reference/random/index.rst @@ -185,7 +185,7 @@ What's New or Different methods which are 2-10 times faster than NumPy's Box-Muller or inverse CDF implementations. * Optional ``dtype`` argument that accepts ``np.float32`` or ``np.float64`` - to produce either single or double prevision uniform random variables for + to produce either single or double precision uniform random variables for select distributions * Optional ``out`` argument that allows existing arrays to be filled for select distributions @@ -216,9 +216,10 @@ Parallel Generation ~~~~~~~~~~~~~~~~~~~ The included generators can be used in parallel, distributed applications in -one of three ways: +a number of ways: * :ref:`seedsequence-spawn` +* :ref:`sequence-of-seeds` * :ref:`independent-streams` * :ref:`parallel-jumped` diff --git a/doc/source/reference/random/legacy.rst b/doc/source/reference/random/legacy.rst index 42437dbb6173..b1fce49a16c9 100644 --- a/doc/source/reference/random/legacy.rst +++ b/doc/source/reference/random/legacy.rst @@ -52,7 +52,7 @@ using the state of the `RandomState`: :exclude-members: __init__ Seeding and State -================= +----------------- .. autosummary:: :toctree: generated/ @@ -62,7 +62,7 @@ Seeding and State ~RandomState.seed Simple random data -================== +------------------ .. autosummary:: :toctree: generated/ @@ -75,7 +75,7 @@ Simple random data ~RandomState.bytes Permutations -============ +------------ .. autosummary:: :toctree: generated/ @@ -83,7 +83,7 @@ Permutations ~RandomState.permutation Distributions -============= +------------- .. autosummary:: :toctree: generated/ @@ -124,7 +124,7 @@ Distributions ~RandomState.zipf Functions in `numpy.random` -=========================== +--------------------------- Many of the RandomState methods above are exported as functions in `numpy.random` This usage is discouraged, as it is implemented via a global `RandomState` instance which is not advised on two counts: diff --git a/doc/source/reference/random/new-or-different.rst b/doc/source/reference/random/new-or-different.rst index a815439267fc..8f4a70540b65 100644 --- a/doc/source/reference/random/new-or-different.rst +++ b/doc/source/reference/random/new-or-different.rst @@ -40,7 +40,7 @@ Feature Older Equivalent Notes supported. ------------------ -------------------- ------------- ``integers`` ``randint``, Use the ``endpoint`` kwarg to adjust - ``random_integers`` the inclusion or exclution of the + ``random_integers`` the inclusion or exclusion of the ``high`` interval endpoint ================== ==================== ============= @@ -84,7 +84,7 @@ And in more detail: * The bit generators can be used in downstream projects via Cython. * Optional ``dtype`` argument that accepts ``np.float32`` or ``np.float64`` - to produce either single or double prevision uniform random variables for + to produce either single or double precision uniform random variables for select distributions * Uniforms (`~.Generator.random` and `~.Generator.integers`) diff --git a/doc/source/reference/random/parallel.rst b/doc/source/reference/random/parallel.rst index 7f0207bdebb2..b625d34b70bf 100644 --- a/doc/source/reference/random/parallel.rst +++ b/doc/source/reference/random/parallel.rst @@ -1,7 +1,7 @@ Parallel Random Number Generation ================================= -There are three strategies implemented that can be used to produce +There are four main strategies implemented that can be used to produce repeatable pseudo-random numbers across multiple processes (local or distributed). @@ -28,8 +28,8 @@ streams. `~SeedSequence` avoids these problems by using successions of integer hashes with good `avalanche properties`_ to ensure that flipping any bit in the input -input has about a 50% chance of flipping any bit in the output. Two input seeds -that are very close to each other will produce initial states that are very far +has about a 50% chance of flipping any bit in the output. Two input seeds that +are very close to each other will produce initial states that are very far from each other (with very high probability). It is also constructed in such a way that you can provide arbitrary-sized integers or lists of integers. `~SeedSequence` will take all of the bits that you provide and mix them @@ -109,6 +109,87 @@ territory ([2]_). .. _`not unique to numpy`: https://www.iro.umontreal.ca/~lecuyer/myftp/papers/parallel-rng-imacs.pdf +.. _sequence-of-seeds: + +Sequence of Integer Seeds +------------------------- + +As discussed in the previous section, `~SeedSequence` can not only take an +integer seed, it can also take an arbitrary-length sequence of (non-negative) +integers. If one exercises a little care, one can use this feature to design +*ad hoc* schemes for getting safe parallel PRNG streams with similar safety +guarantees as spawning. + +For example, one common use case is that a worker process is passed one +root seed integer for the whole calculation and also an integer worker ID (or +something more granular like a job ID, batch ID, or something similar). If +these IDs are created deterministically and uniquely, then one can derive +reproducible parallel PRNG streams by combining the ID and the root seed +integer in a list. + +.. code-block:: python + + # default_rng() and each of the BitGenerators use SeedSequence underneath, so + # they all accept sequences of integers as seeds the same way. + from numpy.random import default_rng + + def worker(root_seed, worker_id): + rng = default_rng([worker_id, root_seed]) + # Do work ... + + root_seed = 0x8c3c010cb4754c905776bdac5ee7501 + results = [worker(root_seed, worker_id) for worker_id in range(10)] + +.. end_block + +This can be used to replace a number of unsafe strategies that have been used +in the past which try to combine the root seed and the ID back into a single +integer seed value. For example, it is common to see users add the worker ID to +the root seed, especially with the legacy `~RandomState` code. + +.. code-block:: python + + # UNSAFE! Do not do this! + worker_seed = root_seed + worker_id + rng = np.random.RandomState(worker_seed) + +.. end_block + +It is true that for any one run of a parallel program constructed this way, +each worker will have distinct streams. However, it is quite likely that +multiple invocations of the program with different seeds will get overlapping +sets of worker seeds. It is not uncommon (in the author's self-experience) to +change the root seed merely by an increment or two when doing these repeat +runs. If the worker seeds are also derived by small increments of the worker +ID, then subsets of the workers will return identical results, causing a bias +in the overall ensemble of results. + +Combining the worker ID and the root seed as a list of integers eliminates this +risk. Lazy seeding practices will still be fairly safe. + +This scheme does require that the extra IDs be unique and deterministically +created. This may require coordination between the worker processes. It is +recommended to place the varying IDs *before* the unvarying root seed. +`~SeedSequence.spawn` *appends* integers after the user-provided seed, so if +you might be mixing both this *ad hoc* mechanism and spawning, or passing your +objects down to library code that might be spawning, then it is a little bit +safer to prepend your worker IDs rather than append them to avoid a collision. + +.. code-block:: python + + # Good. + worker_seed = [worker_id, root_seed] + + # Less good. It will *work*, but it's less flexible. + worker_seed = [root_seed, worker_id] + +.. end_block + +With those caveats in mind, the safety guarantees against collision are about +the same as with spawning, discussed in the previous section. The algorithmic +mechanisms are the same. + + .. _independent-streams: Independent Streams diff --git a/doc/source/reference/random/performance.rst b/doc/source/reference/random/performance.rst index cb9b94113c2f..3a7cb027e8dc 100644 --- a/doc/source/reference/random/performance.rst +++ b/doc/source/reference/random/performance.rst @@ -1,10 +1,10 @@ Performance ------------ +=========== .. currentmodule:: numpy.random Recommendation -************** +-------------- The recommended generator for general use is `PCG64` or its upgraded variant `PCG64DXSM` for heavily-parallel use cases. They are statistically high quality, @@ -31,7 +31,7 @@ many systems. .. _`fails some statistical tests`: https://www.iro.umontreal.ca/~lecuyer/myftp/papers/testu01.pdf Timings -******* +------- The timings below are the time in ns to produce 1 random value from a specific distribution. The original `MT19937` generator is @@ -86,7 +86,7 @@ performance was computed using a geometric mean. All timings were taken using Linux on an AMD Ryzen 9 3900X processor. Performance on different Operating Systems -****************************************** +------------------------------------------ Performance differs across platforms due to compiler and hardware availability (e.g., register width) differences. The default bit generator has been chosen to perform well on 64-bit platforms. Performance on 32-bit operating systems diff --git a/doc/source/reference/random/upgrading-pcg64.rst b/doc/source/reference/random/upgrading-pcg64.rst index 9e540ace9331..b36bdf4c8dea 100644 --- a/doc/source/reference/random/upgrading-pcg64.rst +++ b/doc/source/reference/random/upgrading-pcg64.rst @@ -3,7 +3,7 @@ .. currentmodule:: numpy.random Upgrading ``PCG64`` with ``PCG64DXSM`` --------------------------------------- +====================================== Uses of the `PCG64` `BitGenerator` in a massively-parallel context have been shown to have statistical weaknesses that were not apparent at the first @@ -15,7 +15,7 @@ the statistical weakness while preserving the performance and the features of `PCG64`. Does this affect me? -==================== +-------------------- If you @@ -48,7 +48,7 @@ swamped by the remaining streams in most applications. .. _upgrading-pcg64-details: Technical Details -================= +----------------- Like many PRNG algorithms, `PCG64` is constructed from a transition function, which advances a 128-bit state, and an output function, that mixes the 128-bit diff --git a/doc/source/reference/routines.array-creation.rst b/doc/source/reference/routines.array-creation.rst index 30780c286c41..9d2954f2c35b 100644 --- a/doc/source/reference/routines.array-creation.rst +++ b/doc/source/reference/routines.array-creation.rst @@ -35,6 +35,7 @@ From existing data asmatrix copy frombuffer + from_dlpack fromfile fromfunction fromiter diff --git a/doc/source/reference/routines.array-manipulation.rst b/doc/source/reference/routines.array-manipulation.rst index 1c96495d96f7..95fc39876377 100644 --- a/doc/source/reference/routines.array-manipulation.rst +++ b/doc/source/reference/routines.array-manipulation.rst @@ -59,7 +59,6 @@ Changing kind of array asfortranarray ascontiguousarray asarray_chkfinite - asscalar require Joining arrays diff --git a/doc/source/reference/routines.bitwise.rst b/doc/source/reference/routines.bitwise.rst index 58661abc7274..5bf61ed8abf5 100644 --- a/doc/source/reference/routines.bitwise.rst +++ b/doc/source/reference/routines.bitwise.rst @@ -1,5 +1,5 @@ Binary operations -***************** +================= .. currentmodule:: numpy diff --git a/doc/source/reference/routines.char.rst b/doc/source/reference/routines.char.rst index 90df14125b45..98ccfe80233b 100644 --- a/doc/source/reference/routines.char.rst +++ b/doc/source/reference/routines.char.rst @@ -1,13 +1,19 @@ String operations -***************** +================= .. currentmodule:: numpy.char .. module:: numpy.char The `numpy.char` module provides a set of vectorized string -operations for arrays of type `numpy.str_` or `numpy.bytes_`. -All of them are based on the string methods in the Python standard library. +operations for arrays of type `numpy.str_` or `numpy.bytes_`. For example + + >>> np.char.capitalize(["python", "numpy"]) + array(['Python', 'Numpy'], dtype='>> np.char.add(["num", "doc"], ["py", "umentation"]) + array(['numpy', 'documentation'], dtype=' to a masked array ~~~~~~~~~~~~~~~~~~~ @@ -290,7 +291,7 @@ Filling a masked array _____ Masked arrays arithmetic -======================== +------------------------ Arithmetic ~~~~~~~~~~ diff --git a/doc/source/reference/routines.math.rst b/doc/source/reference/routines.math.rst index 2a09b8d204a1..35771cc9cbf7 100644 --- a/doc/source/reference/routines.math.rst +++ b/doc/source/reference/routines.math.rst @@ -1,5 +1,5 @@ Mathematical functions -********************** +====================== .. currentmodule:: numpy @@ -40,7 +40,6 @@ Rounding :toctree: generated/ around - round_ rint fix floor diff --git a/doc/source/reference/routines.other.rst b/doc/source/reference/routines.other.rst index 339857409157..e980406eb419 100644 --- a/doc/source/reference/routines.other.rst +++ b/doc/source/reference/routines.other.rst @@ -1,5 +1,5 @@ Miscellaneous routines -********************** +====================== .. toctree:: @@ -45,6 +45,7 @@ Utility get_include show_config + show_runtime deprecate deprecate_with_doc broadcast_shapes diff --git a/doc/source/reference/routines.polynomials.classes.rst b/doc/source/reference/routines.polynomials.classes.rst index 5f575bed13d4..896e5fe8302c 100644 --- a/doc/source/reference/routines.polynomials.classes.rst +++ b/doc/source/reference/routines.polynomials.classes.rst @@ -52,24 +52,24 @@ the conventional Polynomial class because of its familiarity:: >>> from numpy.polynomial import Polynomial as P >>> p = P([1,2,3]) >>> p - Polynomial([1., 2., 3.], domain=[-1, 1], window=[-1, 1]) + Polynomial([1., 2., 3.], domain=[-1, 1], window=[-1, 1], symbol='x') Note that there are three parts to the long version of the printout. The first is the coefficients, the second is the domain, and the third is the window:: >>> p.coef - array([ 1., 2., 3.]) + array([1., 2., 3.]) >>> p.domain - array([-1., 1.]) + array([-1, 1]) >>> p.window - array([-1., 1.]) + array([-1, 1]) Printing a polynomial yields the polynomial expression in a more familiar format:: >>> print(p) - 1.0 + 2.0·x¹ + 3.0·x² + 1.0 + 2.0·x + 3.0·x² Note that the string representation of polynomials uses Unicode characters by default (except on Windows) to express powers and subscripts. An ASCII-based @@ -77,14 +77,14 @@ representation is also available (default on Windows). The polynomial string format can be toggled at the package-level with the `~numpy.polynomial.set_default_printstyle` function:: - >>> numpy.polynomial.set_default_printstyle('ascii') + >>> np.polynomial.set_default_printstyle('ascii') >>> print(p) - 1.0 + 2.0 x**1 + 3.0 x**2 + 1.0 + 2.0 x + 3.0 x**2 or controlled for individual polynomial instances with string formatting:: >>> print(f"{p:unicode}") - 1.0 + 2.0·x¹ + 3.0·x² + 1.0 + 2.0·x + 3.0·x² We will deal with the domain and window when we get to fitting, for the moment we ignore them and run through the basic algebraic and arithmetic operations. @@ -92,19 +92,19 @@ we ignore them and run through the basic algebraic and arithmetic operations. Addition and Subtraction:: >>> p + p - Polynomial([2., 4., 6.], domain=[-1., 1.], window=[-1., 1.]) + Polynomial([2., 4., 6.], domain=[-1., 1.], window=[-1., 1.], symbol='x') >>> p - p - Polynomial([0.], domain=[-1., 1.], window=[-1., 1.]) + Polynomial([0.], domain=[-1., 1.], window=[-1., 1.], symbol='x') Multiplication:: >>> p * p - Polynomial([ 1., 4., 10., 12., 9.], domain=[-1., 1.], window=[-1., 1.]) + Polynomial([ 1., 4., 10., 12., 9.], domain=[-1., 1.], window=[-1., 1.], symbol='x') Powers:: >>> p**2 - Polynomial([ 1., 4., 10., 12., 9.], domain=[-1., 1.], window=[-1., 1.]) + Polynomial([ 1., 4., 10., 12., 9.], domain=[-1., 1.], window=[-1., 1.], symbol='x') Division: @@ -115,20 +115,20 @@ versions the '/' will only work for division by scalars. At some point it will be deprecated:: >>> p // P([-1, 1]) - Polynomial([5., 3.], domain=[-1., 1.], window=[-1., 1.]) + Polynomial([5., 3.], domain=[-1., 1.], window=[-1., 1.], symbol='x') Remainder:: >>> p % P([-1, 1]) - Polynomial([6.], domain=[-1., 1.], window=[-1., 1.]) + Polynomial([6.], domain=[-1., 1.], window=[-1., 1.], symbol='x') Divmod:: >>> quo, rem = divmod(p, P([-1, 1])) >>> quo - Polynomial([5., 3.], domain=[-1., 1.], window=[-1., 1.]) + Polynomial([5., 3.], domain=[-1., 1.], window=[-1., 1.], symbol='x') >>> rem - Polynomial([6.], domain=[-1., 1.], window=[-1., 1.]) + Polynomial([6.], domain=[-1., 1.], window=[-1., 1.], symbol='x') Evaluation:: @@ -137,9 +137,9 @@ Evaluation:: array([ 1., 6., 17., 34., 57.]) >>> x = np.arange(6).reshape(3,2) >>> p(x) - array([[ 1., 6.], - [ 17., 34.], - [ 57., 86.]]) + array([[ 1., 6.], + [17., 34.], + [57., 86.]]) Substitution: @@ -149,7 +149,7 @@ the polynomials are regarded as functions this is composition of functions:: >>> p(p) - Polynomial([ 6., 16., 36., 36., 27.], domain=[-1., 1.], window=[-1., 1.]) + Polynomial([ 6., 16., 36., 36., 27.], domain=[-1., 1.], window=[-1., 1.], symbol='x') Roots:: @@ -163,11 +163,11 @@ tuples, lists, arrays, and scalars are automatically cast in the arithmetic operations:: >>> p + [1, 2, 3] - Polynomial([2., 4., 6.], domain=[-1., 1.], window=[-1., 1.]) + Polynomial([2., 4., 6.], domain=[-1., 1.], window=[-1., 1.], symbol='x') >>> [1, 2, 3] * p - Polynomial([ 1., 4., 10., 12., 9.], domain=[-1., 1.], window=[-1., 1.]) + Polynomial([ 1., 4., 10., 12., 9.], domain=[-1., 1.], window=[-1., 1.], symbol='x') >>> p / 2 - Polynomial([0.5, 1. , 1.5], domain=[-1., 1.], window=[-1., 1.]) + Polynomial([0.5, 1. , 1.5], domain=[-1., 1.], window=[-1., 1.], symbol='x') Polynomials that differ in domain, window, or class can't be mixed in arithmetic:: @@ -195,7 +195,7 @@ conversion of Polynomial classes among themselves is done for type, domain, and window casting:: >>> p(T([0, 1])) - Chebyshev([2.5, 2. , 1.5], domain=[-1., 1.], window=[-1., 1.]) + Chebyshev([2.5, 2. , 1.5], domain=[-1., 1.], window=[-1., 1.], symbol='x') Which gives the polynomial `p` in Chebyshev form. This works because :math:`T_1(x) = x` and substituting :math:`x` for :math:`x` doesn't change @@ -215,18 +215,18 @@ Polynomial instances can be integrated and differentiated.:: >>> from numpy.polynomial import Polynomial as P >>> p = P([2, 6]) >>> p.integ() - Polynomial([0., 2., 3.], domain=[-1., 1.], window=[-1., 1.]) + Polynomial([0., 2., 3.], domain=[-1., 1.], window=[-1., 1.], symbol='x') >>> p.integ(2) - Polynomial([0., 0., 1., 1.], domain=[-1., 1.], window=[-1., 1.]) + Polynomial([0., 0., 1., 1.], domain=[-1., 1.], window=[-1., 1.], symbol='x') The first example integrates `p` once, the second example integrates it twice. By default, the lower bound of the integration and the integration constant are 0, but both can be specified.:: >>> p.integ(lbnd=-1) - Polynomial([-1., 2., 3.], domain=[-1., 1.], window=[-1., 1.]) + Polynomial([-1., 2., 3.], domain=[-1., 1.], window=[-1., 1.], symbol='x') >>> p.integ(lbnd=-1, k=1) - Polynomial([0., 2., 3.], domain=[-1., 1.], window=[-1., 1.]) + Polynomial([0., 2., 3.], domain=[-1., 1.], window=[-1., 1.], symbol='x') In the first case the lower bound of the integration is set to -1 and the integration constant is 0. In the second the constant of integration is set @@ -235,9 +235,9 @@ number of times the polynomial is differentiated:: >>> p = P([1, 2, 3]) >>> p.deriv(1) - Polynomial([2., 6.], domain=[-1., 1.], window=[-1., 1.]) + Polynomial([2., 6.], domain=[-1., 1.], window=[-1., 1.], symbol='x') >>> p.deriv(2) - Polynomial([6.], domain=[-1., 1.], window=[-1., 1.]) + Polynomial([6.], domain=[-1., 1.], window=[-1., 1.], symbol='x') Other Polynomial Constructors @@ -253,25 +253,25 @@ are demonstrated below:: >>> from numpy.polynomial import Chebyshev as T >>> p = P.fromroots([1, 2, 3]) >>> p - Polynomial([-6., 11., -6., 1.], domain=[-1., 1.], window=[-1., 1.]) + Polynomial([-6., 11., -6., 1.], domain=[-1., 1.], window=[-1., 1.], symbol='x') >>> p.convert(kind=T) - Chebyshev([-9. , 11.75, -3. , 0.25], domain=[-1., 1.], window=[-1., 1.]) + Chebyshev([-9. , 11.75, -3. , 0.25], domain=[-1., 1.], window=[-1., 1.], symbol='x') The convert method can also convert domain and window:: >>> p.convert(kind=T, domain=[0, 1]) - Chebyshev([-2.4375 , 2.96875, -0.5625 , 0.03125], domain=[0., 1.], window=[-1., 1.]) + Chebyshev([-2.4375 , 2.96875, -0.5625 , 0.03125], domain=[0., 1.], window=[-1., 1.], symbol='x') >>> p.convert(kind=P, domain=[0, 1]) - Polynomial([-1.875, 2.875, -1.125, 0.125], domain=[0., 1.], window=[-1., 1.]) + Polynomial([-1.875, 2.875, -1.125, 0.125], domain=[0., 1.], window=[-1., 1.], symbol='x') In numpy versions >= 1.7.0 the `basis` and `cast` class methods are also available. The cast method works like the convert method while the basis method returns the basis polynomial of given degree:: >>> P.basis(3) - Polynomial([0., 0., 0., 1.], domain=[-1., 1.], window=[-1., 1.]) + Polynomial([0., 0., 0., 1.], domain=[-1., 1.], window=[-1., 1.], symbol='x') >>> T.cast(p) - Chebyshev([-9. , 11.75, -3. , 0.25], domain=[-1., 1.], window=[-1., 1.]) + Chebyshev([-9. , 11.75, -3. , 0.25], domain=[-1., 1.], window=[-1., 1.], symbol='x') Conversions between types can be useful, but it is *not* recommended for routine use. The loss of numerical precision in passing from a @@ -294,7 +294,6 @@ polynomials up to degree 5 are plotted below. ... ax = plt.plot(x, T.basis(i)(x), lw=2, label=f"$T_{i}$") ... >>> plt.legend(loc="upper left") - >>> plt.show() In the range -1 <= `x` <= 1 they are nice, equiripple functions lying between +/- 1. @@ -309,7 +308,6 @@ The same plots over the range -2 <= `x` <= 2 look very different: ... ax = plt.plot(x, T.basis(i)(x), lw=2, label=f"$T_{i}$") ... >>> plt.legend(loc="lower right") - >>> plt.show() As can be seen, the "good" parts have shrunk to insignificance. In using @@ -335,12 +333,10 @@ illustrated below for a fit to a noisy sine curve. >>> y = np.sin(x) + np.random.normal(scale=.1, size=x.shape) >>> p = T.fit(x, y, 5) >>> plt.plot(x, y, 'o') - [] >>> xx, yy = p.linspace() >>> plt.plot(xx, yy, lw=2) - [] >>> p.domain - array([ 0. , 6.28318531]) + array([0. , 6.28318531]) >>> p.window array([-1., 1.]) >>> plt.show() diff --git a/doc/source/reference/routines.polynomials.rst b/doc/source/reference/routines.polynomials.rst index 4aea963c0116..ea22ab75fede 100644 --- a/doc/source/reference/routines.polynomials.rst +++ b/doc/source/reference/routines.polynomials.rst @@ -1,7 +1,7 @@ .. _routines.polynomial: Polynomials -*********** +=========== Polynomials in NumPy can be *created*, *manipulated*, and even *fitted* using the :doc:`convenience classes ` @@ -97,7 +97,7 @@ can't be mixed in arithmetic:: >>> p1 = np.polynomial.Polynomial([1, 2, 3]) >>> p1 - Polynomial([1., 2., 3.], domain=[-1, 1], window=[-1, 1]) + Polynomial([1., 2., 3.], domain=[-1, 1], window=[-1, 1], symbol='x') >>> p2 = np.polynomial.Polynomial([1, 2, 3], domain=[-2, 2]) >>> p1 == p2 False diff --git a/doc/source/reference/routines.sort.rst b/doc/source/reference/routines.sort.rst index c22fa0cd6194..998de7949341 100644 --- a/doc/source/reference/routines.sort.rst +++ b/doc/source/reference/routines.sort.rst @@ -12,7 +12,6 @@ Sorting lexsort argsort ndarray.sort - msort sort_complex partition argpartition diff --git a/doc/source/reference/routines.testing.rst b/doc/source/reference/routines.testing.rst index d9e98e94188d..16d53bb4e5ff 100644 --- a/doc/source/reference/routines.testing.rst +++ b/doc/source/reference/routines.testing.rst @@ -27,6 +27,8 @@ Asserts assert_raises assert_raises_regex assert_warns + assert_no_warnings + assert_no_gc_cycles assert_string_equal Asserts (not recommended) @@ -38,9 +40,11 @@ functions for more consistent floating point comparisons. .. autosummary:: :toctree: generated/ + assert_ assert_almost_equal assert_approx_equal assert_array_almost_equal + print_assert_equal Decorators ---------- @@ -60,6 +64,8 @@ Test Running :toctree: generated/ Tester + clear_and_catch_warnings + measure run_module_suite rundocs suppress_warnings diff --git a/doc/source/reference/security.rst b/doc/source/reference/security.rst new file mode 100644 index 000000000000..5b1e7b532dca --- /dev/null +++ b/doc/source/reference/security.rst @@ -0,0 +1,61 @@ +NumPy security +============== + +Security issues can be reported privately as described in the project README +and when opening a `new issue on the issue tracker `_. +The `Python security reporting guidelines `_ +are a good resource and its notes apply also to NumPy. + +NumPy's maintainers are not security experts. However, we are conscientious +about security and experts of both the NumPy codebase and how it's used. +Please do notify us before creating security advisories against NumPy as +we are happy to prioritize issues or help with assessing the severity of a bug. +A security advisory we are not aware of beforehand can lead to a lot of work +for all involved parties. + + +Advice for using NumPy on untrusted data +---------------------------------------- + +A user who can freely execute NumPy (or Python) functions must be considered +to have the same privilege as the process/Python interpreter. + +That said, NumPy should be generally safe to use on *data* provided by +unprivileged users and read through safe API functions (e.g. loaded from a +text file or ``.npy`` file without pickle support). +Malicious *values* or *data sizes* should never lead to privilege escalation. + +The following points may be useful or should be noted when working with +untrusted data: + +* Exhausting memory can result in an out-of-memory kill, which is a possible + denial of service attack. Possible causes could be: + + * Functions reading text files, which may require much more memory than + the original input file size. + * If users can create arbitrarily shaped arrays, NumPy's broadcasting means + that intermediate or result arrays can be much larger than the inputs. + +* NumPy structured dtypes allow for a large amount of complexity. Fortunately, + most code fails gracefully when a structured dtype is provided unexpectedly. + However, code should either disallow untrusted users to provide these + (e.g. via ``.npy`` files) or carefully check the fields included for + nested structured/subarray dtypes. + +* Passing on user input should generally be considered unsafe + (except for the data being read). + An example would be ``np.dtype(user_string)`` or ``dtype=user_string``. + +* The speed of operations can depend on values and memory order can lead to + larger temporary memory use and slower execution. + This means that operations may be significantly slower or use more memory + compared to simple test cases. + +* When reading data, consider enforcing a specific shape (e.g. one dimensional) + or dtype such as ``float64``, ``float32``, or ``int64`` to reduce complexity. + +When working with non-trivial untrusted data, it is advisable to sandbox the +analysis to guard against potential privilege escalation. +This is especially advisable if further libraries based on NumPy are used since +these add additional complexity and potential security issues. + diff --git a/doc/source/reference/simd/build-options.rst b/doc/source/reference/simd/build-options.rst new file mode 100644 index 000000000000..0994f15aa498 --- /dev/null +++ b/doc/source/reference/simd/build-options.rst @@ -0,0 +1,376 @@ +***************** +CPU build options +***************** + +Description +----------- + +The following options are mainly used to change the default behavior of optimizations +that target certain CPU features: + +- ``--cpu-baseline``: minimal set of required CPU features. + Default value is ``min`` which provides the minimum CPU features that can + safely run on a wide range of platforms within the processor family. + + .. note:: + + During the runtime, NumPy modules will fail to load if any of specified features + are not supported by the target CPU (raises Python runtime error). + +- ``--cpu-dispatch``: dispatched set of additional CPU features. + Default value is ``max -xop -fma4`` which enables all CPU + features, except for AMD legacy features (in case of X86). + + .. note:: + + During the runtime, NumPy modules will skip any specified features + that are not available in the target CPU. + +These options are accessible through :py:mod:`distutils` commands +`distutils.command.build`, `distutils.command.build_clib` and +`distutils.command.build_ext`. +They accept a set of :ref:`CPU features ` +or groups of features that gather several features or +:ref:`special options ` that +perform a series of procedures. + +.. note:: + + If ``build_clib`` or ``build_ext`` are not specified by the user, + the arguments of ``build`` will be used instead, which also holds the default values. + +To customize both ``build_ext`` and ``build_clib``:: + + cd /path/to/numpy + python setup.py build --cpu-baseline="avx2 fma3" install --user + +To customize only ``build_ext``:: + + cd /path/to/numpy + python setup.py build_ext --cpu-baseline="avx2 fma3" install --user + +To customize only ``build_clib``:: + + cd /path/to/numpy + python setup.py build_clib --cpu-baseline="avx2 fma3" install --user + +You can also customize CPU/build options through PIP command:: + + pip install --no-use-pep517 --global-option=build \ + --global-option="--cpu-baseline=avx2 fma3" \ + --global-option="--cpu-dispatch=max" ./ + +Quick Start +----------- + +In general, the default settings tend to not impose certain CPU features that +may not be available on some older processors. Raising the ceiling of the +baseline features will often improve performance and may also reduce +binary size. + + +The following are the most common scenarios that may require changing +the default settings: + + +I am building NumPy for my local use +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +And I do not intend to export the build to other users or target a +different CPU than what the host has. + +Set `native` for baseline, or manually specify the CPU features in case of option +`native` isn't supported by your platform:: + + python setup.py build --cpu-baseline="native" bdist + +Building NumPy with extra CPU features isn't necessary for this case, +since all supported features are already defined within the baseline features:: + + python setup.py build --cpu-baseline=native --cpu-dispatch=none bdist + +.. note:: + + A fatal error will be raised if `native` isn't supported by the host platform. + +I do not want to support the old processors of the `x86` architecture +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Since most of the CPUs nowadays support at least `AVX`, `F16C` features, you can use:: + + python setup.py build --cpu-baseline="avx f16c" bdist + +.. note:: + + ``--cpu-baseline`` force combine all implied features, so there's no need + to add SSE features. + + +I'm facing the same case above but with `ppc64` architecture +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Then raise the ceiling of the baseline features to Power8:: + + python setup.py build --cpu-baseline="vsx2" bdist + +Having issues with `AVX512` features? +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +You may have some reservations about including of `AVX512` or +any other CPU feature and you want to exclude from the dispatched features:: + + python setup.py build --cpu-dispatch="max -avx512f -avx512cd \ + -avx512_knl -avx512_knm -avx512_skx -avx512_clx -avx512_cnl -avx512_icl" \ + bdist + +.. _opt-supported-features: + +Supported Features +------------------ + +The names of the features can express one feature or a group of features, +as shown in the following tables supported depend on the lowest interest: + +.. note:: + + The following features may not be supported by all compilers, + also some compilers may produce different set of implied features + when it comes to features like ``AVX512``, ``AVX2``, and ``FMA3``. + See :ref:`opt-platform-differences` for more details. + +.. include:: generated_tables/cpu_features.inc + +.. _opt-special-options: + +Special Options +--------------- + +- ``NONE``: enable no features. + +- ``NATIVE``: Enables all CPU features that supported by the host CPU, + this operation is based on the compiler flags (``-march=native``, ``-xHost``, ``/QxHost``) + +- ``MIN``: Enables the minimum CPU features that can safely run on a wide range of platforms: + + .. table:: + :align: left + + ====================================== ======================================= + For Arch Implies + ====================================== ======================================= + x86 (32-bit mode) ``SSE`` ``SSE2`` + x86_64 ``SSE`` ``SSE2`` ``SSE3`` + IBM/POWER (big-endian mode) ``NONE`` + IBM/POWER (little-endian mode) ``VSX`` ``VSX2`` + ARMHF ``NONE`` + ARM64 A.K. AARCH64 ``NEON`` ``NEON_FP16`` ``NEON_VFPV4`` + ``ASIMD`` + IBM/ZSYSTEM(S390X) ``NONE`` + ====================================== ======================================= + +- ``MAX``: Enables all supported CPU features by the compiler and platform. + +- ``Operators-/+``: remove or add features, useful with options ``MAX``, ``MIN`` and ``NATIVE``. + +Behaviors +--------- + +- CPU features and other options are case-insensitive, for example:: + + python setup.py build --cpu-dispatch="SSE41 avx2 FMA3" + +- The order of the requested optimizations doesn't matter:: + + python setup.py build --cpu-dispatch="SSE41 AVX2 FMA3" + # equivalent to + python setup.py build --cpu-dispatch="FMA3 AVX2 SSE41" + +- Either commas or spaces or '+' can be used as a separator, + for example:: + + python setup.py build --cpu-dispatch="avx2 avx512f" + # or + python setup.py build --cpu-dispatch=avx2,avx512f + # or + python setup.py build --cpu-dispatch="avx2+avx512f" + + all works but arguments should be enclosed in quotes or escaped + by backslash if any spaces are used. + +- ``--cpu-baseline`` combines all implied CPU features, for example:: + + python setup.py build --cpu-baseline=sse42 + # equivalent to + python setup.py build --cpu-baseline="sse sse2 sse3 ssse3 sse41 popcnt sse42" + +- ``--cpu-baseline`` will be treated as "native" if compiler native flag + ``-march=native`` or ``-xHost`` or ``/QxHost`` is enabled through environment variable + `CFLAGS`:: + + export CFLAGS="-march=native" + python setup.py install --user + # is equivalent to + python setup.py build --cpu-baseline=native install --user + +- ``--cpu-baseline`` escapes any specified features that aren't supported + by the target platform or compiler rather than raising fatal errors. + + .. note:: + + Since ``--cpu-baseline`` combines all implied features, the maximum + supported of implied features will be enabled rather than escape all of them. + For example:: + + # Requesting `AVX2,FMA3` but the compiler only support **SSE** features + python setup.py build --cpu-baseline="avx2 fma3" + # is equivalent to + python setup.py build --cpu-baseline="sse sse2 sse3 ssse3 sse41 popcnt sse42" + +- ``--cpu-dispatch`` does not combain any of implied CPU features, + so you must add them unless you want to disable one or all of them:: + + # Only dispatches AVX2 and FMA3 + python setup.py build --cpu-dispatch=avx2,fma3 + # Dispatches AVX and SSE features + python setup.py build --cpu-baseline=ssse3,sse41,sse42,avx,avx2,fma3 + +- ``--cpu-dispatch`` escapes any specified baseline features and also escapes + any features not supported by the target platform or compiler without raising + fatal errors. + +Eventually, you should always check the final report through the build log +to verify the enabled features. See :ref:`opt-build-report` for more details. + +.. _opt-platform-differences: + +Platform differences +-------------------- + +Some exceptional conditions force us to link some features together when it come to +certain compilers or architectures, resulting in the impossibility of building them separately. + +These conditions can be divided into two parts, as follows: + +**Architectural compatibility** + +The need to align certain CPU features that are assured to be supported by +successive generations of the same architecture, some cases: + +- On ppc64le ``VSX(ISA 2.06)`` and ``VSX2(ISA 2.07)`` both imply one another since the + first generation that supports little-endian mode is Power-8`(ISA 2.07)` +- On AArch64 ``NEON NEON_FP16 NEON_VFPV4 ASIMD`` implies each other since they are part of the + hardware baseline. + +For example:: + + # On ARMv8/A64, specify NEON is going to enable Advanced SIMD + # and all predecessor extensions + python setup.py build --cpu-baseline=neon + # which equivalent to + python setup.py build --cpu-baseline="neon neon_fp16 neon_vfpv4 asimd" + +.. note:: + + Please take a deep look at :ref:`opt-supported-features`, + in order to determine the features that imply one another. + +**Compilation compatibility** + +Some compilers don't provide independent support for all CPU features. For instance +**Intel**'s compiler doesn't provide separated flags for ``AVX2`` and ``FMA3``, +it makes sense since all Intel CPUs that comes with ``AVX2`` also support ``FMA3``, +but this approach is incompatible with other **x86** CPUs from **AMD** or **VIA**. + +For example:: + + # Specify AVX2 will force enables FMA3 on Intel compilers + python setup.py build --cpu-baseline=avx2 + # which equivalent to + python setup.py build --cpu-baseline="avx2 fma3" + + +The following tables only show the differences imposed by some compilers from the +general context that been shown in the :ref:`opt-supported-features` tables: + +.. note:: + + Features names with strikeout represent the unsupported CPU features. + +.. raw:: html + + + +.. role:: enabled + :class: enabled-feature + +.. role:: disabled + :class: disabled-feature + +.. include:: generated_tables/compilers-diff.inc + +.. _opt-build-report: + +Build report +------------ + +In most cases, the CPU build options do not produce any fatal errors that lead to hanging the build. +Most of the errors that may appear in the build log serve as heavy warnings due to the lack of some +expected CPU features by the compiler. + +So we strongly recommend checking the final report log, to be aware of what kind of CPU features +are enabled and what are not. + +You can find the final report of CPU optimizations at the end of the build log, +and here is how it looks on x86_64/gcc: + +.. raw:: html + + + +.. literalinclude:: log_example.txt + :language: bash + +As you see, there is a separate report for each of ``build_ext`` and ``build_clib`` +that includes several sections, and each section has several values, representing the following: + +**Platform**: + +- :enabled:`Architecture`: The architecture name of target CPU. It should be one of + ``x86``, ``x64``, ``ppc64``, ``ppc64le``, ``armhf``, ``aarch64``, ``s390x`` or ``unknown``. + +- :enabled:`Compiler`: The compiler name. It should be one of + gcc, clang, msvc, icc, iccw or unix-like. + +**CPU baseline**: + +- :enabled:`Requested`: The specific features and options to ``--cpu-baseline`` as-is. +- :enabled:`Enabled`: The final set of enabled CPU features. +- :enabled:`Flags`: The compiler flags that were used to all NumPy `C/C++` sources + during the compilation except for temporary sources that have been used for generating + the binary objects of dispatched features. +- :enabled:`Extra checks`: list of internal checks that activate certain functionality + or intrinsics related to the enabled features, useful for debugging when it comes + to developing SIMD kernels. + +**CPU dispatch**: + +- :enabled:`Requested`: The specific features and options to ``--cpu-dispatch`` as-is. +- :enabled:`Enabled`: The final set of enabled CPU features. +- :enabled:`Generated`: At the beginning of the next row of this property, + the features for which optimizations have been generated are shown in the + form of several sections with similar properties explained as follows: + + - :enabled:`One or multiple dispatched feature`: The implied CPU features. + - :enabled:`Flags`: The compiler flags that been used for these features. + - :enabled:`Extra checks`: Similar to the baseline but for these dispatched features. + - :enabled:`Detect`: Set of CPU features that need be detected in runtime in order to + execute the generated optimizations. + - The lines that come after the above property and end with a ':' on a separate line, + represent the paths of c/c++ sources that define the generated optimizations. + +Runtime Trace +------------- +To be completed. diff --git a/doc/source/reference/simd/gen_features.py b/doc/source/reference/simd/gen_features.py new file mode 100644 index 000000000000..9a38ef5c9ba2 --- /dev/null +++ b/doc/source/reference/simd/gen_features.py @@ -0,0 +1,196 @@ +""" +Generate CPU features tables from CCompilerOpt +""" +from os import sys, path +from numpy.distutils.ccompiler_opt import CCompilerOpt + +class FakeCCompilerOpt(CCompilerOpt): + # disable caching no need for it + conf_nocache = True + + def __init__(self, arch, cc, *args, **kwargs): + self.fake_info = (arch, cc, '') + CCompilerOpt.__init__(self, None, **kwargs) + + def dist_compile(self, sources, flags, **kwargs): + return sources + + def dist_info(self): + return self.fake_info + + @staticmethod + def dist_log(*args, stderr=False): + # avoid printing + pass + + def feature_test(self, name, force_flags=None, macros=[]): + # To speed up + return True + +class Features: + def __init__(self, arch, cc): + self.copt = FakeCCompilerOpt(arch, cc, cpu_baseline="max") + + def names(self): + return self.copt.cpu_baseline_names() + + def serialize(self, features_names): + result = [] + for f in self.copt.feature_sorted(features_names): + gather = self.copt.feature_supported.get(f, {}).get("group", []) + implies = self.copt.feature_sorted(self.copt.feature_implies(f)) + result.append((f, implies, gather)) + return result + + def table(self, **kwargs): + return self.gen_table(self.serialize(self.names()), **kwargs) + + def table_diff(self, vs, **kwargs): + fnames = set(self.names()) + fnames_vs = set(vs.names()) + common = fnames.intersection(fnames_vs) + extra = fnames.difference(fnames_vs) + notavl = fnames_vs.difference(fnames) + iextra = {} + inotavl = {} + idiff = set() + for f in common: + implies = self.copt.feature_implies(f) + implies_vs = vs.copt.feature_implies(f) + e = implies.difference(implies_vs) + i = implies_vs.difference(implies) + if not i and not e: + continue + if e: + iextra[f] = e + if i: + inotavl[f] = e + idiff.add(f) + + def fbold(f): + if f in extra: + return f':enabled:`{f}`' + if f in notavl: + return f':disabled:`{f}`' + return f + + def fbold_implies(f, i): + if i in iextra.get(f, {}): + return f':enabled:`{i}`' + if f in notavl or i in inotavl.get(f, {}): + return f':disabled:`{i}`' + return i + + diff_all = self.serialize(idiff.union(extra)) + diff_all += vs.serialize(notavl) + content = self.gen_table( + diff_all, fstyle=fbold, fstyle_implies=fbold_implies, **kwargs + ) + return content + + def gen_table(self, serialized_features, fstyle=None, fstyle_implies=None, + **kwargs): + + if fstyle is None: + fstyle = lambda ft: f'``{ft}``' + if fstyle_implies is None: + fstyle_implies = lambda origin, ft: fstyle(ft) + + rows = [] + have_gather = False + for f, implies, gather in serialized_features: + if gather: + have_gather = True + name = fstyle(f) + implies = ' '.join([fstyle_implies(f, i) for i in implies]) + gather = ' '.join([fstyle_implies(f, i) for i in gather]) + rows.append((name, implies, gather)) + if not rows: + return '' + fields = ["Name", "Implies", "Gathers"] + if not have_gather: + del fields[2] + rows = [(name, implies) for name, implies, _ in rows] + return self.gen_rst_table(fields, rows, **kwargs) + + def gen_rst_table(self, field_names, rows, tab_size=4): + assert(not rows or len(field_names) == len(rows[0])) + rows.append(field_names) + fld_len = len(field_names) + cls_len = [max(len(c[i]) for c in rows) for i in range(fld_len)] + del rows[-1] + cformat = ' '.join('{:<%d}' % i for i in cls_len) + border = cformat.format(*['='*i for i in cls_len]) + + rows = [cformat.format(*row) for row in rows] + # header + rows = [border, cformat.format(*field_names), border] + rows + # footer + rows += [border] + # add left margin + rows = [(' ' * tab_size) + r for r in rows] + return '\n'.join(rows) + +def wrapper_section(title, content, tab_size=4): + tab = ' '*tab_size + if content: + return ( + f"{title}\n{'~'*len(title)}" + f"\n.. table::\n{tab}:align: left\n\n" + f"{content}\n\n" + ) + return '' + +def wrapper_tab(title, table, tab_size=4): + tab = ' '*tab_size + if table: + ('\n' + tab).join(( + '.. tab:: ' + title, + tab + '.. table::', + tab + 'align: left', + table + '\n\n' + )) + return '' + + +if __name__ == '__main__': + + pretty_names = { + "PPC64": "IBM/POWER big-endian", + "PPC64LE": "IBM/POWER little-endian", + "S390X": "IBM/ZSYSTEM(S390X)", + "ARMHF": "ARMv7/A32", + "AARCH64": "ARMv8/A64", + "ICC": "Intel Compiler", + # "ICCW": "Intel Compiler msvc-like", + "MSVC": "Microsoft Visual C/C++" + } + gen_path = path.join( + path.dirname(path.realpath(__file__)), "generated_tables" + ) + with open(path.join(gen_path, 'cpu_features.inc'), 'wt') as fd: + fd.write(f'.. generated via {__file__}\n\n') + for arch in ( + ("x86", "PPC64", "PPC64LE", "ARMHF", "AARCH64", "S390X") + ): + title = "On " + pretty_names.get(arch, arch) + table = Features(arch, 'gcc').table() + fd.write(wrapper_section(title, table)) + + with open(path.join(gen_path, 'compilers-diff.inc'), 'wt') as fd: + fd.write(f'.. generated via {__file__}\n\n') + for arch, cc_names in ( + ("x86", ("clang", "ICC", "MSVC")), + ("PPC64", ("clang",)), + ("PPC64LE", ("clang",)), + ("ARMHF", ("clang",)), + ("AARCH64", ("clang",)), + ("S390X", ("clang",)) + ): + arch_pname = pretty_names.get(arch, arch) + for cc in cc_names: + title = f"On {arch_pname}::{pretty_names.get(cc, cc)}" + table = Features(arch, cc).table_diff(Features(arch, "gcc")) + fd.write(wrapper_section(title, table)) + + diff --git a/doc/source/reference/simd/generated_tables/compilers-diff.inc b/doc/source/reference/simd/generated_tables/compilers-diff.inc new file mode 100644 index 000000000000..4b9009a684da --- /dev/null +++ b/doc/source/reference/simd/generated_tables/compilers-diff.inc @@ -0,0 +1,33 @@ +.. generated via /home/seiko/work/repos/numpy/doc/source/reference/simd/./gen_features.py + +On x86::Intel Compiler +~~~~~~~~~~~~~~~~~~~~~~ +.. table:: + :align: left + + ================ ========================================================================================================================================== + Name Implies + ================ ========================================================================================================================================== + FMA3 SSE SSE2 SSE3 SSSE3 SSE41 POPCNT SSE42 AVX F16C :enabled:`AVX2` + AVX2 SSE SSE2 SSE3 SSSE3 SSE41 POPCNT SSE42 AVX F16C :enabled:`FMA3` + AVX512F SSE SSE2 SSE3 SSSE3 SSE41 POPCNT SSE42 AVX F16C FMA3 AVX2 :enabled:`AVX512CD` + :disabled:`XOP` :disabled:`SSE` :disabled:`SSE2` :disabled:`SSE3` :disabled:`SSSE3` :disabled:`SSE41` :disabled:`POPCNT` :disabled:`SSE42` :disabled:`AVX` + :disabled:`FMA4` :disabled:`SSE` :disabled:`SSE2` :disabled:`SSE3` :disabled:`SSSE3` :disabled:`SSE41` :disabled:`POPCNT` :disabled:`SSE42` :disabled:`AVX` + ================ ========================================================================================================================================== + +On x86::Microsoft Visual C/C++ +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +.. table:: + :align: left + + ====================== ============================================================================================================================================================================================================================================================= ============================================================================= + Name Implies Gathers + ====================== ============================================================================================================================================================================================================================================================= ============================================================================= + FMA3 SSE SSE2 SSE3 SSSE3 SSE41 POPCNT SSE42 AVX F16C :enabled:`AVX2` + AVX2 SSE SSE2 SSE3 SSSE3 SSE41 POPCNT SSE42 AVX F16C :enabled:`FMA3` + AVX512F SSE SSE2 SSE3 SSSE3 SSE41 POPCNT SSE42 AVX F16C FMA3 AVX2 :enabled:`AVX512CD` :enabled:`AVX512_SKX` + AVX512CD SSE SSE2 SSE3 SSSE3 SSE41 POPCNT SSE42 AVX F16C FMA3 AVX2 AVX512F :enabled:`AVX512_SKX` + :disabled:`AVX512_KNL` :disabled:`SSE` :disabled:`SSE2` :disabled:`SSE3` :disabled:`SSSE3` :disabled:`SSE41` :disabled:`POPCNT` :disabled:`SSE42` :disabled:`AVX` :disabled:`F16C` :disabled:`FMA3` :disabled:`AVX2` :disabled:`AVX512F` :disabled:`AVX512CD` :disabled:`AVX512ER` :disabled:`AVX512PF` + :disabled:`AVX512_KNM` :disabled:`SSE` :disabled:`SSE2` :disabled:`SSE3` :disabled:`SSSE3` :disabled:`SSE41` :disabled:`POPCNT` :disabled:`SSE42` :disabled:`AVX` :disabled:`F16C` :disabled:`FMA3` :disabled:`AVX2` :disabled:`AVX512F` :disabled:`AVX512CD` :disabled:`AVX512_KNL` :disabled:`AVX5124FMAPS` :disabled:`AVX5124VNNIW` :disabled:`AVX512VPOPCNTDQ` + ====================== ============================================================================================================================================================================================================================================================= ============================================================================= + diff --git a/doc/source/reference/simd/generated_tables/cpu_features.inc b/doc/source/reference/simd/generated_tables/cpu_features.inc new file mode 100644 index 000000000000..7782172d288c --- /dev/null +++ b/doc/source/reference/simd/generated_tables/cpu_features.inc @@ -0,0 +1,108 @@ +.. generated via /home/seiko/work/repos/review/numpy/doc/source/reference/simd/gen_features.py + +On x86 +~~~~~~ +.. table:: + :align: left + + ============== =========================================================================================================================================================================== ===================================================== + Name Implies Gathers + ============== =========================================================================================================================================================================== ===================================================== + ``SSE`` ``SSE2`` + ``SSE2`` ``SSE`` + ``SSE3`` ``SSE`` ``SSE2`` + ``SSSE3`` ``SSE`` ``SSE2`` ``SSE3`` + ``SSE41`` ``SSE`` ``SSE2`` ``SSE3`` ``SSSE3`` + ``POPCNT`` ``SSE`` ``SSE2`` ``SSE3`` ``SSSE3`` ``SSE41`` + ``SSE42`` ``SSE`` ``SSE2`` ``SSE3`` ``SSSE3`` ``SSE41`` ``POPCNT`` + ``AVX`` ``SSE`` ``SSE2`` ``SSE3`` ``SSSE3`` ``SSE41`` ``POPCNT`` ``SSE42`` + ``XOP`` ``SSE`` ``SSE2`` ``SSE3`` ``SSSE3`` ``SSE41`` ``POPCNT`` ``SSE42`` ``AVX`` + ``FMA4`` ``SSE`` ``SSE2`` ``SSE3`` ``SSSE3`` ``SSE41`` ``POPCNT`` ``SSE42`` ``AVX`` + ``F16C`` ``SSE`` ``SSE2`` ``SSE3`` ``SSSE3`` ``SSE41`` ``POPCNT`` ``SSE42`` ``AVX`` + ``FMA3`` ``SSE`` ``SSE2`` ``SSE3`` ``SSSE3`` ``SSE41`` ``POPCNT`` ``SSE42`` ``AVX`` ``F16C`` + ``AVX2`` ``SSE`` ``SSE2`` ``SSE3`` ``SSSE3`` ``SSE41`` ``POPCNT`` ``SSE42`` ``AVX`` ``F16C`` + ``AVX512F`` ``SSE`` ``SSE2`` ``SSE3`` ``SSSE3`` ``SSE41`` ``POPCNT`` ``SSE42`` ``AVX`` ``F16C`` ``FMA3`` ``AVX2`` + ``AVX512CD`` ``SSE`` ``SSE2`` ``SSE3`` ``SSSE3`` ``SSE41`` ``POPCNT`` ``SSE42`` ``AVX`` ``F16C`` ``FMA3`` ``AVX2`` ``AVX512F`` + ``AVX512_KNL`` ``SSE`` ``SSE2`` ``SSE3`` ``SSSE3`` ``SSE41`` ``POPCNT`` ``SSE42`` ``AVX`` ``F16C`` ``FMA3`` ``AVX2`` ``AVX512F`` ``AVX512CD`` ``AVX512ER`` ``AVX512PF`` + ``AVX512_KNM`` ``SSE`` ``SSE2`` ``SSE3`` ``SSSE3`` ``SSE41`` ``POPCNT`` ``SSE42`` ``AVX`` ``F16C`` ``FMA3`` ``AVX2`` ``AVX512F`` ``AVX512CD`` ``AVX512_KNL`` ``AVX5124FMAPS`` ``AVX5124VNNIW`` ``AVX512VPOPCNTDQ`` + ``AVX512_SKX`` ``SSE`` ``SSE2`` ``SSE3`` ``SSSE3`` ``SSE41`` ``POPCNT`` ``SSE42`` ``AVX`` ``F16C`` ``FMA3`` ``AVX2`` ``AVX512F`` ``AVX512CD`` ``AVX512VL`` ``AVX512BW`` ``AVX512DQ`` + ``AVX512_CLX`` ``SSE`` ``SSE2`` ``SSE3`` ``SSSE3`` ``SSE41`` ``POPCNT`` ``SSE42`` ``AVX`` ``F16C`` ``FMA3`` ``AVX2`` ``AVX512F`` ``AVX512CD`` ``AVX512_SKX`` ``AVX512VNNI`` + ``AVX512_CNL`` ``SSE`` ``SSE2`` ``SSE3`` ``SSSE3`` ``SSE41`` ``POPCNT`` ``SSE42`` ``AVX`` ``F16C`` ``FMA3`` ``AVX2`` ``AVX512F`` ``AVX512CD`` ``AVX512_SKX`` ``AVX512IFMA`` ``AVX512VBMI`` + ``AVX512_ICL`` ``SSE`` ``SSE2`` ``SSE3`` ``SSSE3`` ``SSE41`` ``POPCNT`` ``SSE42`` ``AVX`` ``F16C`` ``FMA3`` ``AVX2`` ``AVX512F`` ``AVX512CD`` ``AVX512_SKX`` ``AVX512_CLX`` ``AVX512_CNL`` ``AVX512VBMI2`` ``AVX512BITALG`` ``AVX512VPOPCNTDQ`` + ============== =========================================================================================================================================================================== ===================================================== + +On IBM/POWER big-endian +~~~~~~~~~~~~~~~~~~~~~~~ +.. table:: + :align: left + + ======== ========================= + Name Implies + ======== ========================= + ``VSX`` + ``VSX2`` ``VSX`` + ``VSX3`` ``VSX`` ``VSX2`` + ``VSX4`` ``VSX`` ``VSX2`` ``VSX3`` + ======== ========================= + +On IBM/POWER little-endian +~~~~~~~~~~~~~~~~~~~~~~~~~~ +.. table:: + :align: left + + ======== ========================= + Name Implies + ======== ========================= + ``VSX`` ``VSX2`` + ``VSX2`` ``VSX`` + ``VSX3`` ``VSX`` ``VSX2`` + ``VSX4`` ``VSX`` ``VSX2`` ``VSX3`` + ======== ========================= + +On ARMv7/A32 +~~~~~~~~~~~~ +.. table:: + :align: left + + ============== =========================================================== + Name Implies + ============== =========================================================== + ``NEON`` + ``NEON_FP16`` ``NEON`` + ``NEON_VFPV4`` ``NEON`` ``NEON_FP16`` + ``ASIMD`` ``NEON`` ``NEON_FP16`` ``NEON_VFPV4`` + ``ASIMDHP`` ``NEON`` ``NEON_FP16`` ``NEON_VFPV4`` ``ASIMD`` + ``ASIMDDP`` ``NEON`` ``NEON_FP16`` ``NEON_VFPV4`` ``ASIMD`` + ``ASIMDFHM`` ``NEON`` ``NEON_FP16`` ``NEON_VFPV4`` ``ASIMD`` ``ASIMDHP`` + ============== =========================================================== + +On ARMv8/A64 +~~~~~~~~~~~~ +.. table:: + :align: left + + ============== =========================================================== + Name Implies + ============== =========================================================== + ``NEON`` ``NEON_FP16`` ``NEON_VFPV4`` ``ASIMD`` + ``NEON_FP16`` ``NEON`` ``NEON_VFPV4`` ``ASIMD`` + ``NEON_VFPV4`` ``NEON`` ``NEON_FP16`` ``ASIMD`` + ``ASIMD`` ``NEON`` ``NEON_FP16`` ``NEON_VFPV4`` + ``ASIMDHP`` ``NEON`` ``NEON_FP16`` ``NEON_VFPV4`` ``ASIMD`` + ``ASIMDDP`` ``NEON`` ``NEON_FP16`` ``NEON_VFPV4`` ``ASIMD`` + ``ASIMDFHM`` ``NEON`` ``NEON_FP16`` ``NEON_VFPV4`` ``ASIMD`` ``ASIMDHP`` + ============== =========================================================== + +On IBM/ZSYSTEM(S390X) +~~~~~~~~~~~~~~~~~~~~~ +.. table:: + :align: left + + ======== ============== + Name Implies + ======== ============== + ``VX`` + ``VXE`` ``VX`` + ``VXE2`` ``VX`` ``VXE`` + ======== ============== + diff --git a/doc/source/reference/simd/how-it-works.rst b/doc/source/reference/simd/how-it-works.rst new file mode 100644 index 000000000000..19b3dba45692 --- /dev/null +++ b/doc/source/reference/simd/how-it-works.rst @@ -0,0 +1,349 @@ +********************************** +How does the CPU dispatcher work? +********************************** + +NumPy dispatcher is based on multi-source compiling, which means taking +a certain source and compiling it multiple times with different compiler +flags and also with different **C** definitions that affect the code +paths. This enables certain instruction-sets for each compiled object +depending on the required optimizations and ends with linking the +returned objects together. + +.. figure:: ../figures/opt-infra.png + +This mechanism should support all compilers and it doesn't require any +compiler-specific extension, but at the same time it adds a few steps to +normal compilation that are explained as follows. + +1- Configuration +~~~~~~~~~~~~~~~~ + +Configuring the required optimization by the user before starting to build the +source files via the two command arguments as explained above: + +- ``--cpu-baseline``: minimal set of required optimizations. + +- ``--cpu-dispatch``: dispatched set of additional optimizations. + + +2- Discovering the environment +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +In this part, we check the compiler and platform architecture +and cache some of the intermediary results to speed up rebuilding. + +3- Validating the requested optimizations +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +By testing them against the compiler, and seeing what the compiler can +support according to the requested optimizations. + +4- Generating the main configuration header +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +The generated header ``_cpu_dispatch.h`` contains all the definitions and +headers of instruction-sets for the required optimizations that have been +validated during the previous step. + +It also contains extra C definitions that are used for defining NumPy's +Python-level module attributes ``__cpu_baseline__`` and ``__cpu_dispatch__``. + +**What is in this header?** + +The example header was dynamically generated by gcc on an X86 machine. +The compiler supports ``--cpu-baseline="sse sse2 sse3"`` and +``--cpu-dispatch="ssse3 sse41"``, and the result is below. + +.. code:: c + + // The header should be located at numpy/numpy/core/src/common/_cpu_dispatch.h + /**NOTE + ** C definitions prefixed with "NPY_HAVE_" represent + ** the required optimizations. + ** + ** C definitions prefixed with 'NPY__CPU_TARGET_' are protected and + ** shouldn't be used by any NumPy C sources. + */ + /******* baseline features *******/ + /** SSE **/ + #define NPY_HAVE_SSE 1 + #include + /** SSE2 **/ + #define NPY_HAVE_SSE2 1 + #include + /** SSE3 **/ + #define NPY_HAVE_SSE3 1 + #include + + /******* dispatch-able features *******/ + #ifdef NPY__CPU_TARGET_SSSE3 + /** SSSE3 **/ + #define NPY_HAVE_SSSE3 1 + #include + #endif + #ifdef NPY__CPU_TARGET_SSE41 + /** SSE41 **/ + #define NPY_HAVE_SSE41 1 + #include + #endif + +**Baseline features** are the minimal set of required optimizations configured +via ``--cpu-baseline``. They have no preprocessor guards and they're +always on, which means they can be used in any source. + +Does this mean NumPy's infrastructure passes the compiler's flags of +baseline features to all sources? + +Definitely, yes. But the :ref:`dispatch-able sources ` are +treated differently. + +What if the user specifies certain **baseline features** during the +build but at runtime the machine doesn't support even these +features? Will the compiled code be called via one of these definitions, or +maybe the compiler itself auto-generated/vectorized certain piece of code +based on the provided command line compiler flags? + +During the loading of the NumPy module, there's a validation step +which detects this behavior. It will raise a Python runtime error to inform the +user. This is to prevent the CPU reaching an illegal instruction error causing +a segfault. + +**Dispatch-able features** are our dispatched set of additional optimizations +that were configured via ``--cpu-dispatch``. They are not activated by +default and are always guarded by other C definitions prefixed with +``NPY__CPU_TARGET_``. C definitions ``NPY__CPU_TARGET_`` are only +enabled within **dispatch-able sources**. + +.. _dispatchable-sources: + +5- Dispatch-able sources and configuration statements +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Dispatch-able sources are special **C** files that can be compiled multiple +times with different compiler flags and also with different **C** +definitions. These affect code paths to enable certain +instruction-sets for each compiled object according to "**the +configuration statements**" that must be declared between a **C** +comment\ ``(/**/)`` and start with a special mark **@targets** at the +top of each dispatch-able source. At the same time, dispatch-able +sources will be treated as normal **C** sources if the optimization was +disabled by the command argument ``--disable-optimization`` . + +**What are configuration statements?** + +Configuration statements are sort of keywords combined together to +determine the required optimization for the dispatch-able source. + +Example: + +.. code:: c + + /*@targets avx2 avx512f vsx2 vsx3 asimd asimdhp */ + // C code + +The keywords mainly represent the additional optimizations configured +through ``--cpu-dispatch``, but it can also represent other options such as: + +- Target groups: pre-configured configuration statements used for + managing the required optimizations from outside the dispatch-able source. + +- Policies: collections of options used for changing the default + behaviors or forcing the compilers to perform certain things. + +- "baseline": a unique keyword represents the minimal optimizations + that configured through ``--cpu-baseline`` + +**Numpy's infrastructure handles dispatch-able sources in four steps**: + +- **(A) Recognition**: Just like source templates and F2PY, the + dispatch-able sources requires a special extension ``*.dispatch.c`` + to mark C dispatch-able source files, and for C++ + ``*.dispatch.cpp`` or ``*.dispatch.cxx`` + **NOTE**: C++ not supported yet. + +- **(B) Parsing and validating**: In this step, the + dispatch-able sources that had been filtered by the previous step + are parsed and validated by the configuration statements for each one + of them one by one in order to determine the required optimizations. + +- **(C) Wrapping**: This is the approach taken by NumPy's + infrastructure, which has proved to be sufficiently flexible in order + to compile a single source multiple times with different **C** + definitions and flags that affect the code paths. The process is + achieved by creating a temporary **C** source for each required + optimization that related to the additional optimization, which + contains the declarations of the **C** definitions and includes the + involved source via the **C** directive **#include**. For more + clarification take a look at the following code for AVX512F : + + .. code:: c + + /* + * this definition is used by NumPy utilities as suffixes for the + * exported symbols + */ + #define NPY__CPU_TARGET_CURRENT AVX512F + /* + * The following definitions enable + * definitions of the dispatch-able features that are defined within the main + * configuration header. These are definitions for the implied features. + */ + #define NPY__CPU_TARGET_SSE + #define NPY__CPU_TARGET_SSE2 + #define NPY__CPU_TARGET_SSE3 + #define NPY__CPU_TARGET_SSSE3 + #define NPY__CPU_TARGET_SSE41 + #define NPY__CPU_TARGET_POPCNT + #define NPY__CPU_TARGET_SSE42 + #define NPY__CPU_TARGET_AVX + #define NPY__CPU_TARGET_F16C + #define NPY__CPU_TARGET_FMA3 + #define NPY__CPU_TARGET_AVX2 + #define NPY__CPU_TARGET_AVX512F + // our dispatch-able source + #include "/the/absuolate/path/of/hello.dispatch.c" + +- **(D) Dispatch-able configuration header**: The infrastructure + generates a config header for each dispatch-able source, this header + mainly contains two abstract **C** macros used for identifying the + generated objects, so they can be used for runtime dispatching + certain symbols from the generated objects by any **C** source. It is + also used for forward declarations. + + The generated header takes the name of the dispatch-able source after + excluding the extension and replace it with ``.h``, for example + assume we have a dispatch-able source called ``hello.dispatch.c`` and + contains the following: + + .. code:: c + + // hello.dispatch.c + /*@targets baseline sse42 avx512f */ + #include + #include "numpy/utils.h" // NPY_CAT, NPY_TOSTR + + #ifndef NPY__CPU_TARGET_CURRENT + // wrapping the dispatch-able source only happens to the additional optimizations + // but if the keyword 'baseline' provided within the configuration statements, + // the infrastructure will add extra compiling for the dispatch-able source by + // passing it as-is to the compiler without any changes. + #define CURRENT_TARGET(X) X + #define NPY__CPU_TARGET_CURRENT baseline // for printing only + #else + // since we reach to this point, that's mean we're dealing with + // the additional optimizations, so it could be SSE42 or AVX512F + #define CURRENT_TARGET(X) NPY_CAT(NPY_CAT(X, _), NPY__CPU_TARGET_CURRENT) + #endif + // Macro 'CURRENT_TARGET' adding the current target as suffux to the exported symbols, + // to avoid linking duplications, NumPy already has a macro called + // 'NPY_CPU_DISPATCH_CURFX' similar to it, located at + // numpy/numpy/core/src/common/npy_cpu_dispatch.h + // NOTE: we tend to not adding suffixes to the baseline exported symbols + void CURRENT_TARGET(simd_whoami)(const char *extra_info) + { + printf("I'm " NPY_TOSTR(NPY__CPU_TARGET_CURRENT) ", %s\n", extra_info); + } + + Now assume you attached **hello.dispatch.c** to the source tree, then + the infrastructure should generate a temporary config header called + **hello.dispatch.h** that can be reached by any source in the source + tree, and it should contain the following code : + + .. code:: c + + #ifndef NPY__CPU_DISPATCH_EXPAND_ + // To expand the macro calls in this header + #define NPY__CPU_DISPATCH_EXPAND_(X) X + #endif + // Undefining the following macros, due to the possibility of including config headers + // multiple times within the same source and since each config header represents + // different required optimizations according to the specified configuration + // statements in the dispatch-able source that derived from it. + #undef NPY__CPU_DISPATCH_BASELINE_CALL + #undef NPY__CPU_DISPATCH_CALL + // nothing strange here, just a normal preprocessor callback + // enabled only if 'baseline' specified within the configuration statements + #define NPY__CPU_DISPATCH_BASELINE_CALL(CB, ...) \ + NPY__CPU_DISPATCH_EXPAND_(CB(__VA_ARGS__)) + // 'NPY__CPU_DISPATCH_CALL' is an abstract macro is used for dispatching + // the required optimizations that specified within the configuration statements. + // + // @param CHK, Expected a macro that can be used to detect CPU features + // in runtime, which takes a CPU feature name without string quotes and + // returns the testing result in a shape of boolean value. + // NumPy already has macro called "NPY_CPU_HAVE", which fits this requirement. + // + // @param CB, a callback macro that expected to be called multiple times depending + // on the required optimizations, the callback should receive the following arguments: + // 1- The pending calls of @param CHK filled up with the required CPU features, + // that need to be tested first in runtime before executing call belong to + // the compiled object. + // 2- The required optimization name, same as in 'NPY__CPU_TARGET_CURRENT' + // 3- Extra arguments in the macro itself + // + // By default the callback calls are sorted depending on the highest interest + // unless the policy "$keep_sort" was in place within the configuration statements + // see "Dive into the CPU dispatcher" for more clarification. + #define NPY__CPU_DISPATCH_CALL(CHK, CB, ...) \ + NPY__CPU_DISPATCH_EXPAND_(CB((CHK(AVX512F)), AVX512F, __VA_ARGS__)) \ + NPY__CPU_DISPATCH_EXPAND_(CB((CHK(SSE)&&CHK(SSE2)&&CHK(SSE3)&&CHK(SSSE3)&&CHK(SSE41)), SSE41, __VA_ARGS__)) + + An example of using the config header in light of the above: + + .. code:: c + + // NOTE: The following macros are only defined for demonstration purposes only. + // NumPy already has a collections of macros located at + // numpy/numpy/core/src/common/npy_cpu_dispatch.h, that covers all dispatching + // and declarations scenarios. + + #include "numpy/npy_cpu_features.h" // NPY_CPU_HAVE + #include "numpy/utils.h" // NPY_CAT, NPY_EXPAND + + // An example for setting a macro that calls all the exported symbols at once + // after checking if they're supported by the running machine. + #define DISPATCH_CALL_ALL(FN, ARGS) \ + NPY__CPU_DISPATCH_CALL(NPY_CPU_HAVE, DISPATCH_CALL_ALL_CB, FN, ARGS) \ + NPY__CPU_DISPATCH_BASELINE_CALL(DISPATCH_CALL_BASELINE_ALL_CB, FN, ARGS) + // The preprocessor callbacks. + // The same suffixes as we define it in the dispatch-able source. + #define DISPATCH_CALL_ALL_CB(CHECK, TARGET_NAME, FN, ARGS) \ + if (CHECK) { NPY_CAT(NPY_CAT(FN, _), TARGET_NAME) ARGS; } + #define DISPATCH_CALL_BASELINE_ALL_CB(FN, ARGS) \ + FN NPY_EXPAND(ARGS); + + // An example for setting a macro that calls the exported symbols of highest + // interest optimization, after checking if they're supported by the running machine. + #define DISPATCH_CALL_HIGH(FN, ARGS) \ + if (0) {} \ + NPY__CPU_DISPATCH_CALL(NPY_CPU_HAVE, DISPATCH_CALL_HIGH_CB, FN, ARGS) \ + NPY__CPU_DISPATCH_BASELINE_CALL(DISPATCH_CALL_BASELINE_HIGH_CB, FN, ARGS) + // The preprocessor callbacks + // The same suffixes as we define it in the dispatch-able source. + #define DISPATCH_CALL_HIGH_CB(CHECK, TARGET_NAME, FN, ARGS) \ + else if (CHECK) { NPY_CAT(NPY_CAT(FN, _), TARGET_NAME) ARGS; } + #define DISPATCH_CALL_BASELINE_HIGH_CB(FN, ARGS) \ + else { FN NPY_EXPAND(ARGS); } + + // NumPy has a macro called 'NPY_CPU_DISPATCH_DECLARE' can be used + // for forward declarations any kind of prototypes based on + // 'NPY__CPU_DISPATCH_CALL' and 'NPY__CPU_DISPATCH_BASELINE_CALL'. + // However in this example, we just handle it manually. + void simd_whoami(const char *extra_info); + void simd_whoami_AVX512F(const char *extra_info); + void simd_whoami_SSE41(const char *extra_info); + + void trigger_me(void) + { + // bring the auto-generated config header + // which contains config macros 'NPY__CPU_DISPATCH_CALL' and + // 'NPY__CPU_DISPATCH_BASELINE_CALL'. + // it is highly recommended to include the config header before executing + // the dispatching macros in case if there's another header in the scope. + #include "hello.dispatch.h" + DISPATCH_CALL_ALL(simd_whoami, ("all")) + DISPATCH_CALL_HIGH(simd_whoami, ("the highest interest")) + // An example of including multiple config headers in the same source + // #include "hello2.dispatch.h" + // DISPATCH_CALL_HIGH(another_function, ("the highest interest")) + } diff --git a/doc/source/reference/simd/index.rst b/doc/source/reference/simd/index.rst new file mode 100644 index 000000000000..230e2dc15ac5 --- /dev/null +++ b/doc/source/reference/simd/index.rst @@ -0,0 +1,43 @@ +.. _numpysimd: +.. currentmodule:: numpysimd + +*********************** +CPU/SIMD Optimizations +*********************** + +NumPy comes with a flexible working mechanism that allows it to harness the SIMD +features that CPUs own, in order to provide faster and more stable performance +on all popular platforms. Currently, NumPy supports the X86, IBM/Power, ARM7 and ARM8 +architectures. + +The optimization process in NumPy is carried out in three layers: + +- Code is *written* using the universal intrinsics which is a set of types, macros and + functions that are mapped to each supported instruction-sets by using guards that + will enable use of the them only when the compiler recognizes them. + This allow us to generate multiple kernels for the same functionality, + in which each generated kernel represents a set of instructions that related one + or multiple certain CPU features. The first kernel represents the minimum (baseline) + CPU features, and the other kernels represent the additional (dispatched) CPU features. + +- At *compile* time, CPU build options are used to define the minimum and + additional features to support, based on user choice and compiler support. The + appropriate intrinsics are overlaid with the platform / architecture intrinsics, + and multiple kernels are compiled. + +- At *runtime import*, the CPU is probed for the set of supported CPU + features. A mechanism is used to grab the pointer to the most appropriate + kernel, and this will be the one called for the function. + +.. note:: + + NumPy community had a deep discussion before implementing this work, + please check `NEP-38`_ for more clarification. + +.. toctree:: + + build-options + how-it-works + +.. _`NEP-38`: https://numpy.org/neps/nep-0038-SIMD-optimizations.html + diff --git a/doc/source/reference/simd/log_example.txt b/doc/source/reference/simd/log_example.txt new file mode 100644 index 000000000000..b0c732433a89 --- /dev/null +++ b/doc/source/reference/simd/log_example.txt @@ -0,0 +1,79 @@ +########### EXT COMPILER OPTIMIZATION ########### +Platform : + Architecture: x64 + Compiler : gcc + +CPU baseline : + Requested : 'min' + Enabled : SSE SSE2 SSE3 + Flags : -msse -msse2 -msse3 + Extra checks: none + +CPU dispatch : + Requested : 'max -xop -fma4' + Enabled : SSSE3 SSE41 POPCNT SSE42 AVX F16C FMA3 AVX2 AVX512F AVX512CD AVX512_KNL AVX512_KNM AVX512_SKX AVX512_CLX AVX512_CNL AVX512_ICL + Generated : + : + SSE41 : SSE SSE2 SSE3 SSSE3 + Flags : -msse -msse2 -msse3 -mssse3 -msse4.1 + Extra checks: none + Detect : SSE SSE2 SSE3 SSSE3 SSE41 + : build/src.linux-x86_64-3.9/numpy/core/src/umath/loops_arithmetic.dispatch.c + : numpy/core/src/umath/_umath_tests.dispatch.c + : + SSE42 : SSE SSE2 SSE3 SSSE3 SSE41 POPCNT + Flags : -msse -msse2 -msse3 -mssse3 -msse4.1 -mpopcnt -msse4.2 + Extra checks: none + Detect : SSE SSE2 SSE3 SSSE3 SSE41 POPCNT SSE42 + : build/src.linux-x86_64-3.9/numpy/core/src/_simd/_simd.dispatch.c + : + AVX2 : SSE SSE2 SSE3 SSSE3 SSE41 POPCNT SSE42 AVX F16C + Flags : -msse -msse2 -msse3 -mssse3 -msse4.1 -mpopcnt -msse4.2 -mavx -mf16c -mavx2 + Extra checks: none + Detect : AVX F16C AVX2 + : build/src.linux-x86_64-3.9/numpy/core/src/umath/loops_arithm_fp.dispatch.c + : build/src.linux-x86_64-3.9/numpy/core/src/umath/loops_arithmetic.dispatch.c + : numpy/core/src/umath/_umath_tests.dispatch.c + : + (FMA3 AVX2) : SSE SSE2 SSE3 SSSE3 SSE41 POPCNT SSE42 AVX F16C + Flags : -msse -msse2 -msse3 -mssse3 -msse4.1 -mpopcnt -msse4.2 -mavx -mf16c -mfma -mavx2 + Extra checks: none + Detect : AVX F16C FMA3 AVX2 + : build/src.linux-x86_64-3.9/numpy/core/src/_simd/_simd.dispatch.c + : build/src.linux-x86_64-3.9/numpy/core/src/umath/loops_exponent_log.dispatch.c + : build/src.linux-x86_64-3.9/numpy/core/src/umath/loops_trigonometric.dispatch.c + : + AVX512F : SSE SSE2 SSE3 SSSE3 SSE41 POPCNT SSE42 AVX F16C FMA3 AVX2 + Flags : -msse -msse2 -msse3 -mssse3 -msse4.1 -mpopcnt -msse4.2 -mavx -mf16c -mfma -mavx2 -mavx512f + Extra checks: AVX512F_REDUCE + Detect : AVX512F + : build/src.linux-x86_64-3.9/numpy/core/src/_simd/_simd.dispatch.c + : build/src.linux-x86_64-3.9/numpy/core/src/umath/loops_arithm_fp.dispatch.c + : build/src.linux-x86_64-3.9/numpy/core/src/umath/loops_arithmetic.dispatch.c + : build/src.linux-x86_64-3.9/numpy/core/src/umath/loops_exponent_log.dispatch.c + : build/src.linux-x86_64-3.9/numpy/core/src/umath/loops_trigonometric.dispatch.c + : + AVX512_SKX : SSE SSE2 SSE3 SSSE3 SSE41 POPCNT SSE42 AVX F16C FMA3 AVX2 AVX512F AVX512CD + Flags : -msse -msse2 -msse3 -mssse3 -msse4.1 -mpopcnt -msse4.2 -mavx -mf16c -mfma -mavx2 -mavx512f -mavx512cd -mavx512vl -mavx512bw -mavx512dq + Extra checks: AVX512BW_MASK AVX512DQ_MASK + Detect : AVX512_SKX + : build/src.linux-x86_64-3.9/numpy/core/src/_simd/_simd.dispatch.c + : build/src.linux-x86_64-3.9/numpy/core/src/umath/loops_arithmetic.dispatch.c + : build/src.linux-x86_64-3.9/numpy/core/src/umath/loops_exponent_log.dispatch.c +CCompilerOpt.cache_flush[804] : write cache to path -> /home/seiko/work/repos/numpy/build/temp.linux-x86_64-3.9/ccompiler_opt_cache_ext.py + +########### CLIB COMPILER OPTIMIZATION ########### +Platform : + Architecture: x64 + Compiler : gcc + +CPU baseline : + Requested : 'min' + Enabled : SSE SSE2 SSE3 + Flags : -msse -msse2 -msse3 + Extra checks: none + +CPU dispatch : + Requested : 'max -xop -fma4' + Enabled : SSSE3 SSE41 POPCNT SSE42 AVX F16C FMA3 AVX2 AVX512F AVX512CD AVX512_KNL AVX512_KNM AVX512_SKX AVX512_CLX AVX512_CNL AVX512_ICL + Generated : none diff --git a/doc/source/reference/simd/simd-optimizations-tables-diff.inc b/doc/source/reference/simd/simd-optimizations-tables-diff.inc deleted file mode 100644 index 41fa96703251..000000000000 --- a/doc/source/reference/simd/simd-optimizations-tables-diff.inc +++ /dev/null @@ -1,37 +0,0 @@ -.. generated via source/reference/simd/simd-optimizations.py - -x86::Intel Compiler - CPU feature names -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -.. table:: - :align: left - - =========== ================================================================================================================== - Name Implies - =========== ================================================================================================================== - ``FMA3`` ``SSE`` ``SSE2`` ``SSE3`` ``SSSE3`` ``SSE41`` ``POPCNT`` ``SSE42`` ``AVX`` ``F16C`` **AVX2** - ``AVX2`` ``SSE`` ``SSE2`` ``SSE3`` ``SSSE3`` ``SSE41`` ``POPCNT`` ``SSE42`` ``AVX`` ``F16C`` **FMA3** - ``AVX512F`` ``SSE`` ``SSE2`` ``SSE3`` ``SSSE3`` ``SSE41`` ``POPCNT`` ``SSE42`` ``AVX`` ``F16C`` ``FMA3`` ``AVX2`` **AVX512CD** - =========== ================================================================================================================== - -.. note:: - The following features aren't supported by x86::Intel Compiler: - **XOP FMA4** - -x86::Microsoft Visual C/C++ - CPU feature names -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -.. table:: - :align: left - - ============ ================================================================================================================================= - Name Implies - ============ ================================================================================================================================= - ``FMA3`` ``SSE`` ``SSE2`` ``SSE3`` ``SSSE3`` ``SSE41`` ``POPCNT`` ``SSE42`` ``AVX`` ``F16C`` **AVX2** - ``AVX2`` ``SSE`` ``SSE2`` ``SSE3`` ``SSSE3`` ``SSE41`` ``POPCNT`` ``SSE42`` ``AVX`` ``F16C`` **FMA3** - ``AVX512F`` ``SSE`` ``SSE2`` ``SSE3`` ``SSSE3`` ``SSE41`` ``POPCNT`` ``SSE42`` ``AVX`` ``F16C`` ``FMA3`` ``AVX2`` **AVX512CD** **AVX512_SKX** - ``AVX512CD`` ``SSE`` ``SSE2`` ``SSE3`` ``SSSE3`` ``SSE41`` ``POPCNT`` ``SSE42`` ``AVX`` ``F16C`` ``FMA3`` ``AVX2`` ``AVX512F`` **AVX512_SKX** - ============ ================================================================================================================================= - -.. note:: - The following features aren't supported by x86::Microsoft Visual C/C++: - **AVX512_KNL AVX512_KNM** - diff --git a/doc/source/reference/simd/simd-optimizations-tables.inc b/doc/source/reference/simd/simd-optimizations-tables.inc deleted file mode 100644 index f038a91e1fd1..000000000000 --- a/doc/source/reference/simd/simd-optimizations-tables.inc +++ /dev/null @@ -1,103 +0,0 @@ -.. generated via source/reference/simd/simd-optimizations.py - -x86 - CPU feature names -~~~~~~~~~~~~~~~~~~~~~~~ -.. table:: - :align: left - - ============ ================================================================================================================= - Name Implies - ============ ================================================================================================================= - ``SSE`` ``SSE2`` - ``SSE2`` ``SSE`` - ``SSE3`` ``SSE`` ``SSE2`` - ``SSSE3`` ``SSE`` ``SSE2`` ``SSE3`` - ``SSE41`` ``SSE`` ``SSE2`` ``SSE3`` ``SSSE3`` - ``POPCNT`` ``SSE`` ``SSE2`` ``SSE3`` ``SSSE3`` ``SSE41`` - ``SSE42`` ``SSE`` ``SSE2`` ``SSE3`` ``SSSE3`` ``SSE41`` ``POPCNT`` - ``AVX`` ``SSE`` ``SSE2`` ``SSE3`` ``SSSE3`` ``SSE41`` ``POPCNT`` ``SSE42`` - ``XOP`` ``SSE`` ``SSE2`` ``SSE3`` ``SSSE3`` ``SSE41`` ``POPCNT`` ``SSE42`` ``AVX`` - ``FMA4`` ``SSE`` ``SSE2`` ``SSE3`` ``SSSE3`` ``SSE41`` ``POPCNT`` ``SSE42`` ``AVX`` - ``F16C`` ``SSE`` ``SSE2`` ``SSE3`` ``SSSE3`` ``SSE41`` ``POPCNT`` ``SSE42`` ``AVX`` - ``FMA3`` ``SSE`` ``SSE2`` ``SSE3`` ``SSSE3`` ``SSE41`` ``POPCNT`` ``SSE42`` ``AVX`` ``F16C`` - ``AVX2`` ``SSE`` ``SSE2`` ``SSE3`` ``SSSE3`` ``SSE41`` ``POPCNT`` ``SSE42`` ``AVX`` ``F16C`` - ``AVX512F`` ``SSE`` ``SSE2`` ``SSE3`` ``SSSE3`` ``SSE41`` ``POPCNT`` ``SSE42`` ``AVX`` ``F16C`` ``FMA3`` ``AVX2`` - ``AVX512CD`` ``SSE`` ``SSE2`` ``SSE3`` ``SSSE3`` ``SSE41`` ``POPCNT`` ``SSE42`` ``AVX`` ``F16C`` ``FMA3`` ``AVX2`` ``AVX512F`` - ============ ================================================================================================================= - -x86 - Group names -~~~~~~~~~~~~~~~~~ -.. table:: - :align: left - - ============== ===================================================== =========================================================================================================================================================================== - Name Gather Implies - ============== ===================================================== =========================================================================================================================================================================== - ``AVX512_KNL`` ``AVX512ER`` ``AVX512PF`` ``SSE`` ``SSE2`` ``SSE3`` ``SSSE3`` ``SSE41`` ``POPCNT`` ``SSE42`` ``AVX`` ``F16C`` ``FMA3`` ``AVX2`` ``AVX512F`` ``AVX512CD`` - ``AVX512_KNM`` ``AVX5124FMAPS`` ``AVX5124VNNIW`` ``AVX512VPOPCNTDQ`` ``SSE`` ``SSE2`` ``SSE3`` ``SSSE3`` ``SSE41`` ``POPCNT`` ``SSE42`` ``AVX`` ``F16C`` ``FMA3`` ``AVX2`` ``AVX512F`` ``AVX512CD`` ``AVX512_KNL`` - ``AVX512_SKX`` ``AVX512VL`` ``AVX512BW`` ``AVX512DQ`` ``SSE`` ``SSE2`` ``SSE3`` ``SSSE3`` ``SSE41`` ``POPCNT`` ``SSE42`` ``AVX`` ``F16C`` ``FMA3`` ``AVX2`` ``AVX512F`` ``AVX512CD`` - ``AVX512_CLX`` ``AVX512VNNI`` ``SSE`` ``SSE2`` ``SSE3`` ``SSSE3`` ``SSE41`` ``POPCNT`` ``SSE42`` ``AVX`` ``F16C`` ``FMA3`` ``AVX2`` ``AVX512F`` ``AVX512CD`` ``AVX512_SKX`` - ``AVX512_CNL`` ``AVX512IFMA`` ``AVX512VBMI`` ``SSE`` ``SSE2`` ``SSE3`` ``SSSE3`` ``SSE41`` ``POPCNT`` ``SSE42`` ``AVX`` ``F16C`` ``FMA3`` ``AVX2`` ``AVX512F`` ``AVX512CD`` ``AVX512_SKX`` - ``AVX512_ICL`` ``AVX512VBMI2`` ``AVX512BITALG`` ``AVX512VPOPCNTDQ`` ``SSE`` ``SSE2`` ``SSE3`` ``SSSE3`` ``SSE41`` ``POPCNT`` ``SSE42`` ``AVX`` ``F16C`` ``FMA3`` ``AVX2`` ``AVX512F`` ``AVX512CD`` ``AVX512_SKX`` ``AVX512_CLX`` ``AVX512_CNL`` - ============== ===================================================== =========================================================================================================================================================================== - -IBM/POWER big-endian - CPU feature names -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -.. table:: - :align: left - - ======== ================ - Name Implies - ======== ================ - ``VSX`` - ``VSX2`` ``VSX`` - ``VSX3`` ``VSX`` ``VSX2`` - ======== ================ - -IBM/POWER little-endian - CPU feature names -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -.. table:: - :align: left - - ======== ================ - Name Implies - ======== ================ - ``VSX`` ``VSX2`` - ``VSX2`` ``VSX`` - ``VSX3`` ``VSX`` ``VSX2`` - ======== ================ - -ARMv7/A32 - CPU feature names -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -.. table:: - :align: left - - ============== =========================================================== - Name Implies - ============== =========================================================== - ``NEON`` - ``NEON_FP16`` ``NEON`` - ``NEON_VFPV4`` ``NEON`` ``NEON_FP16`` - ``ASIMD`` ``NEON`` ``NEON_FP16`` ``NEON_VFPV4`` - ``ASIMDHP`` ``NEON`` ``NEON_FP16`` ``NEON_VFPV4`` ``ASIMD`` - ``ASIMDDP`` ``NEON`` ``NEON_FP16`` ``NEON_VFPV4`` ``ASIMD`` - ``ASIMDFHM`` ``NEON`` ``NEON_FP16`` ``NEON_VFPV4`` ``ASIMD`` ``ASIMDHP`` - ============== =========================================================== - -ARMv8/A64 - CPU feature names -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -.. table:: - :align: left - - ============== =========================================================== - Name Implies - ============== =========================================================== - ``NEON`` ``NEON_FP16`` ``NEON_VFPV4`` ``ASIMD`` - ``NEON_FP16`` ``NEON`` ``NEON_VFPV4`` ``ASIMD`` - ``NEON_VFPV4`` ``NEON`` ``NEON_FP16`` ``ASIMD`` - ``ASIMD`` ``NEON`` ``NEON_FP16`` ``NEON_VFPV4`` - ``ASIMDHP`` ``NEON`` ``NEON_FP16`` ``NEON_VFPV4`` ``ASIMD`` - ``ASIMDDP`` ``NEON`` ``NEON_FP16`` ``NEON_VFPV4`` ``ASIMD`` - ``ASIMDFHM`` ``NEON`` ``NEON_FP16`` ``NEON_VFPV4`` ``ASIMD`` ``ASIMDHP`` - ============== =========================================================== - diff --git a/doc/source/reference/simd/simd-optimizations.py b/doc/source/reference/simd/simd-optimizations.py deleted file mode 100644 index a78302db5e89..000000000000 --- a/doc/source/reference/simd/simd-optimizations.py +++ /dev/null @@ -1,190 +0,0 @@ -""" -Generate CPU features tables from CCompilerOpt -""" -from os import sys, path -gen_path = path.dirname(path.realpath(__file__)) -#sys.path.append(path.abspath(path.join(gen_path, *([".."]*4), "numpy", "distutils"))) -#from ccompiler_opt import CCompilerOpt -from numpy.distutils.ccompiler_opt import CCompilerOpt - -class FakeCCompilerOpt(CCompilerOpt): - fake_info = ("arch", "compiler", "extra_args") - # disable caching no need for it - conf_nocache = True - def __init__(self, *args, **kwargs): - no_cc = None - CCompilerOpt.__init__(self, no_cc, **kwargs) - def dist_compile(self, sources, flags, **kwargs): - return sources - def dist_info(self): - return FakeCCompilerOpt.fake_info - @staticmethod - def dist_log(*args, stderr=False): - # avoid printing - pass - def feature_test(self, name, force_flags=None): - # To speed up - return True - - def gen_features_table(self, features, ignore_groups=True, - field_names=["Name", "Implies"], - fstyle=None, fstyle_implies=None, **kwargs): - rows = [] - if fstyle is None: - fstyle = lambda ft: f'``{ft}``' - if fstyle_implies is None: - fstyle_implies = lambda origin, ft: fstyle(ft) - for f in self.feature_sorted(features): - is_group = "group" in self.feature_supported.get(f, {}) - if ignore_groups and is_group: - continue - implies = self.feature_sorted(self.feature_implies(f)) - implies = ' '.join([fstyle_implies(f, i) for i in implies]) - rows.append([fstyle(f), implies]) - if rows: - return self.gen_rst_table(field_names, rows, **kwargs) - - def gen_gfeatures_table(self, features, - field_names=["Name", "Gather", "Implies"], - fstyle=None, fstyle_implies=None, **kwargs): - rows = [] - if fstyle is None: - fstyle = lambda ft: f'``{ft}``' - if fstyle_implies is None: - fstyle_implies = lambda origin, ft: fstyle(ft) - for f in self.feature_sorted(features): - gather = self.feature_supported.get(f, {}).get("group", None) - if not gather: - continue - implies = self.feature_sorted(self.feature_implies(f)) - implies = ' '.join([fstyle_implies(f, i) for i in implies]) - gather = ' '.join([fstyle_implies(f, i) for i in gather]) - rows.append([fstyle(f), gather, implies]) - if rows: - return self.gen_rst_table(field_names, rows, **kwargs) - - def gen_rst_table(self, field_names, rows, tab_size=4): - assert(not rows or len(field_names) == len(rows[0])) - rows.append(field_names) - fld_len = len(field_names) - cls_len = [max(len(c[i]) for c in rows) for i in range(fld_len)] - del rows[-1] - cformat = ' '.join('{:<%d}' % i for i in cls_len) - border = cformat.format(*['='*i for i in cls_len]) - - rows = [cformat.format(*row) for row in rows] - # header - rows = [border, cformat.format(*field_names), border] + rows - # footer - rows += [border] - # add left margin - rows = [(' ' * tab_size) + r for r in rows] - return '\n'.join(rows) - -def features_table_sections(name, ftable=None, gtable=None, tab_size=4): - tab = ' '*tab_size - content = '' - if ftable: - title = f"{name} - CPU feature names" - content = ( - f"{title}\n{'~'*len(title)}" - f"\n.. table::\n{tab}:align: left\n\n" - f"{ftable}\n\n" - ) - if gtable: - title = f"{name} - Group names" - content += ( - f"{title}\n{'~'*len(title)}" - f"\n.. table::\n{tab}:align: left\n\n" - f"{gtable}\n\n" - ) - return content - -def features_table(arch, cc="gcc", pretty_name=None, **kwargs): - FakeCCompilerOpt.fake_info = (arch, cc, '') - ccopt = FakeCCompilerOpt(cpu_baseline="max") - features = ccopt.cpu_baseline_names() - ftable = ccopt.gen_features_table(features, **kwargs) - gtable = ccopt.gen_gfeatures_table(features, **kwargs) - - if not pretty_name: - pretty_name = arch + '/' + cc - return features_table_sections(pretty_name, ftable, gtable, **kwargs) - -def features_table_diff(arch, cc, cc_vs="gcc", pretty_name=None, **kwargs): - FakeCCompilerOpt.fake_info = (arch, cc, '') - ccopt = FakeCCompilerOpt(cpu_baseline="max") - fnames = ccopt.cpu_baseline_names() - features = {f:ccopt.feature_implies(f) for f in fnames} - - FakeCCompilerOpt.fake_info = (arch, cc_vs, '') - ccopt_vs = FakeCCompilerOpt(cpu_baseline="max") - fnames_vs = ccopt_vs.cpu_baseline_names() - features_vs = {f:ccopt_vs.feature_implies(f) for f in fnames_vs} - - common = set(fnames).intersection(fnames_vs) - extra_avl = set(fnames).difference(fnames_vs) - not_avl = set(fnames_vs).difference(fnames) - diff_impl_f = {f:features[f].difference(features_vs[f]) for f in common} - diff_impl = {k for k, v in diff_impl_f.items() if v} - - fbold = lambda ft: f'**{ft}**' if ft in extra_avl else f'``{ft}``' - fbold_implies = lambda origin, ft: ( - f'**{ft}**' if ft in diff_impl_f.get(origin, {}) else f'``{ft}``' - ) - diff_all = diff_impl.union(extra_avl) - ftable = ccopt.gen_features_table( - diff_all, fstyle=fbold, fstyle_implies=fbold_implies, **kwargs - ) - gtable = ccopt.gen_gfeatures_table( - diff_all, fstyle=fbold, fstyle_implies=fbold_implies, **kwargs - ) - if not pretty_name: - pretty_name = arch + '/' + cc - content = features_table_sections(pretty_name, ftable, gtable, **kwargs) - - if not_avl: - not_avl = ccopt_vs.feature_sorted(not_avl) - not_avl = ' '.join(not_avl) - content += ( - ".. note::\n" - f" The following features aren't supported by {pretty_name}:\n" - f" **{not_avl}**\n\n" - ) - return content - -if __name__ == '__main__': - pretty_names = { - "PPC64": "IBM/POWER big-endian", - "PPC64LE": "IBM/POWER little-endian", - "ARMHF": "ARMv7/A32", - "AARCH64": "ARMv8/A64", - "ICC": "Intel Compiler", - # "ICCW": "Intel Compiler msvc-like", - "MSVC": "Microsoft Visual C/C++" - } - with open(path.join(gen_path, 'simd-optimizations-tables.inc'), 'wt') as fd: - fd.write(f'.. generated via {__file__}\n\n') - for arch in ( - ("x86", "PPC64", "PPC64LE", "ARMHF", "AARCH64") - ): - pretty_name = pretty_names.get(arch, arch) - table = features_table(arch=arch, pretty_name=pretty_name) - assert(table) - fd.write(table) - - with open(path.join(gen_path, 'simd-optimizations-tables-diff.inc'), 'wt') as fd: - fd.write(f'.. generated via {__file__}\n\n') - for arch, cc_names in ( - ("x86", ("clang", "ICC", "MSVC")), - ("PPC64", ("clang",)), - ("PPC64LE", ("clang",)), - ("ARMHF", ("clang",)), - ("AARCH64", ("clang",)) - ): - arch_pname = pretty_names.get(arch, arch) - for cc in cc_names: - pretty_name = f"{arch_pname}::{pretty_names.get(cc, cc)}" - table = features_table_diff(arch=arch, cc=cc, pretty_name=pretty_name) - if table: - fd.write(table) diff --git a/doc/source/reference/simd/simd-optimizations.rst b/doc/source/reference/simd/simd-optimizations.rst index 9de6d1734079..a181082661e8 100644 --- a/doc/source/reference/simd/simd-optimizations.rst +++ b/doc/source/reference/simd/simd-optimizations.rst @@ -1,527 +1,12 @@ -****************** -SIMD Optimizations -****************** +:orphan: -NumPy provides a set of macros that define `Universal Intrinsics`_ to -abstract out typical platform-specific intrinsics so SIMD code needs to be -written only once. There are three layers: +.. raw:: html -- Code is *written* using the universal intrinsic macros, with guards that - will enable use of the macros only when the compiler recognizes them. - In NumPy, these are used to construct multiple ufunc loops. Current policy is - to create three loops: One loop is the default and uses no intrinsics. One - uses the minimum intrinsics required on the architecture. And the third is - written using the maximum set of intrinsics possible. -- At *compile* time, a distutils command is used to define the minimum and - maximum features to support, based on user choice and compiler support. The - appropriate macros are overlaid with the platform / architecture intrinsics, - and the three loops are compiled. -- At *runtime import*, the CPU is probed for the set of supported intrinsic - features. A mechanism is used to grab the pointer to the most appropriate - function, and this will be the one called for the function. + + + + + - -Build options for compilation -============================= - -- ``--cpu-baseline``: minimal set of required optimizations. Default - value is ``min`` which provides the minimum CPU features that can - safely run on a wide range of platforms within the processor family. - -- ``--cpu-dispatch``: dispatched set of additional optimizations. - The default value is ``max -xop -fma4`` which enables all CPU - features, except for AMD legacy features(in case of X86). - -The command arguments are available in ``build``, ``build_clib``, and -``build_ext``. -if ``build_clib`` or ``build_ext`` are not specified by the user, the arguments of -``build`` will be used instead, which also holds the default values. - -Optimization names can be CPU features or groups of features that gather -several features or :ref:`special options ` to perform a series of procedures. - - -The following tables show the current supported optimizations sorted from the lowest to the highest interest. - -.. include:: simd-optimizations-tables.inc - ----- - -.. _tables-diff: - -While the above tables are based on the GCC Compiler, the following tables showing the differences in the -other compilers: - -.. include:: simd-optimizations-tables-diff.inc - -.. _special-options: - -Special options -~~~~~~~~~~~~~~~ - -- ``NONE``: enable no features - -- ``NATIVE``: Enables all CPU features that supported by the current - machine, this operation is based on the compiler flags (``-march=native, -xHost, /QxHost``) - -- ``MIN``: Enables the minimum CPU features that can safely run on a wide range of platforms: - - .. table:: - :align: left - - ====================================== ======================================= - For Arch Returns - ====================================== ======================================= - ``x86`` ``SSE`` ``SSE2`` - ``x86`` ``64-bit mode`` ``SSE`` ``SSE2`` ``SSE3`` - ``IBM/POWER`` ``big-endian mode`` ``NONE`` - ``IBM/POWER`` ``little-endian mode`` ``VSX`` ``VSX2`` - ``ARMHF`` ``NONE`` - ``ARM64`` ``AARCH64`` ``NEON`` ``NEON_FP16`` ``NEON_VFPV4`` - ``ASIMD`` - ====================================== ======================================= - -- ``MAX``: Enables all supported CPU features by the Compiler and platform. - -- ``Operators-/+``: remove or add features, useful with options ``MAX``, ``MIN`` and ``NATIVE``. - -NOTES -~~~~~~~~~~~~~ -- CPU features and other options are case-insensitive. - -- The order of the requested optimizations doesn't matter. - -- Either commas or spaces can be used as a separator, e.g. ``--cpu-dispatch``\ = - "avx2 avx512f" or ``--cpu-dispatch``\ = "avx2, avx512f" both work, but the - arguments must be enclosed in quotes. - -- The operand ``+`` is only added for nominal reasons, For example: - ``--cpu-baseline= "min avx2"`` is equivalent to ``--cpu-baseline="min + avx2"``. - ``--cpu-baseline="min,avx2"`` is equivalent to ``--cpu-baseline`="min,+avx2"`` - -- If the CPU feature is not supported by the user platform or - compiler, it will be skipped rather than raising a fatal error. - -- Any specified CPU feature to ``--cpu-dispatch`` will be skipped if - it's part of CPU baseline features - -- The ``--cpu-baseline`` argument force-enables implied features, - e.g. ``--cpu-baseline``\ ="sse42" is equivalent to - ``--cpu-baseline``\ ="sse sse2 sse3 ssse3 sse41 popcnt sse42" - -- The value of ``--cpu-baseline`` will be treated as "native" if - compiler native flag ``-march=native`` or ``-xHost`` or ``QxHost`` is - enabled through environment variable ``CFLAGS`` - -- The validation process for the requested optimizations when it comes to - ``--cpu-baseline`` isn't strict. For example, if the user requested - ``AVX2`` but the compiler doesn't support it then we just skip it and return - the maximum optimization that the compiler can handle depending on the - implied features of ``AVX2``, let us assume ``AVX``. - -- The user should always check the final report through the build log - to verify the enabled features. - -Special cases -~~~~~~~~~~~~~ - -**Interrelated CPU features**: Some exceptional conditions force us to link some features together when it come to certain compilers or architectures, resulting in the impossibility of building them separately. -These conditions can be divided into two parts, as follows: - -- **Architectural compatibility**: The need to align certain CPU features that are assured - to be supported by successive generations of the same architecture, for example: - - - On ppc64le `VSX(ISA 2.06)` and `VSX2(ISA 2.07)` both imply one another since the - first generation that supports little-endian mode is Power-8`(ISA 2.07)` - - On AArch64 `NEON` `FP16` `VFPV4` `ASIMD` implies each other since they are part of the - hardware baseline. - -- **Compilation compatibility**: Not all **C/C++** compilers provide independent support for all CPU - features. For example, **Intel**'s compiler doesn't provide separated flags for `AVX2` and `FMA3`, - it makes sense since all Intel CPUs that comes with `AVX2` also support `FMA3` and vice versa, - but this approach is incompatible with other **x86** CPUs from **AMD** or **VIA**. - Therefore, there are differences in the depiction of CPU features between the C/C++ compilers, - as shown in the :ref:`tables above `. - - -Behaviors and Errors -~~~~~~~~~~~~~~~~~~~~ - - - -Usage and Examples -~~~~~~~~~~~~~~~~~~ - -Report and Trace -~~~~~~~~~~~~~~~~ - -Understanding CPU Dispatching, How the NumPy dispatcher works? -============================================================== - -NumPy dispatcher is based on multi-source compiling, which means taking -a certain source and compiling it multiple times with different compiler -flags and also with different **C** definitions that affect the code -paths to enable certain instruction-sets for each compiled object -depending on the required optimizations, then combining the returned -objects together. - -.. figure:: ../figures/opt-infra.png - -This mechanism should support all compilers and it doesn't require any -compiler-specific extension, but at the same time it is adds a few steps to -normal compilation that are explained as follows: - -1- Configuration -~~~~~~~~~~~~~~~~ - -Configuring the required optimization by the user before starting to build the -source files via the two command arguments as explained above: - -- ``--cpu-baseline``: minimal set of required optimizations. - -- ``--cpu-dispatch``: dispatched set of additional optimizations. - - -2- Discovering the environment -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -In this part, we check the compiler and platform architecture -and cache some of the intermediary results to speed up rebuilding. - -3- Validating the requested optimizations -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -By testing them against the compiler, and seeing what the compiler can -support according to the requested optimizations. - -4- Generating the main configuration header -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -The generated header ``_cpu_dispatch.h`` contains all the definitions and -headers of instruction-sets for the required optimizations that have been -validated during the previous step. - -It also contains extra C definitions that are used for defining NumPy's -Python-level module attributes ``__cpu_baseline__`` and ``__cpu_dispaٍtch__``. - -**What is in this header?** - -The example header was dynamically generated by gcc on an X86 machine. -The compiler supports ``--cpu-baseline="sse sse2 sse3"`` and -``--cpu-dispatch="ssse3 sse41"``, and the result is below. - -.. code:: c - - // The header should be located at numpy/numpy/core/src/common/_cpu_dispatch.h - /**NOTE - ** C definitions prefixed with "NPY_HAVE_" represent - ** the required optimzations. - ** - ** C definitions prefixed with 'NPY__CPU_TARGET_' are protected and - ** shouldn't be used by any NumPy C sources. - */ - /******* baseline features *******/ - /** SSE **/ - #define NPY_HAVE_SSE 1 - #include - /** SSE2 **/ - #define NPY_HAVE_SSE2 1 - #include - /** SSE3 **/ - #define NPY_HAVE_SSE3 1 - #include - - /******* dispatch-able features *******/ - #ifdef NPY__CPU_TARGET_SSSE3 - /** SSSE3 **/ - #define NPY_HAVE_SSSE3 1 - #include - #endif - #ifdef NPY__CPU_TARGET_SSE41 - /** SSE41 **/ - #define NPY_HAVE_SSE41 1 - #include - #endif - -**Baseline features** are the minimal set of required optimizations configured -via ``--cpu-baseline``. They have no preprocessor guards and they're -always on, which means they can be used in any source. - -Does this mean NumPy's infrastructure passes the compiler's flags of -baseline features to all sources? - -Definitely, yes. But the :ref:`dispatch-able sources ` are -treated differently. - -What if the user specifies certain **baseline features** during the -build but at runtime the machine doesn't support even these -features? Will the compiled code be called via one of these definitions, or -maybe the compiler itself auto-generated/vectorized certain piece of code -based on the provided command line compiler flags? - -During the loading of the NumPy module, there's a validation step -which detects this behavior. It will raise a Python runtime error to inform the -user. This is to prevent the CPU reaching an illegal instruction error causing -a segfault. - -**Dispatch-able features** are our dispatched set of additional optimizations -that were configured via ``--cpu-dispatch``. They are not activated by -default and are always guarded by other C definitions prefixed with -``NPY__CPU_TARGET_``. C definitions ``NPY__CPU_TARGET_`` are only -enabled within **dispatch-able sources**. - -.. _dispatchable-sources: - -5- Dispatch-able sources and configuration statements -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -Dispatch-able sources are special **C** files that can be compiled multiple -times with different compiler flags and also with different **C** -definitions. These affect code paths to enable certain -instruction-sets for each compiled object according to "**the -configuration statements**" that must be declared between a **C** -comment\ ``(/**/)`` and start with a special mark **@targets** at the -top of each dispatch-able source. At the same time, dispatch-able -sources will be treated as normal **C** sources if the optimization was -disabled by the command argument ``--disable-optimization`` . - -**What are configuration statements?** - -Configuration statements are sort of keywords combined together to -determine the required optimization for the dispatch-able source. - -Example: - -.. code:: c - - /*@targets avx2 avx512f vsx2 vsx3 asimd asimdhp */ - // C code - -The keywords mainly represent the additional optimizations configured -through ``--cpu-dispatch``, but it can also represent other options such as: - -- Target groups: pre-configured configuration statements used for - managing the required optimizations from outside the dispatch-able source. - -- Policies: collections of options used for changing the default - behaviors or forcing the compilers to perform certain things. - -- "baseline": a unique keyword represents the minimal optimizations - that configured through ``--cpu-baseline`` - -**Numpy's infrastructure handles dispatch-able sources in four steps**: - -- **(A) Recognition**: Just like source templates and F2PY, the - dispatch-able sources requires a special extension ``*.dispatch.c`` - to mark C dispatch-able source files, and for C++ - ``*.dispatch.cpp`` or ``*.dispatch.cxx`` - **NOTE**: C++ not supported yet. - -- **(B) Parsing and validating**: In this step, the - dispatch-able sources that had been filtered by the previous step - are parsed and validated by the configuration statements for each one - of them one by one in order to determine the required optimizations. - -- **(C) Wrapping**: This is the approach taken by NumPy's - infrastructure, which has proved to be sufficiently flexible in order - to compile a single source multiple times with different **C** - definitions and flags that affect the code paths. The process is - achieved by creating a temporary **C** source for each required - optimization that related to the additional optimization, which - contains the declarations of the **C** definitions and includes the - involved source via the **C** directive **#include**. For more - clarification take a look at the following code for AVX512F : - - .. code:: c - - /* - * this definition is used by NumPy utilities as suffixes for the - * exported symbols - */ - #define NPY__CPU_TARGET_CURRENT AVX512F - /* - * The following definitions enable - * definitions of the dispatch-able features that are defined within the main - * configuration header. These are definitions for the implied features. - */ - #define NPY__CPU_TARGET_SSE - #define NPY__CPU_TARGET_SSE2 - #define NPY__CPU_TARGET_SSE3 - #define NPY__CPU_TARGET_SSSE3 - #define NPY__CPU_TARGET_SSE41 - #define NPY__CPU_TARGET_POPCNT - #define NPY__CPU_TARGET_SSE42 - #define NPY__CPU_TARGET_AVX - #define NPY__CPU_TARGET_F16C - #define NPY__CPU_TARGET_FMA3 - #define NPY__CPU_TARGET_AVX2 - #define NPY__CPU_TARGET_AVX512F - // our dispatch-able source - #include "/the/absuolate/path/of/hello.dispatch.c" - -- **(D) Dispatch-able configuration header**: The infrastructure - generates a config header for each dispatch-able source, this header - mainly contains two abstract **C** macros used for identifying the - generated objects, so they can be used for runtime dispatching - certain symbols from the generated objects by any **C** source. It is - also used for forward declarations. - - The generated header takes the name of the dispatch-able source after - excluding the extension and replace it with '**.h**', for example - assume we have a dispatch-able source called **hello.dispatch.c** and - contains the following: - - .. code:: c - - // hello.dispatch.c - /*@targets baseline sse42 avx512f */ - #include - #include "numpy/utils.h" // NPY_CAT, NPY_TOSTR - - #ifndef NPY__CPU_TARGET_CURRENT - // wrapping the dispatch-able source only happens to the additional optimizations - // but if the keyword 'baseline' provided within the configuration statements, - // the infrastructure will add extra compiling for the dispatch-able source by - // passing it as-is to the compiler without any changes. - #define CURRENT_TARGET(X) X - #define NPY__CPU_TARGET_CURRENT baseline // for printing only - #else - // since we reach to this point, that's mean we're dealing with - // the additional optimizations, so it could be SSE42 or AVX512F - #define CURRENT_TARGET(X) NPY_CAT(NPY_CAT(X, _), NPY__CPU_TARGET_CURRENT) - #endif - // Macro 'CURRENT_TARGET' adding the current target as suffux to the exported symbols, - // to avoid linking duplications, NumPy already has a macro called - // 'NPY_CPU_DISPATCH_CURFX' similar to it, located at - // numpy/numpy/core/src/common/npy_cpu_dispatch.h - // NOTE: we tend to not adding suffixes to the baseline exported symbols - void CURRENT_TARGET(simd_whoami)(const char *extra_info) - { - printf("I'm " NPY_TOSTR(NPY__CPU_TARGET_CURRENT) ", %s\n", extra_info); - } - - Now assume you attached **hello.dispatch.c** to the source tree, then - the infrastructure should generate a temporary config header called - **hello.dispatch.h** that can be reached by any source in the source - tree, and it should contain the following code : - - .. code:: c - - #ifndef NPY__CPU_DISPATCH_EXPAND_ - // To expand the macro calls in this header - #define NPY__CPU_DISPATCH_EXPAND_(X) X - #endif - // Undefining the following macros, due to the possibility of including config headers - // multiple times within the same source and since each config header represents - // different required optimizations according to the specified configuration - // statements in the dispatch-able source that derived from it. - #undef NPY__CPU_DISPATCH_BASELINE_CALL - #undef NPY__CPU_DISPATCH_CALL - // nothing strange here, just a normal preprocessor callback - // enabled only if 'baseline' specified within the configuration statements - #define NPY__CPU_DISPATCH_BASELINE_CALL(CB, ...) \ - NPY__CPU_DISPATCH_EXPAND_(CB(__VA_ARGS__)) - // 'NPY__CPU_DISPATCH_CALL' is an abstract macro is used for dispatching - // the required optimizations that specified within the configuration statements. - // - // @param CHK, Expected a macro that can be used to detect CPU features - // in runtime, which takes a CPU feature name without string quotes and - // returns the testing result in a shape of boolean value. - // NumPy already has macro called "NPY_CPU_HAVE", which fits this requirement. - // - // @param CB, a callback macro that expected to be called multiple times depending - // on the required optimizations, the callback should receive the following arguments: - // 1- The pending calls of @param CHK filled up with the required CPU features, - // that need to be tested first in runtime before executing call belong to - // the compiled object. - // 2- The required optimization name, same as in 'NPY__CPU_TARGET_CURRENT' - // 3- Extra arguments in the macro itself - // - // By default the callback calls are sorted depending on the highest interest - // unless the policy "$keep_sort" was in place within the configuration statements - // see "Dive into the CPU dispatcher" for more clarification. - #define NPY__CPU_DISPATCH_CALL(CHK, CB, ...) \ - NPY__CPU_DISPATCH_EXPAND_(CB((CHK(AVX512F)), AVX512F, __VA_ARGS__)) \ - NPY__CPU_DISPATCH_EXPAND_(CB((CHK(SSE)&&CHK(SSE2)&&CHK(SSE3)&&CHK(SSSE3)&&CHK(SSE41)), SSE41, __VA_ARGS__)) - - An example of using the config header in light of the above: - - .. code:: c - - // NOTE: The following macros are only defined for demonstration purposes only. - // NumPy already has a collections of macros located at - // numpy/numpy/core/src/common/npy_cpu_dispatch.h, that covers all dispatching - // and declarations scenarios. - - #include "numpy/npy_cpu_features.h" // NPY_CPU_HAVE - #include "numpy/utils.h" // NPY_CAT, NPY_EXPAND - - // An example for setting a macro that calls all the exported symbols at once - // after checking if they're supported by the running machine. - #define DISPATCH_CALL_ALL(FN, ARGS) \ - NPY__CPU_DISPATCH_CALL(NPY_CPU_HAVE, DISPATCH_CALL_ALL_CB, FN, ARGS) \ - NPY__CPU_DISPATCH_BASELINE_CALL(DISPATCH_CALL_BASELINE_ALL_CB, FN, ARGS) - // The preprocessor callbacks. - // The same suffixes as we define it in the dispatch-able source. - #define DISPATCH_CALL_ALL_CB(CHECK, TARGET_NAME, FN, ARGS) \ - if (CHECK) { NPY_CAT(NPY_CAT(FN, _), TARGET_NAME) ARGS; } - #define DISPATCH_CALL_BASELINE_ALL_CB(FN, ARGS) \ - FN NPY_EXPAND(ARGS); - - // An example for setting a macro that calls the exported symbols of highest - // interest optimization, after checking if they're supported by the running machine. - #define DISPATCH_CALL_HIGH(FN, ARGS) \ - if (0) {} \ - NPY__CPU_DISPATCH_CALL(NPY_CPU_HAVE, DISPATCH_CALL_HIGH_CB, FN, ARGS) \ - NPY__CPU_DISPATCH_BASELINE_CALL(DISPATCH_CALL_BASELINE_HIGH_CB, FN, ARGS) - // The preprocessor callbacks - // The same suffixes as we define it in the dispatch-able source. - #define DISPATCH_CALL_HIGH_CB(CHECK, TARGET_NAME, FN, ARGS) \ - else if (CHECK) { NPY_CAT(NPY_CAT(FN, _), TARGET_NAME) ARGS; } - #define DISPATCH_CALL_BASELINE_HIGH_CB(FN, ARGS) \ - else { FN NPY_EXPAND(ARGS); } - - // NumPy has a macro called 'NPY_CPU_DISPATCH_DECLARE' can be used - // for forward declrations any kind of prototypes based on - // 'NPY__CPU_DISPATCH_CALL' and 'NPY__CPU_DISPATCH_BASELINE_CALL'. - // However in this example, we just handle it manually. - void simd_whoami(const char *extra_info); - void simd_whoami_AVX512F(const char *extra_info); - void simd_whoami_SSE41(const char *extra_info); - - void trigger_me(void) - { - // bring the auto-gernreated config header - // which contains config macros 'NPY__CPU_DISPATCH_CALL' and - // 'NPY__CPU_DISPATCH_BASELINE_CALL'. - // it highely recomaned to include the config header before exectuing - // the dispatching macros in case if there's another header in the scope. - #include "hello.dispatch.h" - DISPATCH_CALL_ALL(simd_whoami, ("all")) - DISPATCH_CALL_HIGH(simd_whoami, ("the highest interest")) - // An example of including multiple config headers in the same source - // #include "hello2.dispatch.h" - // DISPATCH_CALL_HIGH(another_function, ("the highest interest")) - } - - -Dive into the CPU dispatcher -============================ - -The baseline -~~~~~~~~~~~~ - -Dispatcher -~~~~~~~~~~ - -Groups and Policies -~~~~~~~~~~~~~~~~~~~ - -Examples -~~~~~~~~ - -Report and Trace -~~~~~~~~~~~~~~~~ - - -.. _`Universal Intrinsics`: https://numpy.org/neps/nep-0038-SIMD-optimizations.html +The location of this document has been changed , if you are not +redirected in few seconds, `click here `_. diff --git a/doc/source/reference/swig.interface-file.rst b/doc/source/reference/swig.interface-file.rst index 6dd74f4ecb21..f2bb0f0c2179 100644 --- a/doc/source/reference/swig.interface-file.rst +++ b/doc/source/reference/swig.interface-file.rst @@ -235,7 +235,7 @@ the buffer pointer. Names with ``FARRAY`` are for Fortran-ordered arrays, and names with ``ARRAY`` are for C-ordered (or 1D arrays). Input Arrays -```````````` +~~~~~~~~~~~~ Input arrays are defined as arrays of data that are passed into a routine but are not altered in-place or returned to the user. The @@ -279,7 +279,7 @@ one-dimensional arrays with hard-coded dimensions. Likewise, with hard-coded dimensions, and similarly for three-dimensional. In-Place Arrays -``````````````` +~~~~~~~~~~~~~~~ In-place arrays are defined as arrays that are modified in-place. The input values may or may not be used, but the values at the time the @@ -332,7 +332,7 @@ ND: Argout Arrays -````````````` +~~~~~~~~~~~~~ Argout arrays are arrays that appear in the input arguments in C, but are in fact output arrays. This pattern occurs often when there is @@ -376,7 +376,7 @@ cannot be avoided. Note that for these types of 1D typemaps, the Python function will take a single argument representing ``DIM1``. Argout View Arrays -`````````````````` +~~~~~~~~~~~~~~~~~~ Argoutview arrays are for when your C code provides you with a view of its internal data and does not require any memory to be allocated by @@ -424,7 +424,7 @@ Note that arrays with hard-coded dimensions are not supported. These cannot follow the double pointer signatures of these typemaps. Memory Managed Argout View Arrays -````````````````````````````````` +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ A recent addition to ``numpy.i`` are typemaps that permit argout arrays with views into memory that is managed. See the discussion `here @@ -458,7 +458,7 @@ arrays with views into memory that is managed. See the discussion `here Output Arrays -````````````` +~~~~~~~~~~~~~ The ``numpy.i`` interface file does not support typemaps for output arrays, for several reasons. First, C/C++ return arguments are @@ -479,7 +479,7 @@ function to be wrapped, either with ``%extend`` for the case of class methods or ``%ignore`` and ``%rename`` for the case of functions. Other Common Types: bool -```````````````````````` +~~~~~~~~~~~~~~~~~~~~~~~~ Note that C++ type ``bool`` is not supported in the list in the `Available Typemaps`_ section. NumPy bools are a single byte, while @@ -497,7 +497,7 @@ to fix the data length problem, and `Input Arrays`_ will work fine, but `In-Place Arrays`_ might fail type-checking. Other Common Types: complex -``````````````````````````` +~~~~~~~~~~~~~~~~~~~~~~~~~~~ Typemap conversions for complex floating-point types is also not supported automatically. This is because Python and NumPy are @@ -566,7 +566,7 @@ be fixed. It is suggested that you do this anyway, as it only increases the capabilities of your Python interface. Why is There a Second File? -``````````````````````````` +~~~~~~~~~~~~~~~~~~~~~~~~~~~ The `SWIG`_ type checking and conversion system is a complicated combination of C macros, `SWIG`_ macros, `SWIG`_ typemaps and `SWIG`_ @@ -604,7 +604,7 @@ in your code using:: in your `SWIG`_ interface file. Macros -`````` +~~~~~~ **is_array(a)** Evaluates as true if ``a`` is non-``NULL`` and can be cast to a @@ -667,7 +667,7 @@ Macros Evaluates as true if ``a`` is FORTRAN ordered. Routines -```````` +~~~~~~~~ **pytype_string()** @@ -904,7 +904,7 @@ Routines * ``PyArrayObject* ary``, a NumPy array. - Require the given ``PyArrayObject`` to to be Fortran ordered. If + Require the given ``PyArrayObject`` to be Fortran ordered. If the ``PyArrayObject`` is already Fortran ordered, do nothing. Else, set the Fortran ordering flag and recompute the strides. @@ -916,7 +916,7 @@ There are many C or C++ array/NumPy array situations not covered by a simple ``%include "numpy.i"`` and subsequent ``%apply`` directives. A Common Example -```````````````` +~~~~~~~~~~~~~~~~ Consider a reasonable prototype for a dot product function:: @@ -974,7 +974,7 @@ above for ``my_dot`` to get the behavior we want (note that macro to perform this task. Other Situations -```````````````` +~~~~~~~~~~~~~~~~ There are other wrapping situations in which ``numpy.i`` may be helpful when you encounter them. @@ -1007,7 +1007,7 @@ helpful when you encounter them. `Swig-user `_ mail lists. A Final Note -```````````` +~~~~~~~~~~~~ When you use the ``%apply`` directive, as is usually necessary to use ``numpy.i``, it will remain in effect until you tell `SWIG`_ that it diff --git a/doc/source/reference/testing.rst b/doc/source/reference/testing.rst index 72780dd44aac..47996c240194 100644 --- a/doc/source/reference/testing.rst +++ b/doc/source/reference/testing.rst @@ -3,5 +3,5 @@ Testing Guidelines ================== -.. include:: ../../TESTS.rst.txt +.. include:: ../../TESTS.rst :start-line: 6 diff --git a/doc/source/release.rst b/doc/source/release.rst index a4a5bde63aeb..bc05f00f7b2c 100644 --- a/doc/source/release.rst +++ b/doc/source/release.rst @@ -5,7 +5,23 @@ Release notes .. toctree:: :maxdepth: 3 + 1.24.3 + 1.24.2 + 1.24.1 + 1.24.0 + 1.23.5 + 1.23.4 + 1.23.3 + 1.23.2 + 1.23.1 + 1.23.0 + 1.22.4 + 1.22.3 + 1.22.2 + 1.22.1 1.22.0 + 1.21.6 + 1.21.5 1.21.4 1.21.3 1.21.2 diff --git a/doc/source/release/1.10.3-notes.rst b/doc/source/release/1.10.3-notes.rst index 0d4df4ce6a18..9172f7663523 100644 --- a/doc/source/release/1.10.3-notes.rst +++ b/doc/source/release/1.10.3-notes.rst @@ -2,4 +2,4 @@ NumPy 1.10.3 Release Notes ========================== -N/A this release did not happen due to various screwups involving PyPi. +N/A this release did not happen due to various screwups involving PyPI. diff --git a/doc/source/release/1.11.1-notes.rst b/doc/source/release/1.11.1-notes.rst index 6303c32f0e07..a196502cf746 100644 --- a/doc/source/release/1.11.1-notes.rst +++ b/doc/source/release/1.11.1-notes.rst @@ -4,7 +4,7 @@ NumPy 1.11.1 Release Notes Numpy 1.11.1 supports Python 2.6 - 2.7 and 3.2 - 3.5. It fixes bugs and regressions found in Numpy 1.11.0 and includes several build related -improvements. Wheels for Linux, Windows, and OSX can be found on pypi. +improvements. Wheels for Linux, Windows, and OSX can be found on PyPI. Fixes Merged ============ diff --git a/doc/source/release/1.12.1-notes.rst b/doc/source/release/1.12.1-notes.rst index f67dab1085d5..09a2e67381c9 100644 --- a/doc/source/release/1.12.1-notes.rst +++ b/doc/source/release/1.12.1-notes.rst @@ -4,7 +4,7 @@ NumPy 1.12.1 Release Notes NumPy 1.12.1 supports Python 2.7 and 3.4 - 3.6 and fixes bugs and regressions found in NumPy 1.12.0. In particular, the regression in f2py constant parsing -is fixed. Wheels for Linux, Windows, and OSX can be found on pypi, +is fixed. Wheels for Linux, Windows, and OSX can be found on PyPI, Bugs Fixed ========== diff --git a/doc/source/release/1.19.0-notes.rst b/doc/source/release/1.19.0-notes.rst index 410890697b5c..4a09920e45cd 100644 --- a/doc/source/release/1.19.0-notes.rst +++ b/doc/source/release/1.19.0-notes.rst @@ -317,9 +317,9 @@ New Features ``numpy.frompyfunc`` now accepts an identity argument ----------------------------------------------------- -This allows the :attr:``numpy.ufunc.identity`` attribute to be set on the +This allows the :attr:`numpy.ufunc.identity` attribute to be set on the resulting ufunc, meaning it can be used for empty and multi-dimensional -calls to :meth:``numpy.ufunc.reduce``. +calls to :meth:`numpy.ufunc.reduce`. (`gh-8255 `__) diff --git a/doc/source/release/1.21.5-notes.rst b/doc/source/release/1.21.5-notes.rst new file mode 100644 index 000000000000..c69d26771268 --- /dev/null +++ b/doc/source/release/1.21.5-notes.rst @@ -0,0 +1,42 @@ +.. currentmodule:: numpy + +========================== +NumPy 1.21.5 Release Notes +========================== + +NumPy 1.21.5 is a maintenance release that fixes a few bugs discovered after +the 1.21.4 release and does some maintenance to extend the 1.21.x lifetime. +The Python versions supported in this release are 3.7-3.10. If you want to +compile your own version using gcc-11, you will need to use gcc-11.2+ to avoid +problems. + +Contributors +============ + +A total of 7 people contributed to this release. People with a "+" by their +names contributed a patch for the first time. + +* Bas van Beek +* Charles Harris +* Matti Picus +* Rohit Goswami +* Ross Barnowski +* Sayed Adel +* Sebastian Berg + +Pull requests merged +==================== + +A total of 11 pull requests were merged for this release. + +* `#20357 `__: MAINT: Do not forward ``__(deep)copy__`` calls of ``_GenericAlias``... +* `#20462 `__: BUG: Fix float16 einsum fastpaths using wrong tempvar +* `#20463 `__: BUG, DIST: Print os error message when the executable not exist +* `#20464 `__: BLD: Verify the ability to compile C++ sources before initiating... +* `#20465 `__: BUG: Force ``npymath` ` to respect ``npy_longdouble`` +* `#20466 `__: BUG: Fix failure to create aligned, empty structured dtype +* `#20467 `__: ENH: provide a convenience function to replace npy_load_module +* `#20495 `__: MAINT: update wheel to version that supports python3.10 +* `#20497 `__: BUG: Clear errors correctly in F2PY conversions +* `#20613 `__: DEV: add a warningfilter to fix pytest workflow. +* `#20618 `__: MAINT: Help boost::python libraries at least not crash diff --git a/doc/source/release/1.21.6-notes.rst b/doc/source/release/1.21.6-notes.rst new file mode 100644 index 000000000000..6683969a280e --- /dev/null +++ b/doc/source/release/1.21.6-notes.rst @@ -0,0 +1,13 @@ +.. currentmodule:: numpy + +========================== +NumPy 1.21.6 Release Notes +========================== + +NumPy 1.21.6 is a very small release that achieves two things: + +- Backs out the mistaken backport of C++ code into 1.21.5. +- Provides a 32 bit Windows wheel for Python 3.10. + +The provision of the 32 bit wheel is intended to make life easier +for oldest-supported-numpy. diff --git a/doc/source/release/1.22.0-notes.rst b/doc/source/release/1.22.0-notes.rst index 0760a3dd7cb9..c5477fb163d0 100644 --- a/doc/source/release/1.22.0-notes.rst +++ b/doc/source/release/1.22.0-notes.rst @@ -3,43 +3,458 @@ ========================== NumPy 1.22.0 Release Notes ========================== +NumPy 1.22.0 is a big release featuring the work of 153 contributors spread +over 609 pull requests. There have been many improvements, highlights are: +* Annotations of the main namespace are essentially complete. Upstream is a + moving target, so there will likely be further improvements, but the major + work is done. This is probably the most user visible enhancement in this + release. +* A preliminary version of the proposed Array-API is provided. This is a step + in creating a standard collection of functions that can be used across + applications such as CuPy and JAX. +* NumPy now has a DLPack backend. DLPack provides a common interchange format + for array (tensor) data. +* New methods for ``quantile``, ``percentile``, and related functions. The new + methods provide a complete set of the methods commonly found in the + literature. +* The universal functions have been refactored to implement most of + :ref:`NEP 43 `. This also unlocks the ability to experiment with the + future DType API. +* A new configurable allocator for use by downstream projects. -Highlights -========== +These are in addition to the ongoing work to provide SIMD support for commonly +used functions, improvements to F2PY, and better documentation. +The Python versions supported in this release are 3.8-3.10, Python 3.7 has been +dropped. Note that the Mac wheels are now based on OS X 10.14 rather than 10.9 +that was used in previous NumPy release cycles. 10.14 is the oldest release +supported by Apple. Also note that 32 bit wheels are only provided for Python +3.8 and 3.9 on Windows, all other wheels are 64 bits on account of Ubuntu, +Fedora, and other Linux distributions dropping 32 bit support. All 64 bit +wheels are also linked with 64 bit integer OpenBLAS, which should fix the +occasional problems encountered by folks using truly huge arrays. -New functions -============= + +Expired deprecations +==================== + +Deprecated numeric style dtype strings have been removed +-------------------------------------------------------- +Using the strings ``"Bytes0"``, ``"Datetime64"``, ``"Str0"``, ``"Uint32"``, +and ``"Uint64"`` as a dtype will now raise a ``TypeError``. + +(`gh-19539 `__) + +Expired deprecations for ``loads``, ``ndfromtxt``, and ``mafromtxt`` in npyio +----------------------------------------------------------------------------- +``numpy.loads`` was deprecated in v1.15, with the recommendation that users use +``pickle.loads`` instead. ``ndfromtxt`` and ``mafromtxt`` were both deprecated +in v1.17 - users should use ``numpy.genfromtxt`` instead with the appropriate +value for the ``usemask`` parameter. + +(`gh-19615 `__) Deprecations ============ +Use delimiter rather than delimitor as kwarg in mrecords +-------------------------------------------------------- +The misspelled keyword argument ``delimitor`` of +``numpy.ma.mrecords.fromtextfile()`` has been changed to ``delimiter``, using +it will emit a deprecation warning. -Future Changes -============== +(`gh-19921 `__) +Passing boolean ``kth`` values to (arg-)partition has been deprecated +--------------------------------------------------------------------- +``numpy.partition`` and ``numpy.argpartition`` would previously accept boolean +values for the ``kth`` parameter, which would subsequently be converted into +integers. This behavior has now been deprecated. -Expired deprecations -==================== +(`gh-20000 `__) + +The ``np.MachAr`` class has been deprecated +------------------------------------------- +The ``numpy.MachAr`` class and ``finfo.machar `` attribute have +been deprecated. Users are encouraged to access the property if interest +directly from the corresponding ``numpy.finfo`` attribute. + +(`gh-20201 `__) Compatibility notes =================== +Distutils forces strict floating point model on clang +----------------------------------------------------- +NumPy now sets the ``-ftrapping-math`` option on clang to enforce correct +floating point error handling for universal functions. Clang defaults to +non-IEEE and C99 conform behaviour otherwise. This change (using the +equivalent but newer ``-ffp-exception-behavior=strict``) was attempted in NumPy +1.21, but was effectively never used. + +(`gh-19479 `__) + +Removed floor division support for complex types +------------------------------------------------ +Floor division of complex types will now result in a ``TypeError`` + +.. code-block:: python + + >>> a = np.arange(10) + 1j* np.arange(10) + >>> a // 1 + TypeError: ufunc 'floor_divide' not supported for the input types... + +(`gh-19135 `__) + +``numpy.vectorize`` functions now produce the same output class as the base function +------------------------------------------------------------------------------------ +When a function that respects ``numpy.ndarray`` subclasses is vectorized using +``numpy.vectorize``, the vectorized function will now be subclass-safe also for +cases that a signature is given (i.e., when creating a ``gufunc``): the output +class will be the same as that returned by the first call to the underlying +function. + +(`gh-19356 `__) + +Python 3.7 is no longer supported +--------------------------------- +Python support has been dropped. This is rather strict, there are changes that +require Python >= 3.8. + +(`gh-19665 `__) + +str/repr of complex dtypes now include space after punctuation +-------------------------------------------------------------- +The repr of ``np.dtype({"names": ["a"], "formats": [int], "offsets": [2]})`` is +now ``dtype({'names': ['a'], 'formats': ['`__) + +Corrected ``advance`` in ``PCG64DSXM`` and ``PCG64`` +---------------------------------------------------- +Fixed a bug in the ``advance`` method of ``PCG64DSXM`` and ``PCG64``. The bug +only affects results when the step was larger than :math:`2^{64}` on platforms +that do not support 128-bit integers(e.g., Windows and 32-bit Linux). + +(`gh-20049 `__) + +Change in generation of random 32 bit floating point variates +------------------------------------------------------------- +There was bug in the generation of 32 bit floating point values from the +uniform distribution that would result in the least significant bit of the +random variate always being 0. This has been fixed. + +This change affects the variates produced by the ``random.Generator`` methods +``random``, ``standard_normal``, ``standard_exponential``, and +``standard_gamma``, but only when the dtype is specified as ``numpy.float32``. + +(`gh-20314 `__) + C API changes ============= +Masked inner-loops cannot be customized anymore +----------------------------------------------- +The masked inner-loop selector is now never used. A warning will be given in +the unlikely event that it was customized. + +We do not expect that any code uses this. If you do use it, you must unset the +selector on newer NumPy version. Please also contact the NumPy developers, we +do anticipate providing a new, more specific, mechanism. + +The customization was part of a never-implemented feature to allow for faster +masked operations. + +(`gh-19259 `__) + +Experimental exposure of future DType and UFunc API +--------------------------------------------------- +The new header ``experimental_public_dtype_api.h`` allows to experiment with +future API for improved universal function and especially user DType support. +At this time it is advisable to experiment using the development version +of NumPy since some changes are expected and new features will be unlocked. + +(`gh-19919 `__) + New Features ============ +NEP 49 configurable allocators +------------------------------ +As detailed in `NEP 49`_, the function used for allocation of the data segment +of a ndarray can be changed. The policy can be set globally or in a context. +For more information see the NEP and the :ref:`data_memory` reference docs. +Also add a ``NUMPY_WARN_IF_NO_MEM_POLICY`` override to warn on dangerous use +of transfering ownership by setting ``NPY_ARRAY_OWNDATA``. + +.. _`NEP 49`: https://numpy.org/neps/nep-0049.html + +(`gh-17582 `__) + +Implementation of the NEP 47 (adopting the array API standard) +-------------------------------------------------------------- +An initial implementation of `NEP 47`_ (adoption the array API standard) has +been added as ``numpy.array_api``. The implementation is experimental and will +issue a UserWarning on import, as the `array API standard +`_ is still in draft state. +``numpy.array_api`` is a conforming implementation of the array API standard, +which is also minimal, meaning that only those functions and behaviors that are +required by the standard are implemented (see the NEP for more info). +Libraries wishing to make use of the array API standard are encouraged to use +``numpy.array_api`` to check that they are only using functionality that is +guaranteed to be present in standard conforming implementations. + +.. _`NEP 47`: https://numpy.org/neps/nep-0047-array-api-standard.html + +(`gh-18585 `__) + +Generate C/C++ API reference documentation from comments blocks is now possible +------------------------------------------------------------------------------- +This feature depends on Doxygen_ in the generation process and on Breathe_ to +integrate it with Sphinx. + +.. _`Doxygen`: https://www.doxygen.nl/index.html +.. _`Breathe`: https://breathe.readthedocs.io/en/latest/ + +(`gh-18884 `__) + +Assign the platform-specific ``c_intp`` precision via a mypy plugin +------------------------------------------------------------------- +The mypy_ plugin, introduced in `numpy/numpy#17843`_, has again been expanded: +the plugin now is now responsible for setting the platform-specific precision +of ``numpy.ctypeslib.c_intp``, the latter being used as data type for various +``numpy.ndarray.ctypes`` attributes. + +Without the plugin, aforementioned type will default to ``ctypes.c_int64``. + +To enable the plugin, one must add it to their mypy `configuration file`_: + +.. code-block:: ini + + [mypy] + plugins = numpy.typing.mypy_plugin + + +.. _mypy: http://mypy-lang.org/ +.. _configuration file: https://mypy.readthedocs.io/en/stable/config_file.html +.. _`numpy/numpy#17843`: https://github.com/numpy/numpy/pull/17843 + +(`gh-19062 `__) + +Add NEP 47-compatible dlpack support +------------------------------------ +Add a ``ndarray.__dlpack__()`` method which returns a ``dlpack`` C structure +wrapped in a ``PyCapsule``. Also add a ``np._from_dlpack(obj)`` function, where +``obj`` supports ``__dlpack__()``, and returns an ``ndarray``. + +(`gh-19083 `__) + +``keepdims`` optional argument added to ``numpy.argmin``, ``numpy.argmax`` +-------------------------------------------------------------------------- +``keepdims`` argument is added to ``numpy.argmin``, ``numpy.argmax``. If set +to ``True``, the axes which are reduced are left in the result as dimensions +with size one. The resulting array has the same number of dimensions and will +broadcast with the input array. + +(`gh-19211 `__) + +``bit_count`` to compute the number of 1-bits in an integer +----------------------------------------------------------- +Computes the number of 1-bits in the absolute value of the input. +This works on all the numpy integer types. Analogous to the builtin +``int.bit_count`` or ``popcount`` in C++. + +.. code-block:: python + + >>> np.uint32(1023).bit_count() + 10 + >>> np.int32(-127).bit_count() + 7 + +(`gh-19355 `__) + +The ``ndim`` and ``axis`` attributes have been added to ``numpy.AxisError`` +--------------------------------------------------------------------------- +The ``ndim`` and ``axis`` parameters are now also stored as attributes +within each ``numpy.AxisError`` instance. + +(`gh-19459 `__) + +Preliminary support for ``windows/arm64`` target +------------------------------------------------ +``numpy`` added support for windows/arm64 target. Please note ``OpenBLAS`` +support is not yet available for windows/arm64 target. + +(`gh-19513 `__) + +Added support for LoongArch +--------------------------- +LoongArch is a new instruction set, numpy compilation failure on LoongArch +architecture, so add the commit. + +(`gh-19527 `__) + +A ``.clang-format`` file has been added +--------------------------------------- +Clang-format is a C/C++ code formatter, together with the added +``.clang-format`` file, it produces code close enough to the NumPy +C_STYLE_GUIDE for general use. Clang-format version 12+ is required due to the +use of several new features, it is available in Fedora 34 and Ubuntu Focal +among other distributions. + +(`gh-19754 `__) + +``is_integer`` is now available to ``numpy.floating`` and ``numpy.integer`` +--------------------------------------------------------------------------- +Based on its counterpart in Python ``float`` and ``int``, the numpy floating +point and integer types now support ``float.is_integer``. Returns ``True`` if +the number is finite with integral value, and ``False`` otherwise. + +.. code-block:: python + + >>> np.float32(-2.0).is_integer() + True + >>> np.float64(3.2).is_integer() + False + >>> np.int32(-2).is_integer() + True + +(`gh-19803 `__) + +Symbolic parser for Fortran dimension specifications +---------------------------------------------------- +A new symbolic parser has been added to f2py in order to correctly parse +dimension specifications. The parser is the basis for future improvements and +provides compatibility with Draft Fortran 202x. + +(`gh-19805 `__) + +``ndarray``, ``dtype`` and ``number`` are now runtime-subscriptable +------------------------------------------------------------------- +Mimicking :pep:`585`, the ``numpy.ndarray``, ``numpy.dtype`` and +``numpy.number`` classes are now subscriptable for python 3.9 and later. +Consequently, expressions that were previously only allowed in .pyi stub files +or with the help of ``from __future__ import annotations`` are now also legal +during runtime. + +.. code-block:: python + + >>> import numpy as np + >>> from typing import Any + + >>> np.ndarray[Any, np.dtype[np.float64]] + numpy.ndarray[typing.Any, numpy.dtype[numpy.float64]] + +(`gh-19879 `__) + Improvements ============ +``ctypeslib.load_library`` can now take any path-like object +------------------------------------------------------------ +All parameters in the can now take any :term:`python:path-like object`. +This includes the likes of strings, bytes and objects implementing the +:meth:`__fspath__` protocol. + +(`gh-17530 `__) + +Add ``smallest_normal`` and ``smallest_subnormal`` attributes to ``finfo`` +-------------------------------------------------------------------------- +The attributes ``smallest_normal`` and ``smallest_subnormal`` are available as +an extension of ``finfo`` class for any floating-point data type. To use these +new attributes, write ``np.finfo(np.float64).smallest_normal`` or +``np.finfo(np.float64).smallest_subnormal``. + +(`gh-18536 `__) + +``numpy.linalg.qr`` accepts stacked matrices as inputs +------------------------------------------------------ +``numpy.linalg.qr`` is able to produce results for stacked matrices as inputs. +Moreover, the implementation of QR decomposition has been shifted to C from +Python. + +(`gh-19151 `__) + +``numpy.fromregex`` now accepts ``os.PathLike`` implementations +--------------------------------------------------------------- +``numpy.fromregex`` now accepts objects implementing the ``__fspath__`` +protocol, *e.g.* ``pathlib.Path``. + +(`gh-19680 `__) + +Add new methods for ``quantile`` and ``percentile`` +--------------------------------------------------- +``quantile`` and ``percentile`` now have have a ``method=`` keyword argument +supporting 13 different methods. This replaces the ``interpolation=`` keyword +argument. + +The methods are now aligned with nine methods which can be found in scientific +literature and the R language. The remaining methods are the previous +discontinuous variations of the default "linear" one. + +Please see the documentation of ``numpy.percentile`` for more information. + +(`gh-19857 `__) + +Missing parameters have been added to the ``nan`` functions +-------------------------------------------------------------- +A number of the ``nan`` functions previously lacked parameters that were +present in their ````-based counterpart, *e.g.* the ``where`` parameter was +present in ``numpy.mean`` but absent from ``numpy.nanmean``. + +The following parameters have now been added to the ``nan`` functions: + +* nanmin: ``initial`` & ``where`` +* nanmax: ``initial`` & ``where`` +* nanargmin: ``keepdims`` & ``out`` +* nanargmax: ``keepdims`` & ``out`` +* nansum: ``initial`` & ``where`` +* nanprod: ``initial`` & ``where`` +* nanmean: ``where`` +* nanvar: ``where`` +* nanstd: ``where`` + +(`gh-20027 `__) + +Annotating the main Numpy namespace +----------------------------------- +Starting from the 1.20 release, PEP 484 type annotations have been included for +parts of the NumPy library; annotating the remaining functions being a work in +progress. With the release of 1.22 this process has been completed for the main +NumPy namespace, which is now fully annotated. + +Besides the main namespace, a limited number of sub-packages contain +annotations as well. This includes, among others, ``numpy.testing``, +``numpy.linalg`` and ``numpy.random`` (available since 1.21). + +(`gh-20217 `__) + +Vectorize umath module using AVX-512 +------------------------------------- +By leveraging Intel Short Vector Math Library (SVML), 18 umath functions +(``exp2``, ``log2``, ``log10``, ``expm1``, ``log1p``, ``cbrt``, ``sin``, +``cos``, ``tan``, ``arcsin``, ``arccos``, ``arctan``, ``sinh``, ``cosh``, +``tanh``, ``arcsinh``, ``arccosh``, ``arctanh``) are vectorized using AVX-512 +instruction set for both single and double precision implementations. This +change is currently enabled only for Linux users and on processors with AVX-512 +instruction set. It provides an average speed up of 32x and 14x for single and +double precision functions respectively. + +(`gh-19478 `__) + +OpenBLAS v0.3.18 +---------------- +Update the OpenBLAS used in testing and in wheels to v0.3.18 + +(`gh-20058 `__) -Changes -======= diff --git a/doc/source/release/1.22.1-notes.rst b/doc/source/release/1.22.1-notes.rst new file mode 100644 index 000000000000..0012f199eaf7 --- /dev/null +++ b/doc/source/release/1.22.1-notes.rst @@ -0,0 +1,63 @@ +.. currentmodule:: numpy + +========================== +NumPy 1.22.1 Release Notes +========================== + +The NumPy 1.22.1 is a maintenance release that fixes bugs discovered after the +1.22.0 release. Notable fixes are: + +- Fix f2PY docstring problems (SciPy) +- Fix reduction type problems (AstroPy) +- Fix various typing bugs. + +The Python versions supported for this release are 3.8-3.10. + + +Contributors +============ + +A total of 14 people contributed to this release. People with a "+" by their +names contributed a patch for the first time. + +* Arryan Singh +* Bas van Beek +* Charles Harris +* Denis Laxalde +* Isuru Fernando +* Kevin Sheppard +* Matthew Barber +* Matti Picus +* Melissa Weber Mendonça +* Mukulika Pahari +* Omid Rajaei + +* Pearu Peterson +* Ralf Gommers +* Sebastian Berg + + +Pull requests merged +==================== + +A total of 20 pull requests were merged for this release. + +* `#20702 `__: MAINT, DOC: Post 1.22.0 release fixes. +* `#20703 `__: DOC, BUG: Use pngs instead of svgs. +* `#20704 `__: DOC: Fixed the link on user-guide landing page +* `#20714 `__: BUG: Restore vc141 support +* `#20724 `__: BUG: Fix array dimensions solver for multidimensional arguments... +* `#20725 `__: TYP: change type annotation for ``__array_namespace__`` to ModuleType +* `#20726 `__: TYP, MAINT: Allow ``ndindex`` to accept integer tuples +* `#20757 `__: BUG: Relax dtype identity check in reductions +* `#20763 `__: TYP: Allow time manipulation functions to accept ``date`` and ``timedelta``... +* `#20768 `__: TYP: Relax the type of ``ndarray.__array_finalize__`` +* `#20795 `__: MAINT: Raise RuntimeError if setuptools version is too recent. +* `#20796 `__: BUG, DOC: Fixes SciPy docs build warnings +* `#20797 `__: DOC: fix OpenBLAS version in release note +* `#20798 `__: PERF: Optimize array check for bounded 0,1 values +* `#20805 `__: BUG: Fix that reduce-likes honor out always (and live in the... +* `#20806 `__: BUG: ``array_api.argsort(descending=True)`` respects relative... +* `#20807 `__: BUG: Allow integer inputs for pow-related functions in ``array_api`` +* `#20814 `__: DOC: Refer to NumPy, not pandas, in main page +* `#20815 `__: DOC: Update Copyright to 2022 [License] +* `#20819 `__: BUG: Return correctly shaped inverse indices in array_api set... diff --git a/doc/source/release/1.22.2-notes.rst b/doc/source/release/1.22.2-notes.rst new file mode 100644 index 000000000000..974560fc7a45 --- /dev/null +++ b/doc/source/release/1.22.2-notes.rst @@ -0,0 +1,64 @@ +.. currentmodule:: numpy + +========================== +NumPy 1.22.2 Release Notes +========================== + +The NumPy 1.22.2 is maintenance release that fixes bugs discovered after the +1.22.1 release. Notable fixes are: + +- Several build related fixes for downstream projects and other platforms. +- Various Annotation fixes/additions. +- Numpy wheels for Windows will use the 1.41 tool chain, fixing downstream link + problems for projects using NumPy provided libraries on Windows. +- Deal with CVE-2021-41495 complaint. + +The Python versions supported for this release are 3.8-3.10. + +Contributors +============ + +A total of 14 people contributed to this release. People with a "+" by their +names contributed a patch for the first time. + +* Andrew J. Hesford + +* Bas van Beek +* Brénainn Woodsend + +* Charles Harris +* Hood Chatham +* Janus Heide + +* Leo Singer +* Matti Picus +* Mukulika Pahari +* Niyas Sait +* Pearu Peterson +* Ralf Gommers +* Sebastian Berg +* Serge Guelton + +Pull requests merged +==================== + +A total of 21 pull requests were merged for this release. + +* `#20842 `__: BLD: Add NPY_DISABLE_SVML env var to opt out of SVML +* `#20843 `__: BUG: Fix build of third party extensions with Py_LIMITED_API +* `#20844 `__: TYP: Fix pyright being unable to infer the ``real`` and ``imag``... +* `#20845 `__: BUG: Fix comparator function signatures +* `#20906 `__: BUG: Avoid importing ``numpy.distutils`` on import numpy.testing +* `#20907 `__: MAINT: remove outdated mingw32 fseek support +* `#20908 `__: TYP: Relax the return type of ``np.vectorize`` +* `#20909 `__: BUG: fix f2py's define for threading when building with Mingw +* `#20910 `__: BUG: distutils: fix building mixed C/Fortran extensions +* `#20912 `__: DOC,TST: Fix Pandas code example as per new release +* `#20935 `__: TYP, MAINT: Add annotations for ``flatiter.__setitem__`` +* `#20936 `__: MAINT, TYP: Added missing where typehints in ``fromnumeric.pyi`` +* `#20937 `__: BUG: Fix build_ext interaction with non numpy extensions +* `#20938 `__: BUG: Fix missing intrinsics for windows/arm64 target +* `#20945 `__: REL: Prepare for the NumPy 1.22.2 release. +* `#20982 `__: MAINT: f2py: don't generate code that triggers ``-Wsometimes-uninitialized``. +* `#20983 `__: BUG: Fix incorrect return type in reduce without initial value +* `#20984 `__: ENH: review return values for PyArray_DescrNew +* `#20985 `__: MAINT: be more tolerant of setuptools >= 60 +* `#20986 `__: BUG: Fix misplaced return. +* `#20992 `__: MAINT: Further small return value validation fixes diff --git a/doc/source/release/1.22.3-notes.rst b/doc/source/release/1.22.3-notes.rst new file mode 100644 index 000000000000..6c94e2d28baa --- /dev/null +++ b/doc/source/release/1.22.3-notes.rst @@ -0,0 +1,48 @@ +.. currentmodule:: numpy + +========================== +NumPy 1.22.3 Release Notes +========================== + +NumPy 1.22.3 is a maintenance release that fixes bugs discovered after the +1.22.2 release. The most noticeable fixes may be those for DLPack. One that may +cause some problems is disallowing strings as inputs to logical ufuncs. It is +still undecided how strings should be treated in those functions and it was +thought best to simply disallow them until a decision was reached. That should +not cause problems with older code. + +The Python versions supported for this release are 3.8-3.10. Note that the Mac +wheels are now based on OS X 10.14 rather than 10.9 that was used in previous +NumPy release cycles. 10.14 is the oldest release supported by Apple. + +Contributors +============ + +A total of 9 people contributed to this release. People with a "+" by their +names contributed a patch for the first time. + +* @GalaxySnail + +* Alexandre de Siqueira +* Bas van Beek +* Charles Harris +* Melissa Weber Mendonça +* Ross Barnowski +* Sebastian Berg +* Tirth Patel +* Matthieu Darbois + +Pull requests merged +==================== + +A total of 10 pull requests were merged for this release. + +* `#21048 `__: MAINT: Use "3.10" instead of "3.10-dev" on travis. +* `#21106 `__: TYP,MAINT: Explicitly allow sequences of array-likes in ``np.concatenate`` +* `#21137 `__: BLD,DOC: skip broken ipython 8.1.0 +* `#21138 `__: BUG, ENH: np._from_dlpack: export correct device information +* `#21139 `__: BUG: Fix numba DUFuncs added loops getting picked up +* `#21140 `__: BUG: Fix unpickling an empty ndarray with a non-zero dimension... +* `#21141 `__: BUG: use ThreadPoolExecutor instead of ThreadPool +* `#21142 `__: API: Disallow strings in logical ufuncs +* `#21143 `__: MAINT, DOC: Fix SciPy intersphinx link +* `#21148 `__: BUG,ENH: np._from_dlpack: export arrays with any strided size-1... diff --git a/doc/source/release/1.22.4-notes.rst b/doc/source/release/1.22.4-notes.rst new file mode 100644 index 000000000000..1f418ca62adf --- /dev/null +++ b/doc/source/release/1.22.4-notes.rst @@ -0,0 +1,62 @@ +.. currentmodule:: numpy + +========================== +NumPy 1.22.4 Release Notes +========================== + +NumPy 1.22.4 is a maintenance release that fixes bugs discovered after the +1.22.3 release. In addition, the wheels for this release are built using the +recently released Cython 0.29.30, which should fix the reported problems with +`debugging `_. + +The Python versions supported for this release are 3.8-3.10. Note that the Mac +wheels are based on OS X 10.15 rather than 10.9 that was used in previous +NumPy release cycles. + +Contributors +============ + +A total of 12 people contributed to this release. People with a "+" by their +names contributed a patch for the first time. + +* Alexander Shadchin +* Bas van Beek +* Charles Harris +* Hood Chatham +* Jarrod Millman +* John-Mark Gurney + +* Junyan Ou + +* Mariusz Felisiak + +* Ross Barnowski +* Sebastian Berg +* Serge Guelton +* Stefan van der Walt + +Pull requests merged +==================== + +A total of 22 pull requests were merged for this release. + +* `#21191 `__: TYP, BUG: Fix ``np.lib.stride_tricks`` re-exported under the... +* `#21192 `__: TST: Bump mypy from 0.931 to 0.940 +* `#21243 `__: MAINT: Explicitly re-export the types in ``numpy._typing`` +* `#21245 `__: MAINT: Specify sphinx, numpydoc versions for CI doc builds +* `#21275 `__: BUG: Fix typos +* `#21277 `__: ENH, BLD: Fix math feature detection for wasm +* `#21350 `__: MAINT: Fix failing simd and cygwin tests. +* `#21438 `__: MAINT: Fix failing Python 3.8 32-bit Windows test. +* `#21444 `__: BUG: add linux guard per #21386 +* `#21445 `__: BUG: Allow legacy dtypes to cast to datetime again +* `#21446 `__: BUG: Make mmap handling safer in frombuffer +* `#21447 `__: BUG: Stop using PyBytesObject.ob_shash deprecated in Python 3.11. +* `#21448 `__: ENH: Introduce numpy.core.setup_common.NPY_CXX_FLAGS +* `#21472 `__: BUG: Ensure compile errors are raised correclty +* `#21473 `__: BUG: Fix segmentation fault +* `#21474 `__: MAINT: Update doc requirements +* `#21475 `__: MAINT: Mark ``npy_memchr`` with ``no_sanitize("alignment")`` on clang +* `#21512 `__: DOC: Proposal - make the doc landing page cards more similar... +* `#21525 `__: MAINT: Update Cython version to 0.29.30. +* `#21536 `__: BUG: Fix GCC error during build configuration +* `#21541 `__: REL: Prepare for the NumPy 1.22.4 release. +* `#21547 `__: MAINT: Skip tests that fail on PyPy. + diff --git a/doc/source/release/1.23.0-notes.rst b/doc/source/release/1.23.0-notes.rst new file mode 100644 index 000000000000..2301192ccab8 --- /dev/null +++ b/doc/source/release/1.23.0-notes.rst @@ -0,0 +1,412 @@ +.. currentmodule:: numpy + +========================== +NumPy 1.23.0 Release Notes +========================== + +The NumPy 1.23.0 release continues the ongoing work to improve the handling and +promotion of dtypes, increase the execution speed, clarify the documentation, +and expire old deprecations. The highlights are: + +* Implementation of ``loadtxt`` in C, greatly improving its performance. +* Exposing DLPack at the Python level for easy data exchange. +* Changes to the promotion and comparisons of structured dtypes. +* Improvements to f2py. + +See below for the details, + + +New functions +============= + +* A masked array specialization of ``ndenumerate`` is now available as + ``numpy.ma.ndenumerate``. It provides an alternative to ``numpy.ndenumerate`` + and skips masked values by default. + + (`gh-20020 `__) + +* ``numpy.from_dlpack`` has been added to allow easy exchange of data using the + DLPack protocol. It accepts Python objects that implement the ``__dlpack__`` + and ``__dlpack_device__`` methods and returns a ndarray object which is + generally the view of the data of the input object. + + (`gh-21145 `__) + + +Deprecations +============ + +* Setting ``__array_finalize__`` to ``None`` is deprecated. It must now be + a method and may wish to call ``super().__array_finalize__(obj)`` after + checking for ``None`` or if the NumPy version is sufficiently new. + + (`gh-20766 `__) + +* Using ``axis=32`` (``axis=np.MAXDIMS``) in many cases had the + same meaning as ``axis=None``. This is deprecated and ``axis=None`` + must be used instead. + + (`gh-20920 `__) + +* The hook function ``PyDataMem_SetEventHook`` has been deprecated and the + demonstration of its use in tool/allocation_tracking has been removed. The + ability to track allocations is now built-in to python via ``tracemalloc``. + + (`gh-20394 `__) + +* ``numpy.distutils`` has been deprecated, as a result of ``distutils`` itself + being deprecated. It will not be present in NumPy for Python >= 3.12, and + will be removed completely 2 years after the release of Python 3.12 For more + details, see :ref:`distutils-status-migration`. + + (`gh-20875 `__) + +* ``numpy.loadtxt`` will now give a ``DeprecationWarning`` when an integer + ``dtype`` is requested but the value is formatted as a floating point number. + + (`gh-21663 `__) + + +Expired deprecations +==================== + +* The ``NpzFile.iteritems()`` and ``NpzFile.iterkeys()`` methods have been + removed as part of the continued removal of Python 2 compatibility. This + concludes the deprecation from 1.15. + + (`gh-16830 `__) + +* The ``alen`` and ``asscalar`` functions have been removed. + + (`gh-20414 `__) + +* The ``UPDATEIFCOPY`` array flag has been removed together with the enum + ``NPY_ARRAY_UPDATEIFCOPY``. The associated (and deprecated) + ``PyArray_XDECREF_ERR`` was also removed. These were all deprecated in 1.14. They + are replaced by ``NPY_ARRAY_WRITEBACKIFCOPY``, that requires calling + ``PyArray_ResolveWritebackIfCopy`` before the array is deallocated. + + (`gh-20589 `__) + +* Exceptions will be raised during array-like creation. When an object raised + an exception during access of the special attributes ``__array__`` or + ``__array_interface__``, this exception was usually ignored. This behaviour + was deprecated in 1.21, and the exception will now be raised. + + (`gh-20835 `__) + +* Multidimensional indexing with non-tuple values is not allowed. Previously, + code such as ``arr[ind]`` where ``ind = [[0, 1], [0, 1]]`` produced a + ``FutureWarning`` and was interpreted as a multidimensional index (i.e., + ``arr[tuple(ind)]``). Now this example is treated like an array index over a + single dimension (``arr[array(ind)]``). Multidimensional indexing with + anything but a tuple was deprecated in NumPy 1.15. + + (`gh-21029 `__) + +* Changing to a dtype of different size in F-contiguous arrays is no longer + permitted. Deprecated since Numpy 1.11.0. See below for an extended + explanation of the effects of this change. + + (`gh-20722 `__) + + +New Features +============ + +crackfortran has support for operator and assignment overloading +---------------------------------------------------------------- +``crackfortran`` parser now understands operator and assignment +definitions in a module. They are added in the ``body`` list of the +module which contains a new key ``implementedby`` listing the names +of the subroutines or functions implementing the operator or +assignment. + +(`gh-15006 `__) + +f2py supports reading access type attributes from derived type statements +------------------------------------------------------------------------- +As a result, one does not need to use ``public`` or ``private`` statements to +specify derived type access properties. + +(`gh-15844 `__) + +New parameter ``ndmin`` added to ``genfromtxt`` +------------------------------------------------------------------------- +This parameter behaves the same as ``ndmin`` from ``numpy.loadtxt``. + +(`gh-20500 `__) + +``np.loadtxt`` now supports quote character and single converter function +------------------------------------------------------------------------- +``numpy.loadtxt`` now supports an additional ``quotechar`` keyword argument +which is not set by default. Using ``quotechar='"'`` will read quoted fields +as used by the Excel CSV dialect. + +Further, it is now possible to pass a single callable rather than a dictionary +for the ``converters`` argument. + +(`gh-20580 `__) + +Changing to dtype of a different size now requires contiguity of only the last axis +----------------------------------------------------------------------------------- +Previously, viewing an array with a dtype of a different item size required that +the entire array be C-contiguous. This limitation would unnecessarily force the +user to make contiguous copies of non-contiguous arrays before being able to +change the dtype. + +This change affects not only ``ndarray.view``, but other construction +mechanisms, including the discouraged direct assignment to ``ndarray.dtype``. + +This change expires the deprecation regarding the viewing of F-contiguous +arrays, described elsewhere in the release notes. + +(`gh-20722 `__) + +Deterministic output files for F2PY +----------------------------------- +For F77 inputs, ``f2py`` will generate ``modname-f2pywrappers.f`` +unconditionally, though these may be empty. For free-form inputs, +``modname-f2pywrappers.f``, ``modname-f2pywrappers2.f90`` will both be generated +unconditionally, and may be empty. This allows writing generic output rules in +``cmake`` or ``meson`` and other build systems. Older behavior can be restored +by passing ``--skip-empty-wrappers`` to ``f2py``. :ref:`f2py-meson` details usage. + +(`gh-21187 `__) + +``keepdims`` parameter for ``average`` +-------------------------------------- +The parameter ``keepdims`` was added to the functions ``numpy.average`` +and ``numpy.ma.average``. The parameter has the same meaning as it +does in reduction functions such as ``numpy.sum`` or ``numpy.mean``. + +(`gh-21485 `__) + +New parameter ``equal_nan`` added to ``np.unique`` +-------------------------------------------------- +``np.unique`` was changed in 1.21 to treat all ``NaN`` values as equal and return +a single ``NaN``. Setting ``equal_nan=False`` will restore pre-1.21 behavior +to treat ``NaNs`` as unique. Defaults to ``True``. + +(`gh-21623 `__) + + +Compatibility notes +=================== + +1D ``np.linalg.norm`` preserves float input types, even for scalar results +-------------------------------------------------------------------------- +Previously, this would promote to ``float64`` when the ``ord`` argument was +not one of the explicitly listed values, e.g. ``ord=3``:: + + >>> f32 = np.float32([1, 2]) + >>> np.linalg.norm(f32, 2).dtype + dtype('float32') + >>> np.linalg.norm(f32, 3) + dtype('float64') # numpy 1.22 + dtype('float32') # numpy 1.23 + +This change affects only ``float32`` and ``float16`` vectors with ``ord`` +other than ``-Inf``, ``0``, ``1``, ``2``, and ``Inf``. + +(`gh-17709 `__) + +Changes to structured (void) dtype promotion and comparisons +------------------------------------------------------------ +In general, NumPy now defines correct, but slightly limited, promotion for +structured dtypes by promoting the subtypes of each field instead of raising +an exception:: + + >>> np.result_type(np.dtype("i,i"), np.dtype("i,d")) + dtype([('f0', '`__) + +``NPY_RELAXED_STRIDES_CHECKING`` has been removed +------------------------------------------------- +NumPy cannot be compiled with ``NPY_RELAXED_STRIDES_CHECKING=0`` +anymore. Relaxed strides have been the default for many years and +the option was initially introduced to allow a smoother transition. + +(`gh-20220 `__) + +``np.loadtxt`` has recieved several changes +------------------------------------------- + +The row counting of ``numpy.loadtxt`` was fixed. ``loadtxt`` ignores fully +empty lines in the file, but counted them towards ``max_rows``. +When ``max_rows`` is used and the file contains empty lines, these will now +not be counted. Previously, it was possible that the result contained fewer +than ``max_rows`` rows even though more data was available to be read. +If the old behaviour is required, ``itertools.islice`` may be used:: + + import itertools + lines = itertools.islice(open("file"), 0, max_rows) + result = np.loadtxt(lines, ...) + +While generally much faster and improved, ``numpy.loadtxt`` may now fail to +converter certain strings to numbers that were previously successfully read. +The most important cases for this are: + +* Parsing floating point values such as ``1.0`` into integers is now deprecated. +* Parsing hexadecimal floats such as ``0x3p3`` will fail +* An ``_`` was previously accepted as a thousands delimiter ``100_000``. + This will now result in an error. + +If you experience these limitations, they can all be worked around by passing +appropriate ``converters=``. NumPy now supports passing a single converter +to be used for all columns to make this more convenient. +For example, ``converters=float.fromhex`` can read hexadecimal float numbers +and ``converters=int`` will be able to read ``100_000``. + +Further, the error messages have been generally improved. However, this means +that error types may differ. In particularly, a ``ValueError`` is now always +raised when parsing of a single entry fails. + +(`gh-20580 `__) + + +Improvements +============ + +``ndarray.__array_finalize__`` is now callable +---------------------------------------------- +This means subclasses can now use ``super().__array_finalize__(obj)`` +without worrying whether ``ndarray`` is their superclass or not. +The actual call remains a no-op. + +(`gh-20766 `__) + +Add support for VSX4/Power10 +---------------------------------------------- +With VSX4/Power10 enablement, the new instructions available in +Power ISA 3.1 can be used to accelerate some NumPy operations, +e.g., floor_divide, modulo, etc. + +(`gh-20821 `__) + +``np.fromiter`` now accepts objects and subarrays +------------------------------------------------- +The ``numpy.fromiter`` function now supports object and +subarray dtypes. Please see he function documentation for +examples. + +(`gh-20993 `__) + +Math C library feature detection now uses correct signatures +------------------------------------------------------------ +Compiling is preceded by a detection phase to determine whether the +underlying libc supports certain math operations. Previously this code +did not respect the proper signatures. Fixing this enables compilation +for the ``wasm-ld`` backend (compilation for web assembly) and reduces +the number of warnings. + +(`gh-21154 `__) + +``np.kron`` now maintains subclass information +---------------------------------------------- +``np.kron`` maintains subclass information now such as masked arrays +while computing the Kronecker product of the inputs + +.. code-block:: python + + >>> x = ma.array([[1, 2], [3, 4]], mask=[[0, 1], [1, 0]]) + >>> np.kron(x,x) + masked_array( + data=[[1, --, --, --], + [--, 4, --, --], + [--, --, 4, --], + [--, --, --, 16]], + mask=[[False, True, True, True], + [ True, False, True, True], + [ True, True, False, True], + [ True, True, True, False]], + fill_value=999999) + +.. warning:: + ``np.kron`` output now follows ``ufunc`` ordering (``multiply``) + to determine the output class type + + .. code-block:: python + + >>> class myarr(np.ndarray): + >>> __array_priority__ = -1 + >>> a = np.ones([2, 2]) + >>> ma = myarray(a.shape, a.dtype, a.data) + >>> type(np.kron(a, ma)) == np.ndarray + False # Before it was True + >>> type(np.kron(a, ma)) == myarr + True + +(`gh-21262 `__) + + +Performance improvements and changes +==================================== + +Faster ``np.loadtxt`` +--------------------- +``numpy.loadtxt`` is now generally much faster than previously as most of it +is now implemented in C. + +(`gh-20580 `__) + +Faster reduction operators +-------------------------- +Reduction operations like ``numpy.sum``, ``numpy.prod``, ``numpy.add.reduce``, +``numpy.logical_and.reduce`` on contiguous integer-based arrays are now +much faster. + +(`gh-21001 `__) + +Faster ``np.where`` +------------------- +``numpy.where`` is now much faster than previously on unpredictable/random +input data. + +(`gh-21130 `__) + +Faster operations on NumPy scalars +---------------------------------- +Many operations on NumPy scalars are now significantly faster, although +rare operations (e.g. with 0-D arrays rather than scalars) may be slower +in some cases. +However, even with these improvements users who want the best performance +for their scalars, may want to convert a known NumPy scalar into a Python +one using ``scalar.item()``. + +(`gh-21188 `__) + +Faster ``np.kron`` +------------------ +``numpy.kron`` is about 80% faster as the product is now computed +using broadcasting. + +(`gh-21354 `__) diff --git a/doc/source/release/1.23.1-notes.rst b/doc/source/release/1.23.1-notes.rst new file mode 100644 index 000000000000..3efc5dc6f3aa --- /dev/null +++ b/doc/source/release/1.23.1-notes.rst @@ -0,0 +1,45 @@ +.. currentmodule:: numpy + +========================== +NumPy 1.23.1 Release Notes +========================== + +NumPy 1.23.1 is a maintenance release that fixes bugs discovered after the +1.23.0 release. Notable fixes are: + +- Fix searchsorted for float16 NaNs +- Fix compilation on Apple M1 +- Fix KeyError in crackfortran operator support (Slycot) + +The Python version supported for this release are 3.8-3.10. + + +Contributors +============ + +A total of 7 people contributed to this release. People with a "+" by their +names contributed a patch for the first time. + +* Charles Harris +* Matthias Koeppe + +* Pranab Das + +* Rohit Goswami +* Sebastian Berg +* Serge Guelton +* Srimukh Sripada + + + +Pull requests merged +==================== + +A total of 8 pull requests were merged for this release. + +* `#21866 `__: BUG: Fix discovered MachAr (still used within valgrind) +* `#21867 `__: BUG: Handle NaNs correctly for float16 during sorting +* `#21868 `__: BUG: Use ``keepdims`` during normalization in ``np.average`` and... +* `#21869 `__: DOC: mention changes to ``max_rows`` behaviour in ``np.loadtxt`` +* `#21870 `__: BUG: Reject non integer array-likes with size 1 in delete +* `#21949 `__: BLD: Make can_link_svml return False for 32bit builds on x86_64 +* `#21951 `__: BUG: Reorder extern "C" to only apply to function declarations... +* `#21952 `__: BUG: Fix KeyError in crackfortran operator support + diff --git a/doc/source/release/1.23.2-notes.rst b/doc/source/release/1.23.2-notes.rst new file mode 100644 index 000000000000..1dc3bb7b10e4 --- /dev/null +++ b/doc/source/release/1.23.2-notes.rst @@ -0,0 +1,50 @@ +.. currentmodule:: numpy + +========================== +NumPy 1.23.2 Release Notes +========================== + +NumPy 1.23.2 is a maintenance release that fixes bugs discovered after the +1.23.1 release. Notable features are: + +- Typing changes needed for Python 3.11 +- Wheels for Python 3.11.0rc1 + +The Python versions supported for this release are 3.8-3.11. + +Contributors +============ + +A total of 9 people contributed to this release. People with a "+" by their +names contributed a patch for the first time. + +* Alexander Grund + +* Bas van Beek +* Charles Harris +* Jon Cusick + +* Matti Picus +* Michael Osthege + +* Pal Barta + +* Ross Barnowski +* Sebastian Berg + +Pull requests merged +==================== + +A total of 15 pull requests were merged for this release. + +* `#22030 `__: ENH: Add ``__array_ufunc__`` typing support to the ``nin=1`` ufuncs +* `#22031 `__: MAINT, TYP: Fix ``np.angle`` dtype-overloads +* `#22032 `__: MAINT: Do not let ``_GenericAlias`` wrap the underlying classes'... +* `#22033 `__: TYP,MAINT: Allow ``einsum`` subscripts to be passed via integer... +* `#22034 `__: MAINT,TYP: Add object-overloads for the ``np.generic`` rich comparisons +* `#22035 `__: MAINT,TYP: Allow the ``squeeze`` and ``transpose`` method to... +* `#22036 `__: BUG: Fix subarray to object cast ownership details +* `#22037 `__: BUG: Use ``Popen`` to silently invoke f77 -v +* `#22038 `__: BUG: Avoid errors on NULL during deepcopy +* `#22039 `__: DOC: Add versionchanged for converter callable behavior. +* `#22057 `__: MAINT: Quiet the anaconda uploads. +* `#22078 `__: ENH: reorder includes for testing on top of system installations... +* `#22106 `__: TST: fix test_linear_interpolation_formula_symmetric +* `#22107 `__: BUG: Fix skip condition for test_loss_of_precision[complex256] +* `#22115 `__: BLD: Build python3.11.0rc1 wheels. diff --git a/doc/source/release/1.23.3-notes.rst b/doc/source/release/1.23.3-notes.rst new file mode 100644 index 000000000000..882206f82cb0 --- /dev/null +++ b/doc/source/release/1.23.3-notes.rst @@ -0,0 +1,56 @@ +.. currentmodule:: numpy + +========================== +NumPy 1.23.3 Release Notes +========================== +NumPy 1.23.3 is a maintenance release that fixes bugs discovered after the +1.23.2 release. There is no major theme for this release, the main improvements +are for some downstream builds and some annotation corner cases. The Python +versions supported for this release are 3.8-3.11. + +Note that we will move to MacOS 11 for the NumPy 1.23.4 release, the 10.15 +version currently used will no longer be supported by our build infrastructure +at that point. + +Contributors +============ + +A total of 16 people contributed to this release. People with a "+" by their +names contributed a patch for the first time. + +* Aaron Meurer +* Bas van Beek +* Charles Harris +* Ganesh Kathiresan +* Gavin Zhang + +* Iantra Solari+ +* Jyn Spring 琴春 + +* Matti Picus +* Rafael Cardoso Fernandes Sousa +* Rafael Sousa + +* Ralf Gommers +* Rin Cat (鈴猫) + +* Saransh Chopra + +* Sayed Adel +* Sebastian Berg +* Serge Guelton + +Pull requests merged +==================== + +A total of 14 pull requests were merged for this release. + +* `#22136 `__: BLD: Add Python 3.11 wheels to aarch64 build +* `#22148 `__: MAINT: Update setup.py for Python 3.11. +* `#22155 `__: CI: Test NumPy build against old versions of GCC(6, 7, 8) +* `#22156 `__: MAINT: support IBM i system +* `#22195 `__: BUG: Fix circleci build +* `#22214 `__: BUG: Expose heapsort algorithms in a shared header +* `#22215 `__: BUG: Support using libunwind for backtrack +* `#22216 `__: MAINT: fix an incorrect pointer type usage in f2py +* `#22220 `__: BUG: change overloads to play nice with pyright. +* `#22221 `__: TST,BUG: Use fork context to fix MacOS savez test +* `#22222 `__: TYP,BUG: Reduce argument validation in C-based ``__class_getitem__`` +* `#22223 `__: TST: ensure ``np.equal.reduce`` raises a ``TypeError`` +* `#22224 `__: BUG: Fix the implementation of numpy.array_api.vecdot +* `#22230 `__: BUG: Better report integer division overflow (backport) diff --git a/doc/source/release/1.23.4-notes.rst b/doc/source/release/1.23.4-notes.rst new file mode 100644 index 000000000000..b92b2423e9d9 --- /dev/null +++ b/doc/source/release/1.23.4-notes.rst @@ -0,0 +1,48 @@ +.. currentmodule:: numpy + +========================== +NumPy 1.23.4 Release Notes +========================== +NumPy 1.23.4 is a maintenance release that fixes bugs discovered after the +1.23.3 release and keeps the build infrastructure current. The main +improvements are fixes for some annotation corner cases, a fix for a long time +``nested_iters`` memory leak, and a fix of complex vector dot for very large +arrays. The Python versions supported for this release are 3.8-3.11. + +Note that the mypy version needs to be 0.981+ if you test using Python 3.10.7, +otherwise the typing tests will fail. + +Contributors +============ + +A total of 8 people contributed to this release. People with a "+" by their +names contributed a patch for the first time. + +* Bas van Beek +* Charles Harris +* Matthew Barber +* Matti Picus +* Ralf Gommers +* Ross Barnowski +* Sebastian Berg +* Sicheng Zeng + + +Pull requests merged +==================== + +A total of 13 pull requests were merged for this release. + +* `#22368 `__: BUG: Add ``__array_api_version__`` to ``numpy.array_api`` namespace +* `#22370 `__: MAINT: update sde toolkit to 9.0, fix download link +* `#22382 `__: BLD: use macos-11 image on azure, macos-1015 is deprecated +* `#22383 `__: MAINT: random: remove ``get_info`` from "extending with Cython"... +* `#22384 `__: BUG: Fix complex vector dot with more than NPY_CBLAS_CHUNK elements +* `#22387 `__: REV: Loosen ``lookfor``'s import try/except again +* `#22388 `__: TYP,ENH: Mark ``numpy.typing`` protocols as runtime checkable +* `#22389 `__: TYP,MAINT: Change more overloads to play nice with pyright +* `#22390 `__: TST,TYP: Bump mypy to 0.981 +* `#22391 `__: DOC: Update delimiter param description. +* `#22392 `__: BUG: Memory leaks in numpy.nested_iters +* `#22413 `__: REL: Prepare for the NumPy 1.23.4 release. +* `#22424 `__: TST: Fix failing aarch64 wheel builds. + diff --git a/doc/source/release/1.23.5-notes.rst b/doc/source/release/1.23.5-notes.rst new file mode 100644 index 000000000000..8e14794e4c18 --- /dev/null +++ b/doc/source/release/1.23.5-notes.rst @@ -0,0 +1,39 @@ +.. currentmodule:: numpy + +========================== +NumPy 1.23.5 Release Notes +========================== +NumPy 1.23.5 is a maintenance release that fixes bugs discovered after the +1.23.4 release and keeps the build infrastructure current. +The Python versions supported for this release are 3.8-3.11. + +Contributors +============ + +A total of 7 people contributed to this release. People with a "+" by their +names contributed a patch for the first time. + +* @DWesl +* Aayush Agrawal + +* Adam Knapp + +* Charles Harris +* Navpreet Singh + +* Sebastian Berg +* Tania Allard + +Pull requests merged +==================== + +A total of 10 pull requests were merged for this release. + +* `#22489 `__: TST, MAINT: Replace most setup with setup_method (also teardown) +* `#22490 `__: MAINT, CI: Switch to cygwin/cygwin-install-action@v2 +* `#22494 `__: TST: Make test_partial_iteration_cleanup robust but require leak... +* `#22592 `__: MAINT: Ensure graceful handling of large header sizes +* `#22593 `__: TYP: Spelling alignment for array flag literal +* `#22594 `__: BUG: Fix bounds checking for ``random.logseries`` +* `#22595 `__: DEV: Update GH actions and Dockerfile for Gitpod +* `#22596 `__: CI: Only fetch in actions/checkout +* `#22597 `__: BUG: Decrement ref count in gentype_reduce if allocated memory... +* `#22625 `__: BUG: Histogramdd breaks on big arrays in Windows + diff --git a/doc/source/release/1.24.0-notes.rst b/doc/source/release/1.24.0-notes.rst new file mode 100644 index 000000000000..bcccd8c57f27 --- /dev/null +++ b/doc/source/release/1.24.0-notes.rst @@ -0,0 +1,515 @@ +.. currentmodule:: numpy + +======================== +NumPy 1.24 Release Notes +======================== +The NumPy 1.24.0 release continues the ongoing work to improve the handling and +promotion of dtypes, increase the execution speed, and clarify the +documentation. There are also a large number of new and expired deprecations +due to changes in promotion and cleanups. This might be called a deprecation +release. Highlights are + +* Many new deprecations, check them out. +* Many expired deprecations, +* New F2PY features and fixes. +* New "dtype" and "casting" keywords for stacking functions. + +See below for the details, + +This release supports Python versions 3.8-3.11. + + +Deprecations +============ + +Deprecate fastCopyAndTranspose and PyArray_CopyAndTranspose +----------------------------------------------------------- +The ``numpy.fastCopyAndTranspose`` function has been deprecated. Use the +corresponding copy and transpose methods directly:: + + arr.T.copy() + +The underlying C function ``PyArray_CopyAndTranspose`` has also been deprecated +from the NumPy C-API. + +(`gh-22313 `__) + +Conversion of out-of-bound Python integers +------------------------------------------ +Attempting a conversion from a Python integer to a NumPy value will now always +check whether the result can be represented by NumPy. This means the following +examples will fail in the future and give a ``DeprecationWarning`` now:: + + np.uint8(-1) + np.array([3000], dtype=np.int8) + +Many of these did succeed before. Such code was mainly useful for unsigned +integers with negative values such as ``np.uint8(-1)`` giving +``np.iinfo(np.uint8).max``. + +Note that conversion between NumPy integers is unaffected, so that +``np.array(-1).astype(np.uint8)`` continues to work and use C integer overflow +logic. For negative values, it will also work to view the array: +``np.array(-1, dtype=np.int8).view(np.uint8)``. +In some cases, using ``np.iinfo(np.uint8).max`` or ``val % 2**8`` may also +work well. + +In rare cases input data may mix both negative values and very large unsigned +values (i.e. ``-1`` and ``2**63``). There it is unfortunately necessary +to use ``%`` on the Python value or use signed or unsigned conversion +depending on whether negative values are expected. + +(`gh-22385 `__) + +Deprecate ``msort`` +------------------- +The ``numpy.msort`` function is deprecated. Use ``np.sort(a, axis=0)`` instead. + +(`gh-22456 `__) + +``np.str0`` and similar are now deprecated +------------------------------------------ +The scalar type aliases ending in a 0 bit size: ``np.object0``, ``np.str0``, +``np.bytes0``, ``np.void0``, ``np.int0``, ``np.uint0`` as well as ``np.bool8`` +are now deprecated and will eventually be removed. + +(`gh-22607 `__) + + +Expired deprecations +==================== + +* The ``normed`` keyword argument has been removed from + `np.histogram`, `np.histogram2d`, and `np.histogramdd`. + Use ``density`` instead. If ``normed`` was passed by + position, ``density`` is now used. + + (`gh-21645 `__) + +* Ragged array creation will now always raise a ``ValueError`` unless + ``dtype=object`` is passed. This includes very deeply nested sequences. + + (`gh-22004 `__) + +* Support for Visual Studio 2015 and earlier has been removed. + +* Support for the Windows Interix POSIX interop layer has been removed. + + (`gh-22139 `__) + +* Support for Cygwin < 3.3 has been removed. + + (`gh-22159 `__) + +* The mini() method of ``np.ma.MaskedArray`` has been removed. Use either + ``np.ma.MaskedArray.min()`` or ``np.ma.minimum.reduce()``. + +* The single-argument form of ``np.ma.minimum`` and ``np.ma.maximum`` has been + removed. Use ``np.ma.minimum.reduce()`` or ``np.ma.maximum.reduce()`` + instead. + + (`gh-22228 `__) + +* Passing dtype instances other than the canonical (mainly native byte-order) + ones to ``dtype=`` or ``signature=`` in ufuncs will now raise a + ``TypeError``. We recommend passing the strings ``"int8"`` or scalar types + ``np.int8`` since the byte-order, datetime/timedelta unit, etc. are never + enforced. (Initially deprecated in NumPy 1.21.) + + (`gh-22540 `__) + +* The ``dtype=`` argument to comparison ufuncs is now applied correctly. That + means that only ``bool`` and ``object`` are valid values and ``dtype=object`` + is enforced. + + (`gh-22541 `__) + +* The deprecation for the aliases ``np.object``, ``np.bool``, ``np.float``, + ``np.complex``, ``np.str``, and ``np.int`` is expired (introduces NumPy + 1.20). Some of these will now give a FutureWarning in addition to raising an + error since they will be mapped to the NumPy scalars in the future. + + (`gh-22607 `__) + + +Compatibility notes +=================== + +``array.fill(scalar)`` may behave slightly different +---------------------------------------------------- +``numpy.ndarray.fill`` may in some cases behave slightly different now due to +the fact that the logic is aligned with item assignment:: + + arr = np.array([1]) # with any dtype/value + arr.fill(scalar) + # is now identical to: + arr[0] = scalar + +Previously casting may have produced slightly different answers when using +values that could not be represented in the target ``dtype`` or when the target +had ``object`` dtype. + +(`gh-20924 `__) + +Subarray to object cast now copies +---------------------------------- +Casting a dtype that includes a subarray to an object will now ensure a copy of +the subarray. Previously an unsafe view was returned:: + + arr = np.ones(3, dtype=[("f", "i", 3)]) + subarray_fields = arr.astype(object)[0] + subarray = subarray_fields[0] # "f" field + + np.may_share_memory(subarray, arr) + +Is now always false. While previously it was true for the specific cast. + +(`gh-21925 `__) + +Returned arrays respect uniqueness of dtype kwarg objects +--------------------------------------------------------- +When the ``dtype`` keyword argument is used with :py:func:`np.array()` or +:py:func:`asarray()`, the dtype of the returned array now always exactly +matches the dtype provided by the caller. + +In some cases this change means that a *view* rather than the input array is +returned. The following is an example for this on 64bit Linux where ``long`` +and ``longlong`` are the same precision but different ``dtypes``:: + + >>> arr = np.array([1, 2, 3], dtype="long") + >>> new_dtype = np.dtype("longlong") + >>> new = np.asarray(arr, dtype=new_dtype) + >>> new.dtype is new_dtype + True + >>> new is arr + False + +Before the change, the ``dtype`` did not match because ``new is arr`` was +``True``. + +(`gh-21995 `__) + +DLPack export raises ``BufferError`` +------------------------------------ +When an array buffer cannot be exported via DLPack a ``BufferError`` is now +always raised where previously ``TypeError`` or ``RuntimeError`` was raised. +This allows falling back to the buffer protocol or ``__array_interface__`` when +DLPack was tried first. + +(`gh-22542 `__) + +NumPy builds are no longer tested on GCC-6 +------------------------------------------ +Ubuntu 18.04 is deprecated for GitHub actions and GCC-6 is not available on +Ubuntu 20.04, so builds using that compiler are no longer tested. We still test +builds using GCC-7 and GCC-8. + +(`gh-22598 `__) + + +New Features +============ + +New attribute ``symbol`` added to polynomial classes +---------------------------------------------------- +The polynomial classes in the ``numpy.polynomial`` package have a new +``symbol`` attribute which is used to represent the indeterminate of the +polynomial. This can be used to change the value of the variable when +printing:: + + >>> P_y = np.polynomial.Polynomial([1, 0, -1], symbol="y") + >>> print(P_y) + 1.0 + 0.0·y¹ - 1.0·y² + +Note that the polynomial classes only support 1D polynomials, so operations +that involve polynomials with different symbols are disallowed when the result +would be multivariate:: + + >>> P = np.polynomial.Polynomial([1, -1]) # default symbol is "x" + >>> P_z = np.polynomial.Polynomial([1, 1], symbol="z") + >>> P * P_z + Traceback (most recent call last) + ... + ValueError: Polynomial symbols differ + +The symbol can be any valid Python identifier. The default is ``symbol=x``, +consistent with existing behavior. + +(`gh-16154 `__) + +F2PY support for Fortran ``character`` strings +---------------------------------------------- +F2PY now supports wrapping Fortran functions with: + +* character (e.g. ``character x``) +* character array (e.g. ``character, dimension(n) :: x``) +* character string (e.g. ``character(len=10) x``) +* and character string array (e.g. ``character(len=10), dimension(n, m) :: x``) + +arguments, including passing Python unicode strings as Fortran character string +arguments. + +(`gh-19388 `__) + +New function ``np.show_runtime`` +-------------------------------- +A new function ``numpy.show_runtime`` has been added to display the runtime +information of the machine in addition to ``numpy.show_config`` which displays +the build-related information. + +(`gh-21468 `__) + +``strict`` option for ``testing.assert_array_equal`` +---------------------------------------------------- +The ``strict`` option is now available for ``testing.assert_array_equal``. +Setting ``strict=True`` will disable the broadcasting behaviour for scalars and +ensure that input arrays have the same data type. + +(`gh-21595 `__) + +New parameter ``equal_nan`` added to ``np.unique`` +-------------------------------------------------- +``np.unique`` was changed in 1.21 to treat all ``NaN`` values as equal and +return a single ``NaN``. Setting ``equal_nan=False`` will restore pre-1.21 +behavior to treat ``NaNs`` as unique. Defaults to ``True``. + +(`gh-21623 `__) + +``casting`` and ``dtype`` keyword arguments for ``numpy.stack`` +--------------------------------------------------------------- +The ``casting`` and ``dtype`` keyword arguments are now available for +``numpy.stack``. To use them, write ``np.stack(..., dtype=None, +casting='same_kind')``. + +``casting`` and ``dtype`` keyword arguments for ``numpy.vstack`` +---------------------------------------------------------------- +The ``casting`` and ``dtype`` keyword arguments are now available for +``numpy.vstack``. To use them, write ``np.vstack(..., dtype=None, +casting='same_kind')``. + +``casting`` and ``dtype`` keyword arguments for ``numpy.hstack`` +---------------------------------------------------------------- +The ``casting`` and ``dtype`` keyword arguments are now available for +``numpy.hstack``. To use them, write ``np.hstack(..., dtype=None, +casting='same_kind')``. + +(`gh-21627 `__) + +The bit generator underlying the singleton RandomState can be changed +--------------------------------------------------------------------- +The singleton ``RandomState`` instance exposed in the ``numpy.random`` module +is initialized at startup with the ``MT19937`` bit generator. The new function +``set_bit_generator`` allows the default bit generator to be replaced with a +user-provided bit generator. This function has been introduced to provide a +method allowing seamless integration of a high-quality, modern bit generator in +new code with existing code that makes use of the singleton-provided random +variate generating functions. The companion function ``get_bit_generator`` +returns the current bit generator being used by the singleton ``RandomState``. +This is provided to simplify restoring the original source of randomness if +required. + +The preferred method to generate reproducible random numbers is to use a modern +bit generator in an instance of ``Generator``. The function ``default_rng`` +simplifies instantiation:: + + >>> rg = np.random.default_rng(3728973198) + >>> rg.random() + +The same bit generator can then be shared with the singleton instance so that +calling functions in the ``random`` module will use the same bit generator:: + + >>> orig_bit_gen = np.random.get_bit_generator() + >>> np.random.set_bit_generator(rg.bit_generator) + >>> np.random.normal() + +The swap is permanent (until reversed) and so any call to functions in the +``random`` module will use the new bit generator. The original can be restored +if required for code to run correctly:: + + >>> np.random.set_bit_generator(orig_bit_gen) + +(`gh-21976 `__) + +``np.void`` now has a ``dtype`` argument +---------------------------------------- +NumPy now allows constructing structured void scalars directly by +passing the ``dtype`` argument to ``np.void``. + +(`gh-22316 `__) + + +Improvements +============ + +F2PY Improvements +----------------- +* The generated extension modules don't use the deprecated NumPy-C API anymore +* Improved ``f2py`` generated exception messages +* Numerous bug and ``flake8`` warning fixes +* various CPP macros that one can use within C-expressions of signature files + are prefixed with ``f2py_``. For example, one should use ``f2py_len(x)`` + instead of ``len(x)`` +* A new construct ``character(f2py_len=...)`` is introduced to support + returning assumed length character strings (e.g. ``character(len=*)``) from + wrapper functions + +A hook to support rewriting ``f2py`` internal data structures after reading all +its input files is introduced. This is required, for instance, for BC of SciPy +support where character arguments are treated as character strings arguments in +``C`` expressions. + +(`gh-19388 `__) + +IBM zSystems Vector Extension Facility (SIMD) +--------------------------------------------- +Added support for SIMD extensions of zSystem (z13, z14, z15), through the +universal intrinsics interface. This support leads to performance improvements +for all SIMD kernels implemented using the universal intrinsics, including the +following operations: rint, floor, trunc, ceil, sqrt, absolute, square, +reciprocal, tanh, sin, cos, equal, not_equal, greater, greater_equal, less, +less_equal, maximum, minimum, fmax, fmin, argmax, argmin, add, subtract, +multiply, divide. + +(`gh-20913 `__) + +NumPy now gives floating point errors in casts +---------------------------------------------- +In most cases, NumPy previously did not give floating point warnings or errors +when these happened during casts. For examples, casts like:: + + np.array([2e300]).astype(np.float32) # overflow for float32 + np.array([np.inf]).astype(np.int64) + +Should now generally give floating point warnings. These warnings should warn +that floating point overflow occurred. For errors when converting floating +point values to integers users should expect invalid value warnings. + +Users can modify the behavior of these warnings using ``np.errstate``. + +Note that for float to int casts, the exact warnings that are given may +be platform dependent. For example:: + + arr = np.full(100, value=1000, dtype=np.float64) + arr.astype(np.int8) + +May give a result equivalent to (the intermediate cast means no warning is +given):: + + arr.astype(np.int64).astype(np.int8) + +May return an undefined result, with a warning set:: + + RuntimeWarning: invalid value encountered in cast + +The precise behavior is subject to the C99 standard and its implementation in +both software and hardware. + +(`gh-21437 `__) + +F2PY supports the value attribute +--------------------------------- +The Fortran standard requires that variables declared with the ``value`` +attribute must be passed by value instead of reference. F2PY now supports this +use pattern correctly. So ``integer, intent(in), value :: x`` in Fortran codes +will have correct wrappers generated. + +(`gh-21807 `__) + +Added pickle support for third-party BitGenerators +-------------------------------------------------- +The pickle format for bit generators was extended to allow each bit generator +to supply its own constructor when during pickling. Previous versions of NumPy +only supported unpickling ``Generator`` instances created with one of the core +set of bit generators supplied with NumPy. Attempting to unpickle a +``Generator`` that used a third-party bit generators would fail since the +constructor used during the unpickling was only aware of the bit generators +included in NumPy. + +(`gh-22014 `__) + +arange() now explicitly fails with dtype=str +--------------------------------------------- +Previously, the ``np.arange(n, dtype=str)`` function worked for ``n=1`` and +``n=2``, but would raise a non-specific exception message for other values of +``n``. Now, it raises a `TypeError` informing that ``arange`` does not support +string dtypes:: + + >>> np.arange(2, dtype=str) + Traceback (most recent call last) + ... + TypeError: arange() not supported for inputs with DType . + +(`gh-22055 `__) + +``numpy.typing`` protocols are now runtime checkable +---------------------------------------------------- +The protocols used in ``numpy.typing.ArrayLike`` and ``numpy.typing.DTypeLike`` +are now properly marked as runtime checkable, making them easier to use for +runtime type checkers. + +(`gh-22357 `__) + + +Performance improvements and changes +==================================== + +Faster version of ``np.isin`` and ``np.in1d`` for integer arrays +---------------------------------------------------------------- +``np.in1d`` (used by ``np.isin``) can now switch to a faster algorithm (up to +>10x faster) when it is passed two integer arrays. This is often automatically +used, but you can use ``kind="sort"`` or ``kind="table"`` to force the old or +new method, respectively. + +(`gh-12065 `__) + +Faster comparison operators +---------------------------- +The comparison functions (``numpy.equal``, ``numpy.not_equal``, ``numpy.less``, +``numpy.less_equal``, ``numpy.greater`` and ``numpy.greater_equal``) are now +much faster as they are now vectorized with universal intrinsics. For a CPU +with SIMD extension AVX512BW, the performance gain is up to 2.57x, 1.65x and +19.15x for integer, float and boolean data types, respectively (with N=50000). + +(`gh-21483 `__) + + +Changes +======= + +Better reporting of integer division overflow +--------------------------------------------- +Integer division overflow of scalars and arrays used to provide a +``RuntimeWarning`` and the return value was undefined leading to crashes at +rare occasions:: + + >>> np.array([np.iinfo(np.int32).min]*10, dtype=np.int32) // np.int32(-1) + :1: RuntimeWarning: divide by zero encountered in floor_divide + array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0], dtype=int32) + +Integer division overflow now returns the input dtype's minimum value and raise +the following ``RuntimeWarning``:: + + >>> np.array([np.iinfo(np.int32).min]*10, dtype=np.int32) // np.int32(-1) + :1: RuntimeWarning: overflow encountered in floor_divide + array([-2147483648, -2147483648, -2147483648, -2147483648, -2147483648, + -2147483648, -2147483648, -2147483648, -2147483648, -2147483648], + dtype=int32) + +(`gh-21506 `__) + +``masked_invalid`` now modifies the mask in-place +------------------------------------------------- +When used with ``copy=False``, ``numpy.ma.masked_invalid`` now modifies the +input masked array in-place. This makes it behave identically to +``masked_where`` and better matches the documentation. + +(`gh-22046 `__) + +``nditer``/``NpyIter`` allows all allocating all operands +--------------------------------------------------------- +The NumPy iterator available through ``np.nditer`` in Python and as ``NpyIter`` +in C now supports allocating all arrays. The iterator shape defaults to ``()`` +in this case. The operands dtype must be provided, since a "common dtype" +cannot be inferred from the other inputs. + +(`gh-22457 `__) diff --git a/doc/source/release/1.24.1-notes.rst b/doc/source/release/1.24.1-notes.rst new file mode 100644 index 000000000000..c346f6d20493 --- /dev/null +++ b/doc/source/release/1.24.1-notes.rst @@ -0,0 +1,50 @@ +.. currentmodule:: numpy + +========================== +NumPy 1.24.1 Release Notes +========================== +NumPy 1.24.1 is a maintenance release that fixes bugs and regressions discovered after the +1.24.0 release. The Python versions supported by this release are 3.8-3.11. + +Contributors +============ + +A total of 12 people contributed to this release. People with a "+" by their +names contributed a patch for the first time. + +* Andrew Nelson +* Ben Greiner + +* Charles Harris +* Clément Robert +* Matteo Raso +* Matti Picus +* Melissa Weber Mendonça +* Miles Cranmer +* Ralf Gommers +* Rohit Goswami +* Sayed Adel +* Sebastian Berg + +Pull requests merged +==================== + +A total of 18 pull requests were merged for this release. + +* `#22820 `__: BLD: add workaround in setup.py for newer setuptools +* `#22830 `__: BLD: CIRRUS_TAG redux +* `#22831 `__: DOC: fix a couple typos in 1.23 notes +* `#22832 `__: BUG: Fix refcounting errors found using pytest-leaks +* `#22834 `__: BUG, SIMD: Fix invalid value encountered in several ufuncs +* `#22837 `__: TST: ignore more np.distutils.log imports +* `#22839 `__: BUG: Do not use getdata() in np.ma.masked_invalid +* `#22847 `__: BUG: Ensure correct behavior for rows ending in delimiter in... +* `#22848 `__: BUG, SIMD: Fix the bitmask of the boolean comparison +* `#22857 `__: BLD: Help raspian arm + clang 13 about __builtin_mul_overflow +* `#22858 `__: API: Ensure a full mask is returned for masked_invalid +* `#22866 `__: BUG: Polynomials now copy properly (#22669) +* `#22867 `__: BUG, SIMD: Fix memory overlap in ufunc comparison loops +* `#22868 `__: BUG: Fortify string casts against floating point warnings +* `#22875 `__: TST: Ignore nan-warnings in randomized out tests +* `#22883 `__: MAINT: restore npymath implementations needed for freebsd +* `#22884 `__: BUG: Fix integer overflow in in1d for mixed integer dtypes #22877 +* `#22887 `__: BUG: Use whole file for encoding checks with ``charset_normalizer``. diff --git a/doc/source/release/1.24.2-notes.rst b/doc/source/release/1.24.2-notes.rst new file mode 100644 index 000000000000..9e9412244dd6 --- /dev/null +++ b/doc/source/release/1.24.2-notes.rst @@ -0,0 +1,51 @@ +.. currentmodule:: numpy + +========================== +NumPy 1.24.2 Release Notes +========================== +NumPy 1.24.2 is a maintenance release that fixes bugs and regressions discovered after the +1.24.1 release. The Python versions supported by this release are 3.8-3.11. + +Contributors +============ + +A total of 14 people contributed to this release. People with a "+" by their +names contributed a patch for the first time. + +* Bas van Beek +* Charles Harris +* Khem Raj + +* Mark Harfouche +* Matti Picus +* Panagiotis Zestanakis + +* Peter Hawkins +* Pradipta Ghosh +* Ross Barnowski +* Sayed Adel +* Sebastian Berg +* Syam Gadde + +* dmbelov + +* pkubaj + + +Pull requests merged +==================== + +A total of 17 pull requests were merged for this release. + +* `#22965 `__: MAINT: Update python 3.11-dev to 3.11. +* `#22966 `__: DOC: Remove dangling deprecation warning +* `#22967 `__: ENH: Detect CPU features on FreeBSD/powerpc64* +* `#22968 `__: BUG: np.loadtxt cannot load text file with quoted fields separated... +* `#22969 `__: TST: Add fixture to avoid issue with randomizing test order. +* `#22970 `__: BUG: Fix fill violating read-only flag. (#22959) +* `#22971 `__: MAINT: Add additional information to missing scalar AttributeError +* `#22972 `__: MAINT: Move export for scipy arm64 helper into main module +* `#22976 `__: BUG, SIMD: Fix spurious invalid exception for sin/cos on arm64/clang +* `#22989 `__: BUG: Ensure correct loop order in sin, cos, and arctan2 +* `#23030 `__: DOC: Add version added information for the strict parameter in... +* `#23031 `__: BUG: use ``_Alignof`` rather than ``offsetof()`` on most compilers +* `#23147 `__: BUG: Fix for npyv__trunc_s32_f32 (VXE) +* `#23148 `__: BUG: Fix integer / float scalar promotion +* `#23149 `__: BUG: Add missing header. +* `#23150 `__: TYP, MAINT: Add a missing explicit ``Any`` parameter to the ``npt.ArrayLike``... +* `#23161 `__: BLD: remove redundant definition of npy_nextafter [wheel build] diff --git a/doc/source/release/1.24.3-notes.rst b/doc/source/release/1.24.3-notes.rst new file mode 100644 index 000000000000..289b5d98095a --- /dev/null +++ b/doc/source/release/1.24.3-notes.rst @@ -0,0 +1,49 @@ +.. currentmodule:: numpy + +========================== +NumPy 1.24.3 Release Notes +========================== +NumPy 1.24.3 is a maintenance release that fixes bugs and regressions discovered after the +1.24.2 release. The Python versions supported by this release are 3.8-3.11. + +Contributors +============ + +A total of 12 people contributed to this release. People with a "+" by their +names contributed a patch for the first time. + +* Aleksei Nikiforov + +* Alexander Heger +* Bas van Beek +* Bob Eldering +* Brock Mendel +* Charles Harris +* Kyle Sunden +* Peter Hawkins +* Rohit Goswami +* Sebastian Berg +* Warren Weckesser +* dependabot[bot] + +Pull requests merged +==================== + +A total of 17 pull requests were merged for this release. + +* `#23206 `__: BUG: fix for f2py string scalars (#23194) +* `#23207 `__: BUG: datetime64/timedelta64 comparisons return NotImplemented +* `#23208 `__: MAINT: Pin matplotlib to version 3.6.3 for refguide checks +* `#23221 `__: DOC: Fix matplotlib error in documentation +* `#23226 `__: CI: Ensure submodules are initialized in gitpod. +* `#23341 `__: TYP: Replace duplicate reduce in ufunc type signature with reduceat. +* `#23342 `__: TYP: Remove duplicate CLIP/WRAP/RAISE in __init__.pyi. +* `#23343 `__: TYP: Mark ``d`` argument to fftfreq and rfftfreq as optional... +* `#23344 `__: TYP: Add type annotations for comparison operators to MaskedArray. +* `#23345 `__: TYP: Remove some stray type-check-only imports of ``msort`` +* `#23370 `__: BUG: Ensure like is only stripped for `like=` dispatched functions +* `#23543 `__: BUG: fix loading and storing big arrays on s390x +* `#23544 `__: MAINT: Bump larsoner/circleci-artifacts-redirector-action +* `#23634 `__: BUG: Ignore invalid and overflow warnings in masked setitem +* `#23635 `__: BUG: Fix masked array raveling when `order="A"` or `order="K"` +* `#23636 `__: MAINT: Update conftest for newer hypothesis versions +* `#23637 `__: BUG: Fix bug in parsing F77 style string arrays. diff --git a/doc/source/release/1.4.0-notes.rst b/doc/source/release/1.4.0-notes.rst index 9480a054e10b..df7b72da6781 100644 --- a/doc/source/release/1.4.0-notes.rst +++ b/doc/source/release/1.4.0-notes.rst @@ -110,7 +110,7 @@ Testing #. deprecated decorator: this decorator may be used to avoid cluttering testing output while testing DeprecationWarning is effectively raised by the decorated test. - #. assert_array_almost_equal_nulps: new method to compare two arrays of + #. assert_array_almost_equal_nulp: new method to compare two arrays of floating point values. With this function, two values are considered close if there are not many representable floating point values in between, thus being more robust than assert_array_almost_equal when the diff --git a/doc/source/release/1.7.0-notes.rst b/doc/source/release/1.7.0-notes.rst index f111f80dc97a..a04255f3c50c 100644 --- a/doc/source/release/1.7.0-notes.rst +++ b/doc/source/release/1.7.0-notes.rst @@ -162,12 +162,12 @@ Added experimental support for the AArch64 architecture. C API ----- -New function ``PyArray_RequireWriteable`` provides a consistent interface +New function ``PyArray_FailUnlessWriteable`` provides a consistent interface for checking array writeability -- any C code which works with arrays whose WRITEABLE flag is not known to be True a priori, should make sure to call this function before writing. -NumPy C Style Guide added (``doc/C_STYLE_GUIDE.rst.txt``). +NumPy C Style Guide added (``doc/C_STYLE_GUIDE.rst``). Changes ======= diff --git a/doc/source/release/1.8.0-notes.rst b/doc/source/release/1.8.0-notes.rst index 65a471b92125..e7be2d14a99c 100644 --- a/doc/source/release/1.8.0-notes.rst +++ b/doc/source/release/1.8.0-notes.rst @@ -52,7 +52,7 @@ Compatibility notes The doc/sphinxext content has been moved into its own github repository, and is included in numpy as a submodule. See the instructions in -doc/HOWTO_BUILD_DOCS.rst.txt for how to access the content. +doc/HOWTO_BUILD_DOCS.rst for how to access the content. .. _numpydoc: https://github.com/numpy/numpydoc diff --git a/doc/source/user/absolute_beginners.rst b/doc/source/user/absolute_beginners.rst index 27e9e1f638c3..dae2c4f06d22 100644 --- a/doc/source/user/absolute_beginners.rst +++ b/doc/source/user/absolute_beginners.rst @@ -229,8 +229,8 @@ content is random and depends on the state of the memory. The reason to use fill every element afterwards! :: >>> # Create an empty array with 2 elements - >>> np.empty(2) - array([ 3.14, 42. ]) # may vary + >>> np.empty(2) #doctest: +SKIP + array([3.14, 42. ]) # may vary You can create an array with a range of elements:: @@ -669,18 +669,18 @@ If you wanted to split this array into three equally shaped arrays, you would run:: >>> np.hsplit(x, 3) - [array([[1, 2, 3, 4], - [13, 14, 15, 16]]), array([[ 5, 6, 7, 8], - [17, 18, 19, 20]]), array([[ 9, 10, 11, 12], - [21, 22, 23, 24]])] + [array([[ 1, 2, 3, 4], + [13, 14, 15, 16]]), array([[ 5, 6, 7, 8], + [17, 18, 19, 20]]), array([[ 9, 10, 11, 12], + [21, 22, 23, 24]])] If you wanted to split your array after the third and fourth column, you'd run:: >>> np.hsplit(x, (3, 4)) - [array([[1, 2, 3], - [13, 14, 15]]), array([[ 4], - [16]]), array([[ 5, 6, 7, 8, 9, 10, 11, 12], - [17, 18, 19, 20, 21, 22, 23, 24]])] + [array([[ 1, 2, 3], + [13, 14, 15]]), array([[ 4], + [16]]), array([[ 5, 6, 7, 8, 9, 10, 11, 12], + [17, 18, 19, 20, 21, 22, 23, 24]])] :ref:`Learn more about stacking and splitting arrays here `. @@ -967,9 +967,8 @@ All you need to do is pass in the number of elements you want it to generate:: array([1., 1., 1.]) >>> np.zeros(3) array([0., 0., 0.]) - # the simplest way to generate random numbers - >>> rng = np.random.default_rng(0) - >>> rng.random(3) + >>> rng = np.random.default_rng() # the simplest way to generate random numbers + >>> rng.random(3) #doctest: +SKIP array([0.63696169, 0.26978671, 0.04097352]) .. image:: images/np_ones_zeros_random.png @@ -985,7 +984,7 @@ a 2D array if you give them a tuple describing the dimensions of the matrix:: array([[0., 0.], [0., 0.], [0., 0.]]) - >>> rng.random((3, 2)) + >>> rng.random((3, 2)) #doctest: +SKIP array([[0.01652764, 0.81327024], [0.91275558, 0.60663578], [0.72949656, 0.54362499]]) # may vary @@ -1011,7 +1010,7 @@ that this is inclusive with NumPy) to high (exclusive). You can set You can generate a 2 x 4 array of random integers between 0 and 4 with:: - >>> rng.integers(5, size=(2, 4)) + >>> rng.integers(5, size=(2, 4)) #doctest: +SKIP array([[2, 1, 1, 0], [0, 0, 0, 4]]) # may vary @@ -1345,7 +1344,7 @@ followed by the docstring of ``ndarray`` of which ``a`` is an instance): Type: ndarray String form: [1 2 3 4 5 6] Length: 6 - File: ~/anaconda3/lib/python3.7/site-packages/numpy/__init__.py + File: ~/anaconda3/lib/python3.9/site-packages/numpy/__init__.py Docstring: Class docstring: ndarray(shape, dtype=float, buffer=None, offset=0, @@ -1505,7 +1504,7 @@ You can use ``np.load()`` to reconstruct your array. :: >>> b = np.load('filename.npy') -If you want to check your array, you can run::: +If you want to check your array, you can run:: >>> print(b) [1 2 3 4 5 6] @@ -1589,7 +1588,7 @@ If you created this array "a" :: .. for doctests The continuous integration truncates dataframe display without this setting. - >>> pd.set_option('max_columns', 10) + >>> pd.set_option('display.max_columns', 10) You could create a Pandas dataframe :: diff --git a/doc/source/user/basics.broadcasting.rst b/doc/source/user/basics.broadcasting.rst index ca299085aeed..1686b335ffe2 100644 --- a/doc/source/user/basics.broadcasting.rst +++ b/doc/source/user/basics.broadcasting.rst @@ -6,7 +6,7 @@ Broadcasting ************ .. seealso:: - :class:`numpy.broadcast` + :class:`numpy.broadcast` The term broadcasting describes how NumPy treats arrays with different @@ -26,7 +26,7 @@ have exactly the same shape, as in the following example: >>> a = np.array([1.0, 2.0, 3.0]) >>> b = np.array([2.0, 2.0, 2.0]) >>> a * b - array([ 2., 4., 6.]) + array([2., 4., 6.]) NumPy's broadcasting rule relaxes this constraint when the arrays' shapes meet certain constraints. The simplest broadcasting example occurs @@ -35,7 +35,7 @@ when an array and a scalar value are combined in an operation: >>> a = np.array([1.0, 2.0, 3.0]) >>> b = 2.0 >>> a * b -array([ 2., 4., 6.]) +array([2., 4., 6.]) The result is equivalent to the previous example where ``b`` was an array. We can think of the scalar ``b`` being *stretched* during the arithmetic @@ -46,7 +46,7 @@ only conceptual. NumPy is smart enough to use the original scalar value without actually making copies so that broadcasting operations are as memory and computationally efficient as possible. -.. figure:: broadcasting_1.svg +.. figure:: broadcasting_1.png :alt: A scalar is broadcast to match the shape of the 1-d array it is being multiplied to. :name: broadcasting.figure-1 @@ -66,21 +66,25 @@ because broadcasting moves less memory around during the multiplication General Broadcasting Rules ========================== When operating on two arrays, NumPy compares their shapes element-wise. -It starts with the trailing (i.e. rightmost) dimensions and works its +It starts with the trailing (i.e. rightmost) dimension and works its way left. Two dimensions are compatible when 1) they are equal, or -2) one of them is 1 +2) one of them is 1. If these conditions are not met, a -``ValueError: operands could not be broadcast together`` exception is -thrown, indicating that the arrays have incompatible shapes. The size of -the resulting array is the size that is not 1 along each axis of the inputs. - -Arrays do not need to have the same *number* of dimensions. For example, -if you have a ``256x256x3`` array of RGB values, and you want to scale -each color in the image by a different value, you can multiply the image -by a one-dimensional array with 3 values. Lining up the sizes of the +``ValueError: operands could not be broadcast together`` exception is +thrown, indicating that the arrays have incompatible shapes. + +Input arrays do not need to have the same *number* of dimensions. The +resulting array will have the same number of dimensions as the input array +with the greatest number of dimensions, where the *size* of each dimension is +the largest size of the corresponding dimension among the input arrays. Note +that missing dimensions are assumed to have size one. + +For example, if you have a ``256x256x3`` array of RGB values, and you want +to scale each color in the image by a different value, you can multiply the +image by a one-dimensional array with 3 values. Lining up the sizes of the trailing axes of these arrays according to the broadcast rules, shows that they are compatible:: @@ -158,18 +162,18 @@ Here are examples of shapes that do not broadcast:: An example of broadcasting when a 1-d array is added to a 2-d array:: - >>> a = array([[ 0.0, 0.0, 0.0], - ... [10.0, 10.0, 10.0], - ... [20.0, 20.0, 20.0], - ... [30.0, 30.0, 30.0]]) - >>> b = array([1.0, 2.0, 3.0]) + >>> a = np.array([[ 0.0, 0.0, 0.0], + ... [10.0, 10.0, 10.0], + ... [20.0, 20.0, 20.0], + ... [30.0, 30.0, 30.0]]) + >>> b = np.array([1.0, 2.0, 3.0]) >>> a + b array([[ 1., 2., 3.], - [ 11., 12., 13.], - [ 21., 22., 23.], - [ 31., 32., 33.]]) - >>> b = array([1.0, 2.0, 3.0, 4.0]) - >>> a + b + [11., 12., 13.], + [21., 22., 23.], + [31., 32., 33.]]) + >>> b = np.array([1.0, 2.0, 3.0, 4.0]) + >>> a + b Traceback (most recent call last): ValueError: operands could not be broadcast together with shapes (4,3) (4,) @@ -177,8 +181,8 @@ As shown in :ref:`broadcasting.figure-2`, ``b`` is added to each row of ``a``. In :ref:`broadcasting.figure-3`, an exception is raised because of the incompatible shapes. -.. figure:: broadcasting_2.svg - :alt: A 1-d array with shape (3) is strectched to match the 2-d array of +.. figure:: broadcasting_2.png + :alt: A 1-d array with shape (3) is stretched to match the 2-d array of shape (4, 3) it is being added to, and the result is a 2-d array of shape (4, 3). :name: broadcasting.figure-2 @@ -189,7 +193,7 @@ incompatible shapes. broadcasting if number of 1-d array elements matches the number of 2-d array columns.* -.. figure:: broadcasting_3.svg +.. figure:: broadcasting_3.png :alt: A huge cross over the 2-d array of shape (4, 3) and the 1-d array of shape (4) shows that they can not be broadcast due to mismatch of shapes and thus produce no result. @@ -208,12 +212,12 @@ outer addition operation of two 1-d arrays:: >>> a = np.array([0.0, 10.0, 20.0, 30.0]) >>> b = np.array([1.0, 2.0, 3.0]) >>> a[:, np.newaxis] + b - array([[ 1., 2., 3.], - [ 11., 12., 13.], - [ 21., 22., 23.], - [ 31., 32., 33.]]) + array([[ 1., 2., 3.], + [11., 12., 13.], + [21., 22., 23.], + [31., 32., 33.]]) -.. figure:: broadcasting_4.svg +.. figure:: broadcasting_4.png :alt: A 2-d array of shape (4, 1) and a 1-d array of shape (3) are stretched to match their shapes and produce a resultant array of shape (4, 3). @@ -261,12 +265,12 @@ the shape of the ``codes`` array:: Codes (2d array): 4 x 2 Diff (2d array): 4 x 2 -.. figure:: broadcasting_5.svg +.. figure:: broadcasting_5.png :alt: A height versus weight graph that shows data of a female gymnast, marathon runner, basketball player, football lineman and the athlete to be classified. Shortest distance is found between the basketball player and the athlete - to be classified. + to be classified. :name: broadcasting.figure-5 *Figure 5* @@ -280,8 +284,8 @@ Typically, a large number of ``observations``, perhaps read from a database, are compared to a set of ``codes``. Consider this scenario:: Observation (2d array): 10 x 3 - Codes (2d array): 5 x 3 - Diff (3d array): 5 x 10 x 3 + Codes (3d array): 5 x 1 x 3 + Diff (3d array): 5 x 10 x 3 The three-dimensional array, ``diff``, is a consequence of broadcasting, not a necessity for the calculation. Large data sets will generate a large diff --git a/doc/source/user/basics.copies.rst b/doc/source/user/basics.copies.rst index 583a59b9563a..482cbc189ec8 100644 --- a/doc/source/user/basics.copies.rst +++ b/doc/source/user/basics.copies.rst @@ -39,6 +39,8 @@ do not reflect on the original array. Making a copy is slower and memory-consuming but sometimes necessary. A copy can be forced by using :meth:`.ndarray.copy`. +.. _indexing-operations: + Indexing operations =================== @@ -149,4 +151,4 @@ the original array while it returns ``None`` for a copy. Note that the ``base`` attribute should not be used to determine if an ndarray object is *new*; only if it is a view or a copy -of another ndarray. \ No newline at end of file +of another ndarray. diff --git a/doc/source/user/basics.creation.rst b/doc/source/user/basics.creation.rst index 84ff1c30e1f0..a97d69d8b6a3 100644 --- a/doc/source/user/basics.creation.rst +++ b/doc/source/user/basics.creation.rst @@ -74,13 +74,15 @@ assign a new type that satisfies all of the array elements involved in the computation, here ``uint32`` and ``int32`` can both be represented in as ``int64``. -The default NumPy behavior is to create arrays in either 64-bit signed -integers or double precision floating point numbers, ``int64`` and -``float``, respectively. If you expect your arrays to be a certain type, -then you need to specify the ``dtype`` while you create the array. +The default NumPy behavior is to create arrays in either 32 or 64-bit signed +integers (platform dependent and matches C int size) or double precision +floating point numbers, int32/int64 and float, respectively. If you expect your +integer arrays to be a specific type, then you need to specify the dtype while +you create the array. 2) Intrinsic NumPy array creation functions =========================================== + .. 40 functions seems like a small number, but the routies.array-creation has ~47. I'm sure there are more. @@ -108,9 +110,9 @@ examples are shown:: >>> np.arange(10) array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) >>> np.arange(2, 10, dtype=float) - array([ 2., 3., 4., 5., 6., 7., 8., 9.]) + array([2., 3., 4., 5., 6., 7., 8., 9.]) >>> np.arange(2, 3, 0.1) - array([ 2. , 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9]) + array([2. , 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9]) Note: best practice for :func:`numpy.arange` is to use integer start, end, and step values. There are some subtleties regarding ``dtype``. In the second @@ -123,7 +125,7 @@ spaced equally between the specified beginning and end values. For example: :: >>> np.linspace(1., 4., 6) - array([ 1. , 1.6, 2.2, 2.8, 3.4, 4. ]) + array([1. , 1.6, 2.2, 2.8, 3.4, 4. ]) The advantage of this creation function is that you guarantee the number of elements and the starting and end point. The previous @@ -216,8 +218,8 @@ specified shape. The default dtype is ``float64``:: ``zeros`` in all other respects as such:: >>> np.ones((2, 3)) - array([[ 1., 1., 1.], - [ 1., 1., 1.]]) + array([[1., 1., 1.], + [1., 1., 1.]]) >>> np.ones((2, 3, 2)) array([[[1., 1.], [1., 1.], @@ -299,10 +301,10 @@ arrays into a 4-by-4 array using ``block``:: >>> C = np.zeros((2, 2)) >>> D = np.diag((-3, -4)) >>> np.block([[A, B], [C, D]]) - array([[ 1., 1., 1., 0. ], - [ 1., 1., 0., 1. ], - [ 0., 0., -3., 0. ], - [ 0., 0., 0., -4. ]]) + array([[ 1., 1., 1., 0.], + [ 1., 1., 0., 1.], + [ 0., 0., -3., 0.], + [ 0., 0., 0., -4.]]) Other routines use similar syntax to join ndarrays. Check the routine's documentation for further examples and syntax. diff --git a/doc/source/user/basics.dispatch.rst b/doc/source/user/basics.dispatch.rst index 089a7df17063..0d0ddfcdbbc5 100644 --- a/doc/source/user/basics.dispatch.rst +++ b/doc/source/user/basics.dispatch.rst @@ -57,12 +57,12 @@ array([[2., 0., 0., 0., 0.], Notice that the return type is a standard ``numpy.ndarray``. >>> type(np.multiply(arr, 2)) -numpy.ndarray + How can we pass our custom array type through this function? Numpy allows a class to indicate that it would like to handle computations in a custom-defined way through the interfaces ``__array_ufunc__`` and ``__array_function__``. Let's -take one at a time, starting with ``_array_ufunc__``. This method covers +take one at a time, starting with ``__array_ufunc__``. This method covers :ref:`ufuncs`, a class of functions that includes, for example, :func:`numpy.multiply` and :func:`numpy.sin`. @@ -119,7 +119,9 @@ DiagonalArray(N=5, value=0.8414709848078965) At this point ``arr + 3`` does not work. >>> arr + 3 -TypeError: unsupported operand type(s) for *: 'DiagonalArray' and 'int' +Traceback (most recent call last): +... +TypeError: unsupported operand type(s) for +: 'DiagonalArray' and 'int' To support it, we need to define the Python interfaces ``__add__``, ``__lt__``, and so on to dispatch to the corresponding ufunc. We can achieve this @@ -193,14 +195,14 @@ functions to our custom variants. ... return self.__class__(N, ufunc(*scalars, **kwargs)) ... else: ... return NotImplemented -... def __array_function__(self, func, types, args, kwargs): -... if func not in HANDLED_FUNCTIONS: -... return NotImplemented -... # Note: this allows subclasses that don't override -... # __array_function__ to handle DiagonalArray objects. -... if not all(issubclass(t, self.__class__) for t in types): -... return NotImplemented -... return HANDLED_FUNCTIONS[func](*args, **kwargs) +... def __array_function__(self, func, types, args, kwargs): +... if func not in HANDLED_FUNCTIONS: +... return NotImplemented +... # Note: this allows subclasses that don't override +... # __array_function__ to handle DiagonalArray objects. +... if not all(issubclass(t, self.__class__) for t in types): +... return NotImplemented +... return HANDLED_FUNCTIONS[func](*args, **kwargs) ... A convenient pattern is to define a decorator ``implements`` that can be used @@ -241,14 +243,19 @@ this operation is not supported. For example, concatenating two supported. >>> np.concatenate([arr, arr]) +Traceback (most recent call last): +... TypeError: no implementation found for 'numpy.concatenate' on types that implement __array_function__: [] Additionally, our implementations of ``sum`` and ``mean`` do not accept the optional arguments that numpy's implementation does. >>> np.sum(arr, axis=0) +Traceback (most recent call last): +... TypeError: sum() got an unexpected keyword argument 'axis' + The user always has the option of converting to a normal ``numpy.ndarray`` with :func:`numpy.asarray` and using standard numpy from there. diff --git a/doc/source/user/basics.indexing.rst b/doc/source/user/basics.indexing.rst index 264c3d721f4f..b140e223a261 100644 --- a/doc/source/user/basics.indexing.rst +++ b/doc/source/user/basics.indexing.rst @@ -1,3 +1,6 @@ +.. for doctest: + >>> import numpy as np + .. _basics.indexing: **************************************** @@ -28,6 +31,7 @@ Note that in Python, ``x[(exp1, exp2, ..., expN)]`` is equivalent to ``x[exp1, exp2, ..., expN]``; the latter is just syntactic sugar for the former. +.. _basic-indexing: Basic indexing -------------- @@ -35,7 +39,7 @@ Basic indexing .. _single-element-indexing: Single element indexing -^^^^^^^^^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~~~~~~~~~ Single element indexing works exactly like that for other standard Python sequences. It is 0-based, @@ -88,9 +92,10 @@ that is subsequently indexed by 2. rapidly changing location in memory. This difference represents a great potential for confusion. +.. _slicing-and-striding: Slicing and striding -^^^^^^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~~~~~~ Basic slicing extends Python's basic concept of slicing to N dimensions. Basic slicing occurs when *obj* is a :class:`slice` object @@ -99,14 +104,6 @@ integer, or a tuple of slice objects and integers. :py:data:`Ellipsis` and :const:`newaxis` objects can be interspersed with these as well. -.. deprecated:: 1.15.0 - - In order to remain backward compatible with a common usage in - Numeric, basic slicing is also initiated if the selection object is - any non-ndarray and non-tuple sequence (such as a :class:`list`) containing - :class:`slice` objects, the :py:data:`Ellipsis` object, or the :const:`newaxis` - object, but not for integer arrays or other embedded sequences. - .. index:: triple: ndarray; special methods; getitem triple: ndarray; special methods; setitem @@ -211,7 +208,7 @@ concepts to remember include: - You may use slicing to set values in the array, but (unlike lists) you can never grow the array. The size of the value to be set in - ``x[obj] = value`` must be (broadcastable) to the same shape as + ``x[obj] = value`` must be (broadcastable to) the same shape as ``x[obj]``. - A slicing tuple can always be constructed as *obj* @@ -226,9 +223,10 @@ concepts to remember include: .. index:: pair: ndarray; view +.. _dimensional-indexing-tools: Dimensional indexing tools -^^^^^^^^^^^^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~~~~~~~~~~~~ There are some tools to facilitate the easy matching of array shapes with expressions and in assignments. @@ -296,12 +294,8 @@ basic slicing that returns a :term:`view`). the former will trigger advanced indexing. Be sure to understand why this occurs. - Also recognize that ``x[[1, 2, 3]]`` will trigger advanced indexing, - whereas due to the deprecated Numeric compatibility mentioned above, - ``x[[1, 2, slice(None)]]`` will trigger basic slicing. - Integer array indexing -^^^^^^^^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~~~~~~~~ Integer array indexing allows selection of arbitrary items in the array based on their *N*-dimensional index. Each integer array represents a number @@ -325,6 +319,8 @@ If the index values are out of bounds then an ``IndexError`` is thrown:: array([[3, 4], [5, 6]]) >>> x[np.array([3, 4])] + Traceback (most recent call last): + ... IndexError: index 3 is out of bounds for axis 0 with size 3 When the index consists of as many integer arrays as dimensions of the array @@ -368,6 +364,8 @@ broadcast them to the same shape. If they cannot be broadcast to the same shape, an exception is raised:: >>> y[np.array([0, 2, 4]), np.array([0, 1])] + Traceback (most recent call last): + ... IndexError: shape mismatch: indexing arrays could not be broadcast together with shapes (3,) (2,) @@ -470,9 +468,10 @@ such an array with an image with shape (ny, nx) with dtype=np.uint8 lookup table) will result in an array of shape (ny, nx, 3) where a triple of RGB values is associated with each pixel location. +.. _boolean-indexing: Boolean array indexing -^^^^^^^^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~~~~~~~~ This advanced indexing occurs when *obj* is an array object of Boolean type, such as may be returned from comparison operators. A single @@ -502,7 +501,7 @@ Or wish to add a constant to all negative elements:: >>> x = np.array([1., -1., -2., 3]) >>> x[x < 0] += 20 >>> x - array([1., 19., 18., 3.]) + array([ 1., 19., 18., 3.]) In general if an index includes a Boolean array, the result will be identical to inserting ``obj.nonzero()`` into the same position @@ -603,7 +602,7 @@ with four True elements to select rows from a 3-D array of shape .. _combining-advanced-and-basic-indexing: Combining advanced and basic indexing -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ When there is at least one slice (``:``), ellipsis (``...``) or :const:`newaxis` in the index (or the array has more dimensions than there are advanced indices), @@ -707,7 +706,7 @@ Slicing can be combined with broadcasted boolean indices:: .. _arrays.indexing.fields: Field access -------------- +------------ .. seealso:: :ref:`structured_arrays` @@ -786,6 +785,8 @@ exceptions (assigning complex to floats or ints): :: >>> x[1] 1 >>> x[1] = 1.2j + Traceback (most recent call last): + ... TypeError: can't convert complex to int @@ -851,7 +852,7 @@ For this reason, it is possible to use the output from the :meth:`np.nonzero() ` function directly as an index since it always returns a tuple of index arrays. -Because the special treatment of tuples, they are not automatically +Because of the special treatment of tuples, they are not automatically converted to an array as a list would be. As an example: :: >>> z[[1, 1, 1, 1]] # produces a large array diff --git a/doc/source/user/basics.interoperability.rst b/doc/source/user/basics.interoperability.rst new file mode 100644 index 000000000000..3b2f16431f19 --- /dev/null +++ b/doc/source/user/basics.interoperability.rst @@ -0,0 +1,524 @@ + +.. _basics.interoperability: + +*************************** +Interoperability with NumPy +*************************** + +NumPy's ndarray objects provide both a high-level API for operations on +array-structured data and a concrete implementation of the API based on +:ref:`strided in-RAM storage `. While this API is powerful and fairly +general, its concrete implementation has limitations. As datasets grow and NumPy +becomes used in a variety of new environments and architectures, there are cases +where the strided in-RAM storage strategy is inappropriate, which has caused +different libraries to reimplement this API for their own uses. This includes +GPU arrays (CuPy_), Sparse arrays (`scipy.sparse`, `PyData/Sparse `_) +and parallel arrays (Dask_ arrays) as well as various NumPy-like implementations +in deep learning frameworks, like TensorFlow_ and PyTorch_. Similarly, there are +many projects that build on top of the NumPy API for labeled and indexed arrays +(XArray_), automatic differentiation (JAX_), masked arrays (`numpy.ma`), +physical units (astropy.units_, pint_, unyt_), among others that add additional +functionality on top of the NumPy API. + +Yet, users still want to work with these arrays using the familiar NumPy API and +re-use existing code with minimal (ideally zero) porting overhead. With this +goal in mind, various protocols are defined for implementations of +multi-dimensional arrays with high-level APIs matching NumPy. + +Broadly speaking, there are three groups of features used for interoperability +with NumPy: + +1. Methods of turning a foreign object into an ndarray; +2. Methods of deferring execution from a NumPy function to another array + library; +3. Methods that use NumPy functions and return an instance of a foreign object. + +We describe these features below. + + +1. Using arbitrary objects in NumPy +----------------------------------- + +The first set of interoperability features from the NumPy API allows foreign +objects to be treated as NumPy arrays whenever possible. When NumPy functions +encounter a foreign object, they will try (in order): + +1. The buffer protocol, described :py:doc:`in the Python C-API documentation + `. +2. The ``__array_interface__`` protocol, described + :ref:`in this page `. A precursor to Python's buffer + protocol, it defines a way to access the contents of a NumPy array from other + C extensions. +3. The ``__array__()`` method, which asks an arbitrary object to convert + itself into an array. + +For both the buffer and the ``__array_interface__`` protocols, the object +describes its memory layout and NumPy does everything else (zero-copy if +possible). If that's not possible, the object itself is responsible for +returning a ``ndarray`` from ``__array__()``. + +:doc:`DLPack ` is yet another protocol to convert foreign objects +to NumPy arrays in a language and device agnostic manner. NumPy doesn't implicitly +convert objects to ndarrays using DLPack. It provides the function +`numpy.from_dlpack` that accepts any object implementing the ``__dlpack__`` method +and outputs a NumPy ndarray (which is generally a view of the input object's data +buffer). The :ref:`dlpack:python-spec` page explains the ``__dlpack__`` protocol +in detail. + +The array interface protocol +~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +The :ref:`array interface protocol ` defines a way for +array-like objects to re-use each other's data buffers. Its implementation +relies on the existence of the following attributes or methods: + +- ``__array_interface__``: a Python dictionary containing the shape, the + element type, and optionally, the data buffer address and the strides of an + array-like object; +- ``__array__()``: a method returning the NumPy ndarray view of an array-like + object; + +The ``__array_interface__`` attribute can be inspected directly: + + >>> import numpy as np + >>> x = np.array([1, 2, 5.0, 8]) + >>> x.__array_interface__ + {'data': (94708397920832, False), 'strides': None, 'descr': [('', '>> class wrapper(): + ... pass + ... + >>> arr = np.array([1, 2, 3, 4]) + >>> buf = arr.__array_interface__ + >>> buf + {'data': (140497590272032, False), 'strides': None, 'descr': [('', '>> buf['shape'] = (2, 2) + >>> w = wrapper() + >>> w.__array_interface__ = buf + >>> new_arr = np.array(w, copy=False) + >>> new_arr + array([[1, 2], + [3, 4]]) + +We can check that ``arr`` and ``new_arr`` share the same data buffer: + + >>> new_arr[0, 0] = 1000 + >>> new_arr + array([[1000, 2], + [ 3, 4]]) + >>> arr + array([1000, 2, 3, 4]) + + +The ``__array__()`` method +~~~~~~~~~~~~~~~~~~~~~~~~~~ + +The ``__array__()`` method ensures that any NumPy-like object (an array, any +object exposing the array interface, an object whose ``__array__()`` method +returns an array or any nested sequence) that implements it can be used as a +NumPy array. If possible, this will mean using ``__array__()`` to create a NumPy +ndarray view of the array-like object. Otherwise, this copies the data into a +new ndarray object. This is not optimal, as coercing arrays into ndarrays may +cause performance problems or create the need for copies and loss of metadata, +as the original object and any attributes/behavior it may have had, is lost. + +To see an example of a custom array implementation including the use of +``__array__()``, see :ref:`basics.dispatch`. + +The DLPack Protocol +~~~~~~~~~~~~~~~~~~~ + +The :doc:`DLPack ` protocol defines a memory-layout of +strided n-dimensional array objects. It offers the following syntax +for data exchange: + +1. A `numpy.from_dlpack` function, which accepts (array) objects with a + ``__dlpack__`` method and uses that method to construct a new array + containing the data from ``x``. +2. ``__dlpack__(self, stream=None)`` and ``__dlpack_device__`` methods on the + array object, which will be called from within ``from_dlpack``, to query + what device the array is on (may be needed to pass in the correct + stream, e.g. in the case of multiple GPUs) and to access the data. + +Unlike the buffer protocol, DLPack allows exchanging arrays containing data on +devices other than the CPU (e.g. Vulkan or GPU). Since NumPy only supports CPU, +it can only convert objects whose data exists on the CPU. But other libraries, +like PyTorch_ and CuPy_, may exchange data on GPU using this protocol. + + +2. Operating on foreign objects without converting +-------------------------------------------------- + +A second set of methods defined by the NumPy API allows us to defer the +execution from a NumPy function to another array library. + +Consider the following function. + + >>> import numpy as np + >>> def f(x): + ... return np.mean(np.exp(x)) + +Note that `np.exp ` is a :ref:`ufunc `, which means +that it operates on ndarrays in an element-by-element fashion. On the other +hand, `np.mean ` operates along one of the array's axes. + +We can apply ``f`` to a NumPy ndarray object directly: + + >>> x = np.array([1, 2, 3, 4]) + >>> f(x) + 21.1977562209304 + +We would like this function to work equally well with any NumPy-like array +object. + +NumPy allows a class to indicate that it would like to handle computations in a +custom-defined way through the following interfaces: + +- ``__array_ufunc__``: allows third-party objects to support and override + :ref:`ufuncs `. +- ``__array_function__``: a catch-all for NumPy functionality that is not + covered by the ``__array_ufunc__`` protocol for universal functions. + +As long as foreign objects implement the ``__array_ufunc__`` or +``__array_function__`` protocols, it is possible to operate on them without the +need for explicit conversion. + +The ``__array_ufunc__`` protocol +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +A :ref:`universal function (or ufunc for short) ` is a +“vectorized” wrapper for a function that takes a fixed number of specific inputs +and produces a fixed number of specific outputs. The output of the ufunc (and +its methods) is not necessarily a ndarray, if not all input arguments are +ndarrays. Indeed, if any input defines an ``__array_ufunc__`` method, control +will be passed completely to that function, i.e., the ufunc is overridden. The +``__array_ufunc__`` method defined on that (non-ndarray) object has access to +the NumPy ufunc. Because ufuncs have a well-defined structure, the foreign +``__array_ufunc__`` method may rely on ufunc attributes like ``.at()``, +``.reduce()``, and others. + +A subclass can override what happens when executing NumPy ufuncs on it by +overriding the default ``ndarray.__array_ufunc__`` method. This method is +executed instead of the ufunc and should return either the result of the +operation, or ``NotImplemented`` if the operation requested is not implemented. + +The ``__array_function__`` protocol +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +To achieve enough coverage of the NumPy API to support downstream projects, +there is a need to go beyond ``__array_ufunc__`` and implement a protocol that +allows arguments of a NumPy function to take control and divert execution to +another function (for example, a GPU or parallel implementation) in a way that +is safe and consistent across projects. + +The semantics of ``__array_function__`` are very similar to ``__array_ufunc__``, +except the operation is specified by an arbitrary callable object rather than a +ufunc instance and method. For more details, see :ref:`NEP18`. + + +3. Returning foreign objects +---------------------------- + +A third type of feature set is meant to use the NumPy function implementation +and then convert the return value back into an instance of the foreign object. +The ``__array_finalize__`` and ``__array_wrap__`` methods act behind the scenes +to ensure that the return type of a NumPy function can be specified as needed. + +The ``__array_finalize__`` method is the mechanism that NumPy provides to allow +subclasses to handle the various ways that new instances get created. This +method is called whenever the system internally allocates a new array from an +object which is a subclass (subtype) of the ndarray. It can be used to change +attributes after construction, or to update meta-information from the “parent.” + +The ``__array_wrap__`` method “wraps up the action” in the sense of allowing any +object (such as user-defined functions) to set the type of its return value and +update attributes and metadata. This can be seen as the opposite of the +``__array__`` method. At the end of every object that implements +``__array_wrap__``, this method is called on the input object with the highest +*array priority*, or the output object if one was specified. The +``__array_priority__`` attribute is used to determine what type of object to +return in situations where there is more than one possibility for the Python +type of the returned object. For example, subclasses may opt to use this method +to transform the output array into an instance of the subclass and update +metadata before returning the array to the user. + +For more information on these methods, see :ref:`basics.subclassing` and +:ref:`specific-array-subtyping`. + + +Interoperability examples +------------------------- + +Example: Pandas ``Series`` objects +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Consider the following: + + >>> import pandas as pd + >>> ser = pd.Series([1, 2, 3, 4]) + >>> type(ser) + pandas.core.series.Series + +Now, ``ser`` is **not** a ndarray, but because it +`implements the __array_ufunc__ protocol +`__, +we can apply ufuncs to it as if it were a ndarray: + + >>> np.exp(ser) + 0 2.718282 + 1 7.389056 + 2 20.085537 + 3 54.598150 + dtype: float64 + >>> np.sin(ser) + 0 0.841471 + 1 0.909297 + 2 0.141120 + 3 -0.756802 + dtype: float64 + +We can even do operations with other ndarrays: + + >>> np.add(ser, np.array([5, 6, 7, 8])) + 0 6 + 1 8 + 2 10 + 3 12 + dtype: int64 + >>> f(ser) + 21.1977562209304 + >>> result = ser.__array__() + >>> type(result) + numpy.ndarray + + +Example: PyTorch tensors +~~~~~~~~~~~~~~~~~~~~~~~~ + +`PyTorch `__ is an optimized tensor library for deep +learning using GPUs and CPUs. PyTorch arrays are commonly called *tensors*. +Tensors are similar to NumPy's ndarrays, except that tensors can run on GPUs or +other hardware accelerators. In fact, tensors and NumPy arrays can often share +the same underlying memory, eliminating the need to copy data. + + >>> import torch + >>> data = [[1, 2],[3, 4]] + >>> x_np = np.array(data) + >>> x_tensor = torch.tensor(data) + +Note that ``x_np`` and ``x_tensor`` are different kinds of objects: + + >>> x_np + array([[1, 2], + [3, 4]]) + >>> x_tensor + tensor([[1, 2], + [3, 4]]) + +However, we can treat PyTorch tensors as NumPy arrays without the need for +explicit conversion: + + >>> np.exp(x_tensor) + tensor([[ 2.7183, 7.3891], + [20.0855, 54.5982]], dtype=torch.float64) + +Also, note that the return type of this function is compatible with the initial +data type. + +.. admonition:: Warning + + While this mixing of ndarrays and tensors may be convenient, it is not + recommended. It will not work for non-CPU tensors, and will have unexpected + behavior in corner cases. Users should prefer explicitly converting the + ndarray to a tensor. + +.. note:: + + PyTorch does not implement ``__array_function__`` or ``__array_ufunc__``. + Under the hood, the ``Tensor.__array__()`` method returns a NumPy ndarray as + a view of the tensor data buffer. See `this issue + `__ and the + `__torch_function__ implementation + `__ + for details. + +Note also that we can see ``__array_wrap__`` in action here, even though +``torch.Tensor`` is not a subclass of ndarray:: + + >>> import torch + >>> t = torch.arange(4) + >>> np.abs(t) + tensor([0, 1, 2, 3]) + +PyTorch implements ``__array_wrap__`` to be able to get tensors back from NumPy +functions, and we can modify it directly to control which type of objects are +returned from these functions. + +Example: CuPy arrays +~~~~~~~~~~~~~~~~~~~~ + +CuPy is a NumPy/SciPy-compatible array library for GPU-accelerated computing +with Python. CuPy implements a subset of the NumPy interface by implementing +``cupy.ndarray``, `a counterpart to NumPy ndarrays +`__. + + >>> import cupy as cp + >>> x_gpu = cp.array([1, 2, 3, 4]) + +The ``cupy.ndarray`` object implements the ``__array_ufunc__`` interface. This +enables NumPy ufuncs to be applied to CuPy arrays (this will defer operation to +the matching CuPy CUDA/ROCm implementation of the ufunc): + + >>> np.mean(np.exp(x_gpu)) + array(21.19775622) + +Note that the return type of these operations is still consistent with the +initial type: + + >>> arr = cp.random.randn(1, 2, 3, 4).astype(cp.float32) + >>> result = np.sum(arr) + >>> print(type(result)) + + +See `this page in the CuPy documentation for details +`__. + +``cupy.ndarray`` also implements the ``__array_function__`` interface, meaning +it is possible to do operations such as + + >>> a = np.random.randn(100, 100) + >>> a_gpu = cp.asarray(a) + >>> qr_gpu = np.linalg.qr(a_gpu) + +CuPy implements many NumPy functions on ``cupy.ndarray`` objects, but not all. +See `the CuPy documentation +`__ +for details. + +Example: Dask arrays +~~~~~~~~~~~~~~~~~~~~ + +Dask is a flexible library for parallel computing in Python. Dask Array +implements a subset of the NumPy ndarray interface using blocked algorithms, +cutting up the large array into many small arrays. This allows computations on +larger-than-memory arrays using multiple cores. + +Dask supports ``__array__()`` and ``__array_ufunc__``. + + >>> import dask.array as da + >>> x = da.random.normal(1, 0.1, size=(20, 20), chunks=(10, 10)) + >>> np.mean(np.exp(x)) + dask.array + >>> np.mean(np.exp(x)).compute() + 5.090097550553843 + +.. note:: + + Dask is lazily evaluated, and the result from a computation isn't computed + until you ask for it by invoking ``compute()``. + +See `the Dask array documentation +`__ +and the `scope of Dask arrays interoperability with NumPy arrays +`__ for details. + +Example: DLPack +~~~~~~~~~~~~~~~ + +Several Python data science libraries implement the ``__dlpack__`` protocol. +Among them are PyTorch_ and CuPy_. A full list of libraries that implement +this protocol can be found on +:doc:`this page of DLPack documentation `. + +Convert a PyTorch CPU tensor to NumPy array: + + >>> import torch + >>> x_torch = torch.arange(5) + >>> x_torch + tensor([0, 1, 2, 3, 4]) + >>> x_np = np.from_dlpack(x_torch) + >>> x_np + array([0, 1, 2, 3, 4]) + >>> # note that x_np is a view of x_torch + >>> x_torch[1] = 100 + >>> x_torch + tensor([ 0, 100, 2, 3, 4]) + >>> x_np + array([ 0, 100, 2, 3, 4]) + +The imported arrays are read-only so writing or operating in-place will fail: + + >>> x.flags.writeable + False + >>> x_np[1] = 1 + Traceback (most recent call last): + File "", line 1, in + ValueError: assignment destination is read-only + +A copy must be created in order to operate on the imported arrays in-place, but +will mean duplicating the memory. Do not do this for very large arrays: + + >>> x_np_copy = x_np.copy() + >>> x_np_copy.sort() # works + +.. note:: + + Note that GPU tensors can't be converted to NumPy arrays since NumPy doesn't + support GPU devices: + + >>> x_torch = torch.arange(5, device='cuda') + >>> np.from_dlpack(x_torch) + Traceback (most recent call last): + File "", line 1, in + RuntimeError: Unsupported device in DLTensor. + + But, if both libraries support the device the data buffer is on, it is + possible to use the ``__dlpack__`` protocol (e.g. PyTorch_ and CuPy_): + + >>> x_torch = torch.arange(5, device='cuda') + >>> x_cupy = cupy.from_dlpack(x_torch) + +Similarly, a NumPy array can be converted to a PyTorch tensor: + + >>> x_np = np.arange(5) + >>> x_torch = torch.from_dlpack(x_np) + +Read-only arrays cannot be exported: + + >>> x_np = np.arange(5) + >>> x_np.flags.writeable = False + >>> torch.from_dlpack(x_np) # doctest: +ELLIPSIS + Traceback (most recent call last): + File "", line 1, in + File ".../site-packages/torch/utils/dlpack.py", line 63, in from_dlpack + dlpack = ext_tensor.__dlpack__() + TypeError: NumPy currently only supports dlpack for writeable arrays + +Further reading +--------------- + +- :ref:`arrays.interface` +- :ref:`basics.dispatch` +- :ref:`special-attributes-and-methods` (details on the ``__array_ufunc__`` and + ``__array_function__`` protocols) +- :ref:`basics.subclassing` (details on the ``__array_wrap__`` and + ``__array_finalize__`` methods) +- :ref:`specific-array-subtyping` (more details on the implementation of + ``__array_finalize__``, ``__array_wrap__`` and ``__array_priority__``) +- :doc:`NumPy roadmap: interoperability ` +- `PyTorch documentation on the Bridge with NumPy + `__ + +.. _CuPy: https://cupy.dev/ +.. _Sparse: https://sparse.pydata.org/ +.. _Dask: https://docs.dask.org/ +.. _TensorFlow: https://www.tensorflow.org/ +.. _PyTorch: https://pytorch.org/ +.. _XArray: http://xarray.pydata.org/ +.. _JAX: https://jax.readthedocs.io/ +.. _astropy.units: https://docs.astropy.org/en/stable/units/ +.. _pint: https://pint.readthedocs.io/ +.. _unyt: https://unyt.readthedocs.io/ diff --git a/doc/source/user/basics.io.genfromtxt.rst b/doc/source/user/basics.io.genfromtxt.rst index 8fe7565aa730..a9c521fa378d 100644 --- a/doc/source/user/basics.io.genfromtxt.rst +++ b/doc/source/user/basics.io.genfromtxt.rst @@ -60,8 +60,8 @@ example, comma-separated files (CSV) use a comma (``,``) or a semicolon >>> data = u"1, 2, 3\n4, 5, 6" >>> np.genfromtxt(StringIO(data), delimiter=",") - array([[ 1., 2., 3.], - [ 4., 5., 6.]]) + array([[1., 2., 3.], + [4., 5., 6.]]) Another common separator is ``"\t"``, the tabulation character. However, we are not limited to a single character, any string will do. By default, @@ -76,14 +76,14 @@ size) or to a sequence of integers (if columns can have different sizes):: >>> data = u" 1 2 3\n 4 5 67\n890123 4" >>> np.genfromtxt(StringIO(data), delimiter=3) - array([[ 1., 2., 3.], - [ 4., 5., 67.], - [ 890., 123., 4.]]) + array([[ 1., 2., 3.], + [ 4., 5., 67.], + [890., 123., 4.]]) >>> data = u"123456789\n 4 7 9\n 4567 9" >>> np.genfromtxt(StringIO(data), delimiter=(4, 3, 2)) - array([[ 1234., 567., 89.], - [ 4., 7., 9.], - [ 4., 567., 9.]]) + array([[1234., 567., 89.], + [ 4., 7., 9.], + [ 4., 567., 9.]]) The ``autostrip`` argument @@ -156,10 +156,10 @@ using the ``skip_footer`` attribute and giving it a value of ``n``:: >>> data = u"\n".join(str(i) for i in range(10)) >>> np.genfromtxt(StringIO(data),) - array([ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9.]) + array([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.]) >>> np.genfromtxt(StringIO(data), ... skip_header=3, skip_footer=5) - array([ 3., 4.]) + array([3., 4.]) By default, ``skip_header=0`` and ``skip_footer=0``, meaning that no lines are skipped. @@ -180,8 +180,8 @@ can use ``usecols=(0, -1)``:: >>> data = u"1 2 3\n4 5 6" >>> np.genfromtxt(StringIO(data), usecols=(0, -1)) - array([[ 1., 3.], - [ 4., 6.]]) + array([[1., 3.], + [4., 6.]]) If the columns have names, we can also select which columns to import by giving their name to the ``usecols`` argument, either as a sequence @@ -190,12 +190,10 @@ of strings or a comma-separated string:: >>> data = u"1 2 3\n4 5 6" >>> np.genfromtxt(StringIO(data), ... names="a, b, c", usecols=("a", "c")) - array([(1.0, 3.0), (4.0, 6.0)], - dtype=[('a', '>> np.genfromtxt(StringIO(data), ... names="a, b, c", usecols=("a, c")) - array([(1.0, 3.0), (4.0, 6.0)], - dtype=[('a', '>> data = StringIO("1 2 3\n 4 5 6") >>> np.genfromtxt(data, names="A, B, C") - array([(1.0, 2.0, 3.0), (4.0, 5.0, 6.0)], + array([(1., 2., 3.), (4., 5., 6.)], dtype=[('A', '>> data = StringIO("So it goes\n#a b c\n1 2 3\n 4 5 6") >>> np.genfromtxt(data, skip_header=1, names=True) - array([(1.0, 2.0, 3.0), (4.0, 5.0, 6.0)], + array([(1., 2., 3.), (4., 5., 6.)], dtype=[('a', '>> ndtype=[('a',int), ('b', float), ('c', int)] >>> names = ["A", "B", "C"] >>> np.genfromtxt(data, names=names, dtype=ndtype) - array([(1, 2.0, 3), (4, 5.0, 6)], + array([(1, 2., 3), (4, 5., 6)], dtype=[('A', '>> data = StringIO("1 2 3\n 4 5 6") >>> np.genfromtxt(data, dtype=(int, float, int)) - array([(1, 2.0, 3), (4, 5.0, 6)], + array([(1, 2., 3), (4, 5., 6)], dtype=[('f0', '>> data = StringIO("1 2 3\n 4 5 6") >>> np.genfromtxt(data, dtype=(int, float, int), names="a") - array([(1, 2.0, 3), (4, 5.0, 6)], + array([(1, 2., 3), (4, 5., 6)], dtype=[('a', '>> data = StringIO("1 2 3\n 4 5 6") >>> np.genfromtxt(data, dtype=(int, float, int), defaultfmt="var_%02i") - array([(1, 2.0, 3), (4, 5.0, 6)], + array([(1, 2., 3), (4, 5., 6)], dtype=[('var_00', '>> # Converted case ... >>> np.genfromtxt(StringIO(data), delimiter=",", names=names, ... converters={1: convertfunc}) - array([(1.0, 0.023, 45.0), (6.0, 0.78900000000000003, 0.0)], + array([(1., 0.023, 45.), (6., 0.789, 0.)], dtype=[('i', '>> # Using a name for the converter ... >>> np.genfromtxt(StringIO(data), delimiter=",", names=names, ... converters={"p": convertfunc}) - array([(1.0, 0.023, 45.0), (6.0, 0.78900000000000003, 0.0)], + array([(1., 0.023, 45.), (6., 0.789, 0.)], dtype=[('i', '`. For example, ... dtype=[('name', 'U10'), ('age', 'i4'), ('weight', 'f4')]) >>> x array([('Rex', 9, 81.), ('Fido', 3, 27.)], - dtype=[('name', 'U10'), ('age', '>> x[1] - ('Fido', 3, 27.0) + ('Fido', 3, 27.) You can access and modify individual fields of a structured array by indexing with the field name:: @@ -34,7 +34,7 @@ with the field name:: >>> x['age'] = 5 >>> x array([('Rex', 5, 81.), ('Fido', 5, 27.)], - dtype=[('name', 'U10'), ('age', '>> np.dtype({'col1': ('i1', 0), 'col2': ('f4', 1)}) dtype([('col1', 'i1'), ('col2', '` may be + This form was discouraged because Python dictionaries did not preserve order + in Python versions before Python 3.6. :ref:`Field Titles ` may be specified by using a 3-tuple, see below. Manipulating and Displaying Structured Datatypes @@ -302,7 +300,7 @@ There are a number of ways to assign values to a structured array: Using python tuples, using scalar values, or using other structured arrays. Assignment from Python Native Types (Tuples) -```````````````````````````````````````````` +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The simplest way to assign values to a structured array is using python tuples. Each assigned value should be a tuple of length equal to the number of fields @@ -317,7 +315,7 @@ of the array, from left to right:: dtype=[('f0', '>> a = np.zeros(3, dtype=[('a', 'i4'), ('b', 'i4'), ('c', 'f4')]) >>> a[['a', 'c']] array([(0, 0.), (0, 0.), (0, 0.)], - dtype={'names':['a','c'], 'formats':['>> from numpy.lib.recfunctions import structured_to_unstructured >>> structured_to_unstructured(b[['x', 'z']]) - array([0, 0, 0]) + array([[0., 0.], + [0., 0.], + [0., 0.]], dtype=float32) Assignment to an array with a multi-field index modifies the original array:: @@ -502,7 +502,7 @@ multi-field indexes:: >>> a[['a', 'c']] = a[['c', 'a']] Indexing with an Integer to get a Structured Scalar -``````````````````````````````````````````````````` +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Indexing a single element of a structured array (with an integer index) returns a structured scalar:: @@ -548,29 +548,79 @@ In order to prevent clobbering object pointers in fields of :class:`object` type, numpy currently does not allow views of structured arrays containing objects. -Structure Comparison --------------------- +.. _structured_dtype_comparison_and_promotion: + +Structure Comparison and Promotion +---------------------------------- If the dtypes of two void structured arrays are equal, testing the equality of the arrays will result in a boolean array with the dimensions of the original arrays, with elements set to ``True`` where all fields of the corresponding -structures are equal. Structured dtypes are equal if the field names, -dtypes and titles are the same, ignoring endianness, and the fields are in -the same order:: +structures are equal:: - >>> a = np.zeros(2, dtype=[('a', 'i4'), ('b', 'i4')]) - >>> b = np.ones(2, dtype=[('a', 'i4'), ('b', 'i4')]) + >>> a = np.array([(1, 1), (2, 2)], dtype=[('a', 'i4'), ('b', 'i4')]) + >>> b = np.array([(1, 1), (2, 3)], dtype=[('a', 'i4'), ('b', 'i4')]) >>> a == b - array([False, False]) + array([True, False]) -Currently, if the dtypes of two void structured arrays are not equivalent the -comparison fails, returning the scalar value ``False``. This behavior is -deprecated as of numpy 1.10 and will raise an error or perform elementwise -comparison in the future. +NumPy will promote individual field datatypes to perform the comparison. +So the following is also valid (note the ``'f4'`` dtype for the ``'a'`` field): + + >>> b = np.array([(1.0, 1), (2.5, 2)], dtype=[("a", "f4"), ("b", "i4")]) + >>> a == b + array([True, False]) + +To compare two structured arrays, it must be possible to promote them to a +common dtype as returned by `numpy.result_type` and `np.promote_types`. +This enforces that the number of fields, the field names, and the field titles +must match precisely. +When promotion is not possible, for example due to mismatching field names, +NumPy will raise an error. +Promotion between two structured dtypes results in a canonical dtype that +ensures native byte-order for all fields:: + + >>> np.result_type(np.dtype("i,>i")) + dtype([('f0', '>> np.result_type(np.dtype("i,>i"), np.dtype("i,i")) + dtype([('f0', '>> dt = np.dtype("i1,V3,i4,V1")[["f0", "f2"]] + >>> dt + dtype({'names':['f0','f2'], 'formats':['i1','>> np.result_type(dt) + dtype([('f0', 'i1'), ('f2', '>> dt = np.dtype("i1,V3,i4,V1", align=True)[["f0", "f2"]] + >>> dt + dtype({'names':['f0','f2'], 'formats':['i1','>> np.result_type(dt) + dtype([('f0', 'i1'), ('f2', '>> np.result_type(dt).isalignedstruct + True + +When promoting multiple dtypes, the result is aligned if any of the inputs is:: + + >>> np.result_type(np.dtype("i,i"), np.dtype("i,i", align=True)) + dtype([('f0', '`` operators always return ``False`` when comparing void structured arrays, and arithmetic and bitwise operations are not supported. +.. versionchanged:: 1.23 + Before NumPy 1.23, a warning was given and ``False`` returned when + promotion to a common dtype failed. + Further, promotion was much more restrictive: It would reject the mixed + float/integer comparison example above. + Record Arrays ============= @@ -579,17 +629,18 @@ As an optional convenience numpy provides an ndarray subclass, attribute instead of only by index. Record arrays use a special datatype, :class:`numpy.record`, that allows field access by attribute on the structured scalars obtained from the array. -The :mod:`numpy.rec` module provides functions for creating recarrays from +The ``numpy.rec`` module provides functions for creating recarrays from various objects. Additional helper functions for creating and manipulating structured arrays can be found in :mod:`numpy.lib.recfunctions`. -The simplest way to create a record array is with ``numpy.rec.array``:: +The simplest way to create a record array is with +:func:`numpy.rec.array `:: >>> recordarr = np.rec.array([(1, 2., 'Hello'), (2, 3., "World")], ... dtype=[('foo', 'i4'),('bar', 'f4'), ('baz', 'S10')]) >>> recordarr.bar - array([ 2., 3.], dtype=float32) + array([2., 3.], dtype=float32) >>> recordarr[1:2] rec.array([(2, 3., b'World')], dtype=[('foo', '>> recordarr[1].baz b'World' -:func:`numpy.rec.array` can convert a wide variety of arguments into record -arrays, including structured arrays:: +:func:`numpy.rec.array ` can convert a wide variety +of arguments into record arrays, including structured arrays:: >>> arr = np.array([(1, 2., 'Hello'), (2, 3., "World")], ... dtype=[('foo', 'i4'), ('bar', 'f4'), ('baz', 'S10')]) >>> recordarr = np.rec.array(arr) -The :mod:`numpy.rec` module provides a number of other convenience functions for +The ``numpy.rec`` module provides a number of other convenience functions for creating record arrays, see :ref:`record array creation routines `. diff --git a/doc/source/user/basics.rst b/doc/source/user/basics.rst index affb85db2f0c..04c20da370f3 100644 --- a/doc/source/user/basics.rst +++ b/doc/source/user/basics.rst @@ -14,9 +14,6 @@ fundamental NumPy ideas and philosophy. basics.io basics.types basics.broadcasting - basics.byteswapping + basics.copies basics.rec - basics.dispatch - basics.subclassing basics.ufuncs - basics.copies diff --git a/doc/source/user/basics.subclassing.rst b/doc/source/user/basics.subclassing.rst index 1b78809865aa..e075a2b3f471 100644 --- a/doc/source/user/basics.subclassing.rst +++ b/doc/source/user/basics.subclassing.rst @@ -5,7 +5,7 @@ Subclassing ndarray ******************* Introduction ------------- +============ Subclassing ndarray is relatively simple, but it has some complications compared to other Python objects. On this page we explain the machinery @@ -13,7 +13,7 @@ that allows you to subclass ndarray, and the implications for implementing a subclass. ndarrays and object creation -============================ +---------------------------- Subclassing ndarray is complicated by the fact that new instances of ndarray classes can come about in three different ways. These are: @@ -31,10 +31,53 @@ things like array slicing. The complications of subclassing ndarray are due to the mechanisms numpy has to support these latter two routes of instance creation. +When to use subclassing +----------------------- + +Besides the additional complexities of subclassing a NumPy array, subclasses +can run into unexpected behaviour because some functions may convert the +subclass to a baseclass and "forget" any additional information +associated with the subclass. +This can result in surprising behavior if you use NumPy methods or +functions you have not explicitly tested. + +On the other hand, compared to other interoperability approaches, +subclassing can be a useful because many thing will "just work". + +This means that subclassing can be a convenient approach and for a long time +it was also often the only available approach. +However, NumPy now provides additional interoperability protocols described +in ":ref:`Interoperability with NumPy `". +For many use-cases these interoperability protocols may now be a better fit +or supplement the use of subclassing. + +Subclassing can be a good fit if: + +* you are less worried about maintainability or users other than yourself: + Subclass will be faster to implement and additional interoperability + can be added "as-needed". And with few users, possible surprises are not + an issue. +* you do not think it is problematic if the subclass information is + ignored or lost silently. An example is ``np.memmap`` where "forgetting" + about data being memory mapped cannot lead to a wrong result. + An example of a subclass that sometimes confuses users are NumPy's masked + arrays. When they were introduced, subclassing was the only approach for + implementation. However, today we would possibly try to avoid subclassing + and rely only on interoperability protocols. + +Note that also subclass authors may wish to study +:ref:`Interoperability with NumPy ` +to support more complex use-cases or work around the surprising behavior. + +``astropy.units.Quantity`` and ``xarray`` are examples for array-like objects +that interoperate well with NumPy. Astropy's ``Quantity`` is an example +which uses a dual approach of both subclassing and interoperability protocols. + + .. _view-casting: View casting ------------- +============ *View casting* is the standard ndarray mechanism by which you take an ndarray of any subclass, and return a view of the array as another @@ -48,12 +91,12 @@ ndarray of any subclass, and return a view of the array as another >>> # take a view of it, as our useless subclass >>> c_arr = arr.view(C) >>> type(c_arr) - + .. _new-from-template: Creating new from template --------------------------- +========================== New instances of an ndarray subclass can also come about by a very similar mechanism to :ref:`view-casting`, when numpy finds it needs to @@ -63,7 +106,7 @@ For example: >>> v = c_arr[1:] >>> type(v) # the view is of type 'C' - + >>> v is c_arr # but it's a new instance False @@ -77,7 +120,7 @@ such as copying arrays (``c_arr.copy()``), creating ufunc output arrays ``c_arr.mean()``). Relationship of view casting and new-from-template --------------------------------------------------- +================================================== These paths both use the same machinery. We make the distinction here, because they result in different input to your methods. Specifically, @@ -88,7 +131,7 @@ instance, allowing you - for example - to copy across attributes that are particular to your subclass. Implications for subclassing ----------------------------- +============================ If we subclass ndarray, we need to deal not only with explicit construction of our array type, but also :ref:`view-casting` or @@ -105,7 +148,7 @@ allow subclasses to clean up after the creation of views and new instances from templates. A brief Python primer on ``__new__`` and ``__init__`` -===================================================== +----------------------------------------------------- ``__new__`` is a standard Python method, and, if present, is called before ``__init__`` when we create a class instance. See the `python @@ -114,18 +157,15 @@ __new__ documentation For example, consider the following Python code: -.. testcode:: - - class C: - def __new__(cls, *args): - print('Cls in __new__:', cls) - print('Args in __new__:', args) - # The `object` type __new__ method takes a single argument. - return object.__new__(cls) - - def __init__(self, *args): - print('type(self) in __init__:', type(self)) - print('Args in __init__:', args) +>>> class C: +>>> def __new__(cls, *args): +>>> print('Cls in __new__:', cls) +>>> print('Args in __new__:', args) +>>> # The `object` type __new__ method takes a single argument. +>>> return object.__new__(cls) +>>> def __init__(self, *args): +>>> print('type(self) in __init__:', type(self)) +>>> print('Args in __init__:', args) meaning that we get: @@ -199,7 +239,7 @@ why not call ``obj = subdtype.__new__(...`` then? Because we may not have a ``__new__`` method with the same call signature). The role of ``__array_finalize__`` -================================== +---------------------------------- ``__array_finalize__`` is the mechanism that numpy provides to allow subclasses to handle the various ways that new instances get created. @@ -298,7 +338,7 @@ defaults for new object attributes, among other tasks. This may be clearer with an example. Simple example - adding an extra attribute to ndarray ------------------------------------------------------ +===================================================== .. testcode:: @@ -376,7 +416,7 @@ formed ndarray from the usual numpy calls to ``np.array`` and return an object. Slightly more realistic example - attribute added to existing array -------------------------------------------------------------------- +=================================================================== Here is a class that takes a standard ndarray that already exists, casts as our type, and adds an extra attribute. @@ -419,7 +459,7 @@ So: .. _array-ufunc: ``__array_ufunc__`` for ufuncs ------------------------------- +============================== .. versionadded:: 1.13 @@ -526,7 +566,7 @@ which inputs and outputs it converted. Hence, e.g., >>> a.info {'inputs': [0, 1], 'outputs': [0]} -Note that another approach would be to to use ``getattr(ufunc, +Note that another approach would be to use ``getattr(ufunc, methods)(*inputs, **kwargs)`` instead of the ``super`` call. For this example, the result would be identical, but there is a difference if another operand also defines ``__array_ufunc__``. E.g., lets assume that we evalulate @@ -559,7 +599,7 @@ pass on to ``A.__array_ufunc__``, the ``super`` call in ``A`` would go to .. _array-wrap: ``__array_wrap__`` for ufuncs and other functions -------------------------------------------------- +================================================= Prior to numpy 1.13, the behaviour of ufuncs could only be tuned using ``__array_wrap__`` and ``__array_prepare__``. These two allowed one to @@ -664,7 +704,7 @@ Like ``__array_wrap__``, ``__array_prepare__`` must return an ndarray or subclass thereof or raise an error. Extra gotchas - custom ``__del__`` methods and ndarray.base ------------------------------------------------------------ +=========================================================== One of the problems that ndarray solves is keeping track of memory ownership of ndarrays and their views. Consider the case where we have @@ -702,7 +742,7 @@ how this can work, have a look at the ``memmap`` class in ``numpy.core``. Subclassing and Downstream Compatibility ----------------------------------------- +======================================== When sub-classing ``ndarray`` or creating duck-types that mimic the ``ndarray`` interface, it is your responsibility to decide how aligned your APIs will be diff --git a/doc/source/user/basics.types.rst b/doc/source/user/basics.types.rst index 354f003fbb28..3d5b380dbc8c 100644 --- a/doc/source/user/basics.types.rst +++ b/doc/source/user/basics.types.rst @@ -104,11 +104,7 @@ aliases are provided (See :ref:`sized-aliases`). NumPy numerical types are instances of ``dtype`` (data-type) objects, each having unique characteristics. Once you have imported NumPy using - - :: - - >>> import numpy as np - +``>>> import numpy as np`` the dtypes are available as ``np.bool_``, ``np.float32``, etc. Advanced types, not listed above, are explored in @@ -127,7 +123,6 @@ Data-types can be used as functions to convert python numbers to array scalars to arrays of that type, or as arguments to the dtype keyword that many numpy functions or methods accept. Some examples:: - >>> import numpy as np >>> x = np.float32(1.0) >>> x 1.0 @@ -143,7 +138,7 @@ backward compatibility with older packages such as Numeric. Some documentation may still refer to these, for example:: >>> np.array([1, 2, 3], dtype='f') - array([ 1., 2., 3.], dtype=float32) + array([1., 2., 3.], dtype=float32) We recommend using dtype objects instead. @@ -151,7 +146,7 @@ To convert the type of an array, use the .astype() method (preferred) or the type itself as a function. For example: :: >>> z.astype(float) #doctest: +NORMALIZE_WHITESPACE - array([ 0., 1., 2.]) + array([0., 1., 2.]) >>> np.int8(z) array([0, 1, 2], dtype=int8) @@ -170,7 +165,7 @@ and its byte-order. The data type can also be used indirectly to query properties of the type, such as whether it is an integer:: >>> d = np.dtype(int) - >>> d + >>> d #doctest: +SKIP dtype('int32') >>> np.issubdtype(d, np.integer) @@ -258,8 +253,8 @@ compiler's ``long double`` available as ``np.longdouble`` (and numpy provides with ``np.finfo(np.longdouble)``. NumPy does not provide a dtype with more precision than C's -``long double``\\; in particular, the 128-bit IEEE quad precision -data type (FORTRAN's ``REAL*16``\\) is not available. +``long double``; in particular, the 128-bit IEEE quad precision +data type (FORTRAN's ``REAL*16``) is not available. For efficient memory alignment, ``np.longdouble`` is usually stored padded with zero bits, either to 96 or 128 bits. Which is more efficient diff --git a/doc/source/user/basics.ufuncs.rst b/doc/source/user/basics.ufuncs.rst index 083e31f702b5..5e83621aa619 100644 --- a/doc/source/user/basics.ufuncs.rst +++ b/doc/source/user/basics.ufuncs.rst @@ -89,7 +89,7 @@ Considering ``x`` from the previous example:: >>> y array([0, 0, 0]) >>> np.multiply.reduce(x, dtype=float, out=y) - array([ 0, 28, 80]) # dtype argument is ignored + array([ 0, 28, 80]) Ufuncs also have a fifth method, :func:`numpy.ufunc.at`, that allows in place operations to be performed using advanced indexing. No diff --git a/doc/source/user/broadcasting_1.png b/doc/source/user/broadcasting_1.png new file mode 100644 index 000000000000..40698f95216a Binary files /dev/null and b/doc/source/user/broadcasting_1.png differ diff --git a/doc/source/user/broadcasting_2.png b/doc/source/user/broadcasting_2.png new file mode 100644 index 000000000000..be71afb0d4f3 Binary files /dev/null and b/doc/source/user/broadcasting_2.png differ diff --git a/doc/source/user/broadcasting_3.png b/doc/source/user/broadcasting_3.png new file mode 100644 index 000000000000..806e6f96e163 Binary files /dev/null and b/doc/source/user/broadcasting_3.png differ diff --git a/doc/source/user/broadcasting_4.png b/doc/source/user/broadcasting_4.png new file mode 100644 index 000000000000..23c4c1617a38 Binary files /dev/null and b/doc/source/user/broadcasting_4.png differ diff --git a/doc/source/user/broadcasting_5.png b/doc/source/user/broadcasting_5.png new file mode 100644 index 000000000000..d4218ba247ff Binary files /dev/null and b/doc/source/user/broadcasting_5.png differ diff --git a/doc/source/user/building.rst b/doc/source/user/building.rst index 22efca4a6f83..d01b6c44e925 100644 --- a/doc/source/user/building.rst +++ b/doc/source/user/building.rst @@ -8,7 +8,7 @@ source. Your choice depends on your operating system and familiarity with the command line. Gitpod ------------- +------ Gitpod is an open-source platform that automatically creates the correct development environment right in your browser, reducing the need to @@ -21,7 +21,7 @@ in-depth instructions for building NumPy with `building NumPy with Gitpod`_. .. _building NumPy with Gitpod: https://numpy.org/devdocs/dev/development_gitpod.html Building locally ------------------- +---------------- Building locally on your machine gives you more granular control. If you are a MacOS or Linux user familiar with using the @@ -37,7 +37,7 @@ Prerequisites Building NumPy requires the following software installed: -1) Python 3.6.x or newer +1) Python 3.8.x or newer Please note that the Python development headers also need to be installed, e.g., on Debian/Ubuntu one needs to install both `python3` and @@ -48,6 +48,9 @@ Building NumPy requires the following software installed: Much of NumPy is written in C. You will need a C compiler that complies with the C99 standard. + Part of Numpy is now written in C++. You will also need a C++ compiler that + complies with the C++11 standard. + While a FORTRAN 77 compiler is not necessary for building NumPy, it is needed to run the ``numpy.f2py`` tests. These tests are skipped if the compiler is not auto-detected. @@ -56,7 +59,7 @@ Building NumPy requires the following software installed: MSVC and Clang compilers. Compilers from other vendors such as Intel, Absoft, Sun, NAG, Compaq, Vast, Portland, Lahey, HP, IBM are only supported in the form of community feedback, and may not work out of the - box. GCC 4.x (and later) compilers are recommended. On ARM64 (aarch64) + box. GCC 6.5 (and later) compilers are recommended. On ARM64 (aarch64) GCC 8.x (and later) are recommended. 3) Linear Algebra libraries @@ -76,6 +79,10 @@ Building NumPy requires the following software installed: For building NumPy, you'll need a recent version of Cython. +5) The NumPy source code + + Clone the repository following the instructions in :doc:`/dev/index`. + Basic Installation ------------------ @@ -94,7 +101,14 @@ Testing ------- Make sure to test your builds. To ensure everything stays in shape, see if -all tests pass:: +all tests pass. + +The test suite requires additional dependencies, which can easily be +installed with:: + + $ python -m pip install -r test_requirements.txt + +Run tests:: $ python runtests.py -v -m full @@ -288,3 +302,101 @@ Additional compiler flags can be supplied by setting the ``OPT``, When providing options that should improve the performance of the code ensure that you also set ``-DNDEBUG`` so that debugging code is not executed. + +Cross compilation +----------------- + +Although ``numpy.distutils`` and ``setuptools`` do not directly support cross +compilation, it is possible to build NumPy on one system for different +architectures with minor modifications to the build environment. This may be +desirable, for example, to use the power of a high-performance desktop to +create a NumPy package for a low-power, single-board computer. Because the +``setup.py`` scripts are unaware of cross-compilation environments and tend to +make decisions based on the environment detected on the build system, it is +best to compile for the same type of operating system that runs on the builder. +Attempting to compile a Mac version of NumPy on Windows, for example, is likely +to be met with challenges not considered here. + +For the purpose of this discussion, the nomenclature adopted by `meson`_ will +be used: the "build" system is that which will be running the NumPy build +process, while the "host" is the platform on which the compiled package will be +run. A native Python interpreter, the setuptools and Cython packages and the +desired cross compiler must be available for the build system. In addition, a +Python interpreter and its development headers as well as any external linear +algebra libraries must be available for the host platform. For convenience, it +is assumed that all host software is available under a separate prefix +directory, here called ``$CROSS_PREFIX``. + +.. _meson: https://mesonbuild.com/Cross-compilation.html#cross-compilation + +When building and installing NumPy for a host system, the ``CC`` environment +variable must provide the path the cross compiler that will be used to build +NumPy C extensions. It may also be necessary to set the ``LDSHARED`` +environment variable to the path to the linker that can link compiled objects +for the host system. The compiler must be told where it can find Python +libraries and development headers. On Unix-like systems, this generally +requires adding, *e.g.*, the following parameters to the ``CFLAGS`` environment +variable:: + + -I${CROSS_PREFIX}/usr/include + -I${CROSS_PREFIX}/usr/include/python3.y + +for Python version 3.y. (Replace the "y" in this path with the actual minor +number of the installed Python runtime.) Likewise, the linker should be told +where to find host libraries by adding a parameter to the ``LDFLAGS`` +environment variable:: + + -L${CROSS_PREFIX}/usr/lib + +To make sure Python-specific system configuration options are provided for the +intended host and not the build system, set:: + + _PYTHON_SYSCONFIGDATA_NAME=_sysconfigdata_${ARCH_TRIPLET} + +where ``${ARCH_TRIPLET}`` is an architecture-dependent suffix appropriate for +the host architecture. (This should be the name of a ``_sysconfigdata`` file, +without the ``.py`` extension, found in the host Python library directory.) + +When using external linear algebra libraries, include and library directories +should be provided for the desired libraries in ``site.cfg`` as described +above and in the comments of the ``site.cfg.example`` file included in the +NumPy repository or sdist. In this example, set:: + + include_dirs = ${CROSS_PREFIX}/usr/include + library_dirs = ${CROSS_PREFIX}/usr/lib + +under appropriate sections of the file to allow ``numpy.distutils`` to find the +libraries. + +As of NumPy 1.22.0, a vendored copy of SVML will be built on ``x86_64`` Linux +hosts to provide AVX-512 acceleration of floating-point operations. When using +an ``x86_64`` Linux build system to cross compile NumPy for hosts other than +``x86_64`` Linux, set the environment variable ``NPY_DISABLE_SVML`` to prevent +the NumPy build script from incorrectly attempting to cross-compile this +platform-specific library:: + + NPY_DISABLE_SVML=1 + +With the environment configured, NumPy may be built as it is natively:: + + python setup.py build + +When the ``wheel`` package is available, the cross-compiled package may be +packed into a wheel for installation on the host with:: + + python setup.py bdist_wheel + +It may be possible to use ``pip`` to build a wheel, but ``pip`` configures its +own environment; adapting the ``pip`` environment to cross-compilation is +beyond the scope of this guide. + +The cross-compiled package may also be installed into the host prefix for +cross-compilation of other packages using, *e.g.*, the command:: + + python setup.py install --prefix=${CROSS_PREFIX} + +When cross compiling other packages that depend on NumPy, the host +npy-pkg-config file must be made available. For further discussion, refer to +`numpy distutils documentation`_. + +.. _numpy distutils documentation: https://numpy.org/devdocs/reference/distutils.html#numpy.distutils.misc_util.Configuration.add_npy_pkg_config diff --git a/doc/source/user/basics.byteswapping.rst b/doc/source/user/byteswapping.rst similarity index 92% rename from doc/source/user/basics.byteswapping.rst rename to doc/source/user/byteswapping.rst index fecdb9ee8543..26ffa89439dd 100644 --- a/doc/source/user/basics.byteswapping.rst +++ b/doc/source/user/byteswapping.rst @@ -5,7 +5,7 @@ Byte-swapping Introduction to byte ordering and ndarrays ========================================== -The ``ndarray`` is an object that provide a python array interface to data +The ``ndarray`` is an object that provides a python array interface to data in memory. It often happens that the memory that you want to view with an array is @@ -31,7 +31,7 @@ The bytes I have loaded from the file would have these contents: >>> big_end_buffer = bytearray([0,1,3,2]) >>> big_end_buffer -bytearray(b'\\x00\\x01\\x03\\x02') +bytearray(b'\x00\x01\x03\x02') We might want to use an ``ndarray`` to access these integers. In that case, we can create an array around this memory, and tell numpy that @@ -61,13 +61,15 @@ is also big-endian). However, sometimes you need to flip these around. .. warning:: - Scalars currently do not include byte order information, so extracting - a scalar from an array will return an integer in native byte order. - Hence: + Scalars do not include byte order information, so extracting a scalar from + an array will return an integer in native byte order. Hence: >>> big_end_arr[0].dtype.byteorder == little_end_u4[0].dtype.byteorder True + NumPy intentionally does not attempt to always preserve byte-order + and for example converts to native byte-order in `numpy.concatenate`. + Changing byte ordering ====================== diff --git a/doc/source/user/c-info.beyond-basics.rst b/doc/source/user/c-info.beyond-basics.rst index 7dd22afbf629..c566b4595c72 100644 --- a/doc/source/user/c-info.beyond-basics.rst +++ b/doc/source/user/c-info.beyond-basics.rst @@ -450,6 +450,7 @@ type(s). In particular, to create a sub-type in C follow these steps: More information on creating sub-types in C can be learned by reading PEP 253 (available at https://www.python.org/dev/peps/pep-0253). +.. _specific-array-subtyping: Specific features of ndarray sub-typing --------------------------------------- @@ -458,7 +459,7 @@ Some special methods and attributes are used by arrays in order to facilitate the interoperation of sub-types with the base ndarray type. The __array_finalize\__ method -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ .. attribute:: ndarray.__array_finalize__ @@ -469,13 +470,14 @@ The __array_finalize\__ method __new_\_ method nor the __init\__ method gets called. Instead, the sub-type is allocated and the appropriate instance-structure members are filled in. Finally, the :obj:`~numpy.class.__array_finalize__` - attribute is looked-up in the object dictionary. If it is present - and not None, then it can be either a CObject containing a pointer - to a :c:func:`PyArray_FinalizeFunc` or it can be a method taking a - single argument (which could be None) + attribute is looked-up in the object dictionary. If it is present and not + None, then it can be either a :c:type:`PyCapsule` containing a pointer to a + :c:func:`PyArray_FinalizeFunc` or it can be a method taking a single argument + (which could be None) - If the :obj:`~numpy.class.__array_finalize__` attribute is a CObject, then the pointer - must be a pointer to a function with the signature: + If the :obj:`~numpy.class.__array_finalize__` attribute is a + :c:type:`PyCapsule`, then the pointer must be a pointer to a function with + the signature: .. code-block:: c @@ -487,14 +489,14 @@ The __array_finalize\__ method is present). This routine can do anything it wants to. It should return a -1 on error and 0 otherwise. - If the :obj:`~numpy.class.__array_finalize__` attribute is not None nor a CObject, - then it must be a Python method that takes the parent array as an - argument (which could be None if there is no parent), and returns + If the :obj:`~numpy.class.__array_finalize__` attribute is not None nor a + :c:type:`PyCapsule`, then it must be a Python method that takes the parent + array as an argument (which could be None if there is no parent), and returns nothing. Errors in this method will be caught and handled. The __array_priority\__ attribute -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ .. attribute:: ndarray.__array_priority__ @@ -512,7 +514,7 @@ The __array_priority\__ attribute the return output. The __array_wrap\__ method -^^^^^^^^^^^^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~~~~~~~~~~~~ .. attribute:: ndarray.__array_wrap__ diff --git a/doc/source/user/c-info.how-to-extend.rst b/doc/source/user/c-info.how-to-extend.rst index 96727a177136..ffa141b95c83 100644 --- a/doc/source/user/c-info.how-to-extend.rst +++ b/doc/source/user/c-info.how-to-extend.rst @@ -111,7 +111,7 @@ Defining functions ================== The second argument passed in to the Py_InitModule function is a -structure that makes it easy to to define functions in the module. In +structure that makes it easy to define functions in the module. In the example given above, the mymethods structure would have been defined earlier in the file (usually right before the init{name} subroutine) to: @@ -459,9 +459,8 @@ writeable). The syntax is must be called before :c:func:`Py_DECREF` at the end of the interface routine to write back the temporary data into the original array passed in. Use - of the :c:data:`NPY_ARRAY_WRITEBACKIFCOPY` or - :c:data:`NPY_ARRAY_UPDATEIFCOPY` flags requires that the input - object is already an array (because other objects cannot + of the :c:data:`NPY_ARRAY_WRITEBACKIFCOPY` flag requires that the + input object is already an array (because other objects cannot be automatically updated in this fashion). If an error occurs use :c:func:`PyArray_DiscardWritebackIfCopy` (obj) on an array with these flags set. This will set the underlying base array diff --git a/doc/source/user/c-info.python-as-glue.rst b/doc/source/user/c-info.python-as-glue.rst index 6d514f146c4f..363099fe3a35 100644 --- a/doc/source/user/c-info.python-as-glue.rst +++ b/doc/source/user/c-info.python-as-glue.rst @@ -53,7 +53,7 @@ needs is to call out from Python code to a fast, machine-code routine relatively easy to do is a big reason why Python is such an excellent high-level language for scientific and engineering programming. -Their are two basic approaches to calling compiled code: writing an +There are two basic approaches to calling compiled code: writing an extension module that is then imported to Python using the import command, or calling a shared-library subroutine directly from Python using the `ctypes `_ @@ -97,7 +97,7 @@ control over how the C-library gets used and called which can lead to a lean and tight interface with minimal over-head. The disadvantage is that you have to write, debug, and maintain C-code, although most of it can be adapted using the time-honored technique of -"cutting-pasting-and-modifying" from other extension modules. Because, +"cutting-pasting-and-modifying" from other extension modules. Because the procedure of calling out to additional C-code is fairly regimented, code-generation procedures have been developed to make this process easier. One of these code-generation techniques is @@ -116,303 +116,7 @@ signatures for the subroutines it encounters, or you can guide how the subroutine interfaces with Python by constructing an interface-definition-file (or modifying the f2py-produced one). -.. index:: - single: f2py - -Creating source for a basic extension module --------------------------------------------- - -Probably the easiest way to introduce f2py is to offer a simple -example. Here is one of the subroutines contained in a file named -:file:`add.f` - -.. code-block:: fortran - - C - SUBROUTINE ZADD(A,B,C,N) - C - DOUBLE COMPLEX A(*) - DOUBLE COMPLEX B(*) - DOUBLE COMPLEX C(*) - INTEGER N - DO 20 J = 1, N - C(J) = A(J)+B(J) - 20 CONTINUE - END - -This routine simply adds the elements in two contiguous arrays and -places the result in a third. The memory for all three arrays must be -provided by the calling routine. A very basic interface to this -routine can be automatically generated by f2py:: - - f2py -m add add.f - -You should be able to run this command assuming your search-path is -set-up properly. This command will produce an extension module named -:file:`addmodule.c` in the current directory. This extension module can now be -compiled and used from Python just like any other extension module. - - -Creating a compiled extension module ------------------------------------- - -You can also get f2py to both compile :file:`add.f` along with the produced -extension module leaving only a shared-library extension file that can -be imported from Python:: - - f2py -c -m add add.f - -This command leaves a file named add.{ext} in the current directory -(where {ext} is the appropriate extension for a Python extension -module on your platform --- so, pyd, *etc.* ). This module may then be -imported from Python. It will contain a method for each subroutine in -add (zadd, cadd, dadd, sadd). The docstring of each method contains -information about how the module method may be called:: - - >>> import add - >>> print(add.zadd.__doc__) - zadd(a,b,c,n) - - Wrapper for ``zadd``. - - Parameters - ---------- - a : input rank-1 array('D') with bounds (*) - b : input rank-1 array('D') with bounds (*) - c : input rank-1 array('D') with bounds (*) - n : input int - -Improving the basic interface ------------------------------ - -The default interface is a very literal translation of the Fortran -code into Python. The Fortran array arguments must now be NumPy arrays -and the integer argument should be an integer. The interface will -attempt to convert all arguments to their required types (and shapes) -and issue an error if unsuccessful. However, because it knows nothing -about the semantics of the arguments (such that C is an output and n -should really match the array sizes), it is possible to abuse this -function in ways that can cause Python to crash. For example:: - - >>> add.zadd([1, 2, 3], [1, 2], [3, 4], 1000) - -will cause a program crash on most systems. Under the covers, the -lists are being converted to proper arrays but then the underlying add -loop is told to cycle way beyond the borders of the allocated memory. - -In order to improve the interface, directives should be provided. This -is accomplished by constructing an interface definition file. It is -usually best to start from the interface file that f2py can produce -(where it gets its default behavior from). To get f2py to generate the -interface file use the -h option:: - - f2py -h add.pyf -m add add.f - -This command leaves the file add.pyf in the current directory. The -section of this file corresponding to zadd is: - -.. code-block:: fortran - - subroutine zadd(a,b,c,n) ! in :add:add.f - double complex dimension(*) :: a - double complex dimension(*) :: b - double complex dimension(*) :: c - integer :: n - end subroutine zadd - -By placing intent directives and checking code, the interface can be -cleaned up quite a bit until the Python module method is both easier -to use and more robust. - -.. code-block:: fortran - - subroutine zadd(a,b,c,n) ! in :add:add.f - double complex dimension(n) :: a - double complex dimension(n) :: b - double complex intent(out),dimension(n) :: c - integer intent(hide),depend(a) :: n=len(a) - end subroutine zadd - -The intent directive, intent(out) is used to tell f2py that ``c`` is -an output variable and should be created by the interface before being -passed to the underlying code. The intent(hide) directive tells f2py -to not allow the user to specify the variable, ``n``, but instead to -get it from the size of ``a``. The depend( ``a`` ) directive is -necessary to tell f2py that the value of n depends on the input a (so -that it won't try to create the variable n until the variable a is -created). - -After modifying ``add.pyf``, the new Python module file can be generated -by compiling both ``add.f`` and ``add.pyf``:: - - f2py -c add.pyf add.f - -The new interface has docstring:: - - >>> import add - >>> print(add.zadd.__doc__) - c = zadd(a,b) - - Wrapper for ``zadd``. - - Parameters - ---------- - a : input rank-1 array('D') with bounds (n) - b : input rank-1 array('D') with bounds (n) - - Returns - ------- - c : rank-1 array('D') with bounds (n) - -Now, the function can be called in a much more robust way:: - - >>> add.zadd([1, 2, 3], [4, 5, 6]) - array([5.+0.j, 7.+0.j, 9.+0.j]) - -Notice the automatic conversion to the correct format that occurred. - - -Inserting directives in Fortran source --------------------------------------- - -The nice interface can also be generated automatically by placing the -variable directives as special comments in the original Fortran code. -Thus, if the source code is modified to contain: - -.. code-block:: fortran - - C - SUBROUTINE ZADD(A,B,C,N) - C - CF2PY INTENT(OUT) :: C - CF2PY INTENT(HIDE) :: N - CF2PY DOUBLE COMPLEX :: A(N) - CF2PY DOUBLE COMPLEX :: B(N) - CF2PY DOUBLE COMPLEX :: C(N) - DOUBLE COMPLEX A(*) - DOUBLE COMPLEX B(*) - DOUBLE COMPLEX C(*) - INTEGER N - DO 20 J = 1, N - C(J) = A(J) + B(J) - 20 CONTINUE - END - -Then, one can compile the extension module using:: - - f2py -c -m add add.f - -The resulting signature for the function add.zadd is exactly the same -one that was created previously. If the original source code had -contained ``A(N)`` instead of ``A(*)`` and so forth with ``B`` and ``C``, -then nearly the same interface can be obtained by placing the -``INTENT(OUT) :: C`` comment line in the source code. The only difference -is that ``N`` would be an optional input that would default to the length -of ``A``. - - -A filtering example -------------------- - -For comparison with the other methods to be discussed. Here is another -example of a function that filters a two-dimensional array of double -precision floating-point numbers using a fixed averaging filter. The -advantage of using Fortran to index into multi-dimensional arrays -should be clear from this example. - -.. code-block:: - - SUBROUTINE DFILTER2D(A,B,M,N) - C - DOUBLE PRECISION A(M,N) - DOUBLE PRECISION B(M,N) - INTEGER N, M - CF2PY INTENT(OUT) :: B - CF2PY INTENT(HIDE) :: N - CF2PY INTENT(HIDE) :: M - DO 20 I = 2,M-1 - DO 40 J=2,N-1 - B(I,J) = A(I,J) + - $ (A(I-1,J)+A(I+1,J) + - $ A(I,J-1)+A(I,J+1) )*0.5D0 + - $ (A(I-1,J-1) + A(I-1,J+1) + - $ A(I+1,J-1) + A(I+1,J+1))*0.25D0 - 40 CONTINUE - 20 CONTINUE - END - -This code can be compiled and linked into an extension module named -filter using:: - - f2py -c -m filter filter.f - -This will produce an extension module named filter.so in the current -directory with a method named dfilter2d that returns a filtered -version of the input. - - -Calling f2py from Python ------------------------- - -The f2py program is written in Python and can be run from inside your code -to compile Fortran code at runtime, as follows: - -.. code-block:: python - - from numpy import f2py - with open("add.f") as sourcefile: - sourcecode = sourcefile.read() - f2py.compile(sourcecode, modulename='add') - import add - -The source string can be any valid Fortran code. If you want to save -the extension-module source code then a suitable file-name can be -provided by the ``source_fn`` keyword to the compile function. - - -Automatic extension module generation -------------------------------------- - -If you want to distribute your f2py extension module, then you only -need to include the .pyf file and the Fortran code. The distutils -extensions in NumPy allow you to define an extension module entirely -in terms of this interface file. A valid ``setup.py`` file allowing -distribution of the ``add.f`` module (as part of the package -``f2py_examples`` so that it would be loaded as ``f2py_examples.add``) is: - -.. code-block:: python - - def configuration(parent_package='', top_path=None) - from numpy.distutils.misc_util import Configuration - config = Configuration('f2py_examples',parent_package, top_path) - config.add_extension('add', sources=['add.pyf','add.f']) - return config - - if __name__ == '__main__': - from numpy.distutils.core import setup - setup(**configuration(top_path='').todict()) - -Installation of the new package is easy using:: - - pip install . - -assuming you have the proper permissions to write to the main site- -packages directory for the version of Python you are using. For the -resulting package to work, you need to create a file named ``__init__.py`` -(in the same directory as ``add.pyf``). Notice the extension module is -defined entirely in terms of the ``add.pyf`` and ``add.f`` files. The -conversion of the .pyf file to a .c file is handled by `numpy.disutils`. - - -Conclusion ----------- - -The interface definition file (.pyf) is how you can fine-tune the interface -between Python and Fortran. There is decent documentation for f2py at -:ref:`f2py`. There is also more information on using f2py (including how to use -it to wrap C codes) at the `"Interfacing With Other Languages" heading of the -SciPy Cookbook. -`_ +See the :ref:`F2PY documentation ` for more information and examples. The f2py method of linking compiled code is currently the most sophisticated and integrated approach. It allows clean separation of diff --git a/doc/source/user/c-info.ufunc-tutorial.rst b/doc/source/user/c-info.ufunc-tutorial.rst index 9bd01b9639e7..47d306f8080c 100644 --- a/doc/source/user/c-info.ufunc-tutorial.rst +++ b/doc/source/user/c-info.ufunc-tutorial.rst @@ -71,11 +71,11 @@ Example Non-ufunc extension pair: ufunc; adding new For comparison and general edification of the reader we provide -a simple implementation of a C extension of logit that uses no +a simple implementation of a C extension of ``logit`` that uses no numpy. To do this we need two files. The first is the C file which contains -the actual code, and the second is the setup.py file used to create +the actual code, and the second is the ``setup.py`` file used to create the module. .. code-block:: c @@ -99,8 +99,7 @@ the module. /* This declares the logit function */ - static PyObject* spam_logit(PyObject *self, PyObject *args); - + static PyObject *spam_logit(PyObject *self, PyObject *args); /* * This tells Python what methods this module has. @@ -113,13 +112,12 @@ the module. {NULL, NULL, 0, NULL} }; - /* * This actually defines the logit function for * input args from Python. */ - static PyObject* spam_logit(PyObject *self, PyObject *args) + static PyObject *spam_logit(PyObject *self, PyObject *args) { double p; @@ -136,7 +134,6 @@ the module. return Py_BuildValue("d", p); } - /* This initiates the module using the above definitions. */ static struct PyModuleDef moduledef = { PyModuleDef_HEAD_INIT, @@ -160,10 +157,10 @@ the module. return m; } -To use the setup.py file, place setup.py and spammodule.c in the same -folder. Then python setup.py build will build the module to import, -or setup.py install will install the module to your site-packages -directory. +To use the ``setup.py file``, place ``setup.py`` and ``spammodule.c`` +in the same folder. Then ``python setup.py build`` will build the module to +import, or ``python setup.py install`` will install the module to your +site-packages directory. .. code-block:: python @@ -203,9 +200,9 @@ directory. Once the spam module is imported into python, you can call logit -via spam.logit. Note that the function used above cannot be applied -as-is to numpy arrays. To do so we must call numpy.vectorize on it. -For example, if a python interpreter is opened in the file containing +via ``spam.logit``. Note that the function used above cannot be applied +as-is to numpy arrays. To do so we must call :py:func:`numpy.vectorize` +on it. For example, if a python interpreter is opened in the file containing the spam library or spam has been installed, one can perform the following commands: @@ -225,10 +222,10 @@ TypeError: only length-1 arrays can be converted to Python scalars array([ -inf, -2.07944154, -1.25276297, -0.69314718, -0.22314355, 0.22314355, 0.69314718, 1.25276297, 2.07944154, inf]) -THE RESULTING LOGIT FUNCTION IS NOT FAST! numpy.vectorize simply -loops over spam.logit. The loop is done at the C level, but the numpy +THE RESULTING LOGIT FUNCTION IS NOT FAST! ``numpy.vectorize`` simply +loops over ``spam.logit``. The loop is done at the C level, but the numpy array is constantly being parsed and build back up. This is expensive. -When the author compared numpy.vectorize(spam.logit) against the +When the author compared ``numpy.vectorize(spam.logit)`` against the logit ufuncs constructed below, the logit ufuncs were almost exactly 4 times faster. Larger or smaller speedups are, of course, possible depending on the nature of the function. @@ -242,13 +239,14 @@ Example NumPy ufunc for one dtype .. index:: pair: ufunc; adding new -For simplicity we give a ufunc for a single dtype, the 'f8' double. -As in the previous section, we first give the .c file and then the -setup.py file used to create the module containing the ufunc. +For simplicity we give a ufunc for a single dtype, the ``'f8'`` +``double``. As in the previous section, we first give the ``.c`` file +and then the ``setup.py`` file used to create the module containing the +ufunc. The place in the code corresponding to the actual computations for -the ufunc are marked with /\*BEGIN main ufunc computation\*/ and -/\*END main ufunc computation\*/. The code in between those lines is +the ufunc are marked with ``/\* BEGIN main ufunc computation \*/`` and +``/\* END main ufunc computation \*/``. The code in between those lines is the primary thing that must be changed to create your own ufunc. .. code-block:: c @@ -277,13 +275,13 @@ the primary thing that must be changed to create your own ufunc. */ static PyMethodDef LogitMethods[] = { - {NULL, NULL, 0, NULL} + {NULL, NULL, 0, NULL} }; /* The loop definition must precede the PyMODINIT_FUNC. */ - static void double_logit(char **args, npy_intp *dimensions, - npy_intp* steps, void* data) + static void double_logit(char **args, const npy_intp *dimensions, + const npy_intp *steps, void *data) { npy_intp i; npy_intp n = dimensions[0]; @@ -293,25 +291,23 @@ the primary thing that must be changed to create your own ufunc. double tmp; for (i = 0; i < n; i++) { - /*BEGIN main ufunc computation*/ + /* BEGIN main ufunc computation */ tmp = *(double *)in; - tmp /= 1-tmp; + tmp /= 1 - tmp; *((double *)out) = log(tmp); - /*END main ufunc computation*/ + /* END main ufunc computation */ in += in_step; out += out_step; } } - /*This a pointer to the above function*/ + /* This a pointer to the above function */ PyUFuncGenericFunction funcs[1] = {&double_logit}; /* These are the input and return dtypes of logit.*/ static char types[2] = {NPY_DOUBLE, NPY_DOUBLE}; - static void *data[1] = {NULL}; - static struct PyModuleDef moduledef = { PyModuleDef_HEAD_INIT, "npufunc", @@ -327,15 +323,16 @@ the primary thing that must be changed to create your own ufunc. PyMODINIT_FUNC PyInit_npufunc(void) { PyObject *m, *logit, *d; + + import_array(); + import_umath(); + m = PyModule_Create(&moduledef); if (!m) { return NULL; } - import_array(); - import_umath(); - - logit = PyUFunc_FromFuncAndData(funcs, data, types, 1, 1, 1, + logit = PyUFunc_FromFuncAndData(funcs, NULL, types, 1, 1, 1, PyUFunc_None, "logit", "logit_docstring", 0); @@ -347,21 +344,23 @@ the primary thing that must be changed to create your own ufunc. return m; } -This is a setup.py file for the above code. As before, the module -can be build via calling python setup.py build at the command prompt, -or installed to site-packages via python setup.py install. +This is a ``setup.py file`` for the above code. As before, the module +can be build via calling ``python setup.py build`` at the command prompt, +or installed to site-packages via ``python setup.py install``. The module +can also be placed into a local folder e.g. ``npufunc_directory`` below +using ``python setup.py build_ext --inplace``. .. code-block:: python ''' - setup.py file for logit.c + setup.py file for single_type_logit.c Note that since this is a numpy extension we use numpy.distutils instead of distutils from the python standard library. Calling $python setup.py build_ext --inplace - will build the extension library in the current file. + will build the extension library in the npufunc_directory. Calling $python setup.py build @@ -382,7 +381,6 @@ or installed to site-packages via python setup.py install. def configuration(parent_package='', top_path=None): - import numpy from numpy.distutils.misc_util import Configuration config = Configuration('npufunc_directory', @@ -418,13 +416,13 @@ Example NumPy ufunc with multiple dtypes We finally give an example of a full ufunc, with inner loops for half-floats, floats, doubles, and long doubles. As in the previous -sections we first give the .c file and then the corresponding -setup.py file. +sections we first give the ``.c`` file and then the corresponding +``setup.py`` file. The places in the code corresponding to the actual computations for -the ufunc are marked with /\*BEGIN main ufunc computation\*/ and -/\*END main ufunc computation\*/. The code in between those lines is -the primary thing that must be changed to create your own ufunc. +the ufunc are marked with ``/\* BEGIN main ufunc computation \*/`` and +``/\* END main ufunc computation \*/``. The code in between those lines +is the primary thing that must be changed to create your own ufunc. .. code-block:: c @@ -455,37 +453,36 @@ the primary thing that must be changed to create your own ufunc. * */ - static PyMethodDef LogitMethods[] = { - {NULL, NULL, 0, NULL} + {NULL, NULL, 0, NULL} }; /* The loop definitions must precede the PyMODINIT_FUNC. */ - static void long_double_logit(char **args, npy_intp *dimensions, - npy_intp* steps, void* data) + static void long_double_logit(char **args, const npy_intp *dimensions, + const npy_intp *steps, void *data) { npy_intp i; npy_intp n = dimensions[0]; - char *in = args[0], *out=args[1]; + char *in = args[0], *out = args[1]; npy_intp in_step = steps[0], out_step = steps[1]; long double tmp; for (i = 0; i < n; i++) { - /*BEGIN main ufunc computation*/ + /* BEGIN main ufunc computation */ tmp = *(long double *)in; - tmp /= 1-tmp; + tmp /= 1 - tmp; *((long double *)out) = logl(tmp); - /*END main ufunc computation*/ + /* END main ufunc computation */ in += in_step; out += out_step; } } - static void double_logit(char **args, npy_intp *dimensions, - npy_intp* steps, void* data) + static void double_logit(char **args, const npy_intp *dimensions, + const npy_intp *steps, void *data) { npy_intp i; npy_intp n = dimensions[0]; @@ -495,33 +492,33 @@ the primary thing that must be changed to create your own ufunc. double tmp; for (i = 0; i < n; i++) { - /*BEGIN main ufunc computation*/ + /* BEGIN main ufunc computation */ tmp = *(double *)in; - tmp /= 1-tmp; + tmp /= 1 - tmp; *((double *)out) = log(tmp); - /*END main ufunc computation*/ + /* END main ufunc computation */ in += in_step; out += out_step; } } - static void float_logit(char **args, npy_intp *dimensions, - npy_intp* steps, void* data) + static void float_logit(char **args, const npy_intp *dimensions, + const npy_intp *steps, void *data) { npy_intp i; npy_intp n = dimensions[0]; - char *in=args[0], *out = args[1]; + char *in = args[0], *out = args[1]; npy_intp in_step = steps[0], out_step = steps[1]; float tmp; for (i = 0; i < n; i++) { - /*BEGIN main ufunc computation*/ + /* BEGIN main ufunc computation */ tmp = *(float *)in; - tmp /= 1-tmp; + tmp /= 1 - tmp; *((float *)out) = logf(tmp); - /*END main ufunc computation*/ + /* END main ufunc computation */ in += in_step; out += out_step; @@ -529,8 +526,8 @@ the primary thing that must be changed to create your own ufunc. } - static void half_float_logit(char **args, npy_intp *dimensions, - npy_intp* steps, void* data) + static void half_float_logit(char **args, const npy_intp *dimensions, + const npy_intp *steps, void *data) { npy_intp i; npy_intp n = dimensions[0]; @@ -541,13 +538,12 @@ the primary thing that must be changed to create your own ufunc. for (i = 0; i < n; i++) { - /*BEGIN main ufunc computation*/ - tmp = *(npy_half *)in; - tmp = npy_half_to_float(tmp); - tmp /= 1-tmp; + /* BEGIN main ufunc computation */ + tmp = npy_half_to_float(*(npy_half *)in); + tmp /= 1 - tmp; tmp = logf(tmp); *((npy_half *)out) = npy_float_to_half(tmp); - /*END main ufunc computation*/ + /* END main ufunc computation */ in += in_step; out += out_step; @@ -562,10 +558,9 @@ the primary thing that must be changed to create your own ufunc. &long_double_logit}; static char types[8] = {NPY_HALF, NPY_HALF, - NPY_FLOAT, NPY_FLOAT, - NPY_DOUBLE,NPY_DOUBLE, - NPY_LONGDOUBLE, NPY_LONGDOUBLE}; - static void *data[4] = {NULL, NULL, NULL, NULL}; + NPY_FLOAT, NPY_FLOAT, + NPY_DOUBLE, NPY_DOUBLE, + NPY_LONGDOUBLE, NPY_LONGDOUBLE}; static struct PyModuleDef moduledef = { PyModuleDef_HEAD_INIT, @@ -582,15 +577,16 @@ the primary thing that must be changed to create your own ufunc. PyMODINIT_FUNC PyInit_npufunc(void) { PyObject *m, *logit, *d; + + import_array(); + import_umath(); + m = PyModule_Create(&moduledef); if (!m) { return NULL; } - import_array(); - import_umath(); - - logit = PyUFunc_FromFuncAndData(funcs, data, types, 4, 1, 1, + logit = PyUFunc_FromFuncAndData(funcs, NULL, types, 4, 1, 1, PyUFunc_None, "logit", "logit_docstring", 0); @@ -602,14 +598,14 @@ the primary thing that must be changed to create your own ufunc. return m; } -This is a setup.py file for the above code. As before, the module -can be build via calling python setup.py build at the command prompt, -or installed to site-packages via python setup.py install. +This is a ``setup.py`` file for the above code. As before, the module +can be build via calling ``python setup.py build`` at the command prompt, +or installed to site-packages via ``python setup.py install``. .. code-block:: python ''' - setup.py file for logit.c + setup.py file for multi_type_logit.c Note that since this is a numpy extension we use numpy.distutils instead of distutils from the python standard library. @@ -637,9 +633,7 @@ or installed to site-packages via python setup.py install. def configuration(parent_package='', top_path=None): - import numpy - from numpy.distutils.misc_util import Configuration - from numpy.distutils.misc_util import get_info + from numpy.distutils.misc_util import Configuration, get_info #Necessary for the half-float d-type. info = get_info('npymath') @@ -676,10 +670,10 @@ Example NumPy ufunc with multiple arguments/return values Our final example is a ufunc with multiple arguments. It is a modification of the code for a logit ufunc for data with a single dtype. We -compute (A*B, logit(A*B)). +compute ``(A * B, logit(A * B))``. We only give the C code as the setup.py file is exactly the same as -the setup.py file in `Example NumPy ufunc for one dtype`_, except that +the ``setup.py`` file in `Example NumPy ufunc for one dtype`_, except that the line .. code-block:: python @@ -692,9 +686,9 @@ is replaced with config.add_extension('npufunc', ['multi_arg_logit.c']) -The C file is given below. The ufunc generated takes two arguments A -and B. It returns a tuple whose first element is A*B and whose second -element is logit(A*B). Note that it automatically supports broadcasting, +The C file is given below. The ufunc generated takes two arguments ``A`` +and ``B``. It returns a tuple whose first element is ``A * B`` and whose second +element is ``logit(A * B)``. Note that it automatically supports broadcasting, as well as all other properties of a ufunc. .. code-block:: c @@ -716,19 +710,17 @@ as well as all other properties of a ufunc. * * Details explaining the Python-C API can be found under * 'Extending and Embedding' and 'Python/C API' at - * docs.python.org . - * + * docs.python.org. */ - static PyMethodDef LogitMethods[] = { - {NULL, NULL, 0, NULL} + {NULL, NULL, 0, NULL} }; /* The loop definition must precede the PyMODINIT_FUNC. */ - static void double_logitprod(char **args, npy_intp *dimensions, - npy_intp* steps, void* data) + static void double_logitprod(char **args, const npy_intp *dimensions, + const npy_intp *steps, void *data) { npy_intp i; npy_intp n = dimensions[0]; @@ -740,12 +732,12 @@ as well as all other properties of a ufunc. double tmp; for (i = 0; i < n; i++) { - /*BEGIN main ufunc computation*/ + /* BEGIN main ufunc computation */ tmp = *(double *)in1; tmp *= *(double *)in2; *((double *)out1) = tmp; - *((double *)out2) = log(tmp/(1-tmp)); - /*END main ufunc computation*/ + *((double *)out2) = log(tmp / (1 - tmp)); + /* END main ufunc computation */ in1 += in1_step; in2 += in2_step; @@ -754,7 +746,6 @@ as well as all other properties of a ufunc. } } - /*This a pointer to the above function*/ PyUFuncGenericFunction funcs[1] = {&double_logitprod}; @@ -763,9 +754,6 @@ as well as all other properties of a ufunc. static char types[4] = {NPY_DOUBLE, NPY_DOUBLE, NPY_DOUBLE, NPY_DOUBLE}; - - static void *data[1] = {NULL}; - static struct PyModuleDef moduledef = { PyModuleDef_HEAD_INIT, "npufunc", @@ -781,15 +769,16 @@ as well as all other properties of a ufunc. PyMODINIT_FUNC PyInit_npufunc(void) { PyObject *m, *logit, *d; + + import_array(); + import_umath(); + m = PyModule_Create(&moduledef); if (!m) { return NULL; } - import_array(); - import_umath(); - - logit = PyUFunc_FromFuncAndData(funcs, data, types, 1, 2, 2, + logit = PyUFunc_FromFuncAndData(funcs, NULL, types, 1, 2, 2, PyUFunc_None, "logit", "logit_docstring", 0); @@ -809,13 +798,13 @@ Example NumPy ufunc with structured array dtype arguments This example shows how to create a ufunc for a structured array dtype. For the example we show a trivial ufunc for adding two arrays with dtype -'u8,u8,u8'. The process is a bit different from the other examples since +``'u8,u8,u8'``. The process is a bit different from the other examples since a call to :c:func:`PyUFunc_FromFuncAndData` doesn't fully register ufuncs for custom dtypes and structured array dtypes. We need to also call :c:func:`PyUFunc_RegisterLoopForDescr` to finish setting up the ufunc. -We only give the C code as the setup.py file is exactly the same as -the setup.py file in `Example NumPy ufunc for one dtype`_, except that +We only give the C code as the ``setup.py`` file is exactly the same as +the ``setup.py`` file in `Example NumPy ufunc for one dtype`_, except that the line .. code-block:: python @@ -839,7 +828,6 @@ The C file is given below. #include "numpy/npy_3kcompat.h" #include - /* * add_triplet.c * This is the C code for creating your own @@ -847,7 +835,7 @@ The C file is given below. * * Details explaining the Python-C API can be found under * 'Extending and Embedding' and 'Python/C API' at - * docs.python.org . + * docs.python.org. */ static PyMethodDef StructUfuncTestMethods[] = { @@ -856,25 +844,25 @@ The C file is given below. /* The loop definition must precede the PyMODINIT_FUNC. */ - static void add_uint64_triplet(char **args, npy_intp *dimensions, - npy_intp* steps, void* data) + static void add_uint64_triplet(char **args, const npy_intp *dimensions, + const npy_intp *steps, void *data) { npy_intp i; - npy_intp is1=steps[0]; - npy_intp is2=steps[1]; - npy_intp os=steps[2]; - npy_intp n=dimensions[0]; + npy_intp is1 = steps[0]; + npy_intp is2 = steps[1]; + npy_intp os = steps[2]; + npy_intp n = dimensions[0]; uint64_t *x, *y, *z; - char *i1=args[0]; - char *i2=args[1]; - char *op=args[2]; + char *i1 = args[0]; + char *i2 = args[1]; + char *op = args[2]; for (i = 0; i < n; i++) { - x = (uint64_t*)i1; - y = (uint64_t*)i2; - z = (uint64_t*)op; + x = (uint64_t *)i1; + y = (uint64_t *)i2; + z = (uint64_t *)op; z[0] = x[0] + y[0]; z[1] = x[1] + y[1]; @@ -892,8 +880,6 @@ The C file is given below. /* These are the input and return dtypes of add_uint64_triplet. */ static char types[3] = {NPY_UINT64, NPY_UINT64, NPY_UINT64}; - static void *data[1] = {NULL}; - static struct PyModuleDef moduledef = { PyModuleDef_HEAD_INIT, "struct_ufunc_test", @@ -913,22 +899,21 @@ The C file is given below. PyArray_Descr *dtype; PyArray_Descr *dtypes[3]; - m = PyModule_Create(&moduledef); + import_array(); + import_umath(); + m = PyModule_Create(&moduledef); if (m == NULL) { return NULL; } - import_array(); - import_umath(); - /* Create a new ufunc object */ add_triplet = PyUFunc_FromFuncAndData(NULL, NULL, NULL, 0, 2, 1, - PyUFunc_None, "add_triplet", - "add_triplet_docstring", 0); + PyUFunc_None, "add_triplet", + "add_triplet_docstring", 0); dtype_dict = Py_BuildValue("[(s, s), (s, s), (s, s)]", - "f0", "u8", "f1", "u8", "f2", "u8"); + "f0", "u8", "f1", "u8", "f2", "u8"); PyArray_DescrConverter(dtype_dict, &dtype); Py_DECREF(dtype_dict); @@ -938,10 +923,10 @@ The C file is given below. /* Register ufunc for structured dtype */ PyUFunc_RegisterLoopForDescr(add_triplet, - dtype, - &add_uint64_triplet, - dtypes, - NULL); + dtype, + &add_uint64_triplet, + dtypes, + NULL); d = PyModule_GetDict(m); @@ -963,9 +948,9 @@ adapted from the umath module static PyUFuncGenericFunction atan2_functions[] = { PyUFunc_ff_f, PyUFunc_dd_d, PyUFunc_gg_g, PyUFunc_OO_O_method}; - static void* atan2_data[] = { - (void *)atan2f,(void *) atan2, - (void *)atan2l,(void *)"arctan2"}; + static void *atan2_data[] = { + (void *)atan2f, (void *)atan2, + (void *)atan2l, (void *)"arctan2"}; static char atan2_signatures[] = { NPY_FLOAT, NPY_FLOAT, NPY_FLOAT, NPY_DOUBLE, NPY_DOUBLE, NPY_DOUBLE, diff --git a/doc/source/user/how-to-how-to.rst b/doc/source/user/how-to-how-to.rst index cdf1ad5c3adf..b99efdb1f422 100644 --- a/doc/source/user/how-to-how-to.rst +++ b/doc/source/user/how-to-how-to.rst @@ -105,7 +105,7 @@ deep dives intended to give understanding rather than immediate assistance, and `References`, which give complete, authoritative data on some concrete part of NumPy (like its API) but aren't obligated to paint a broader picture. -For more on tutorials, see :doc:`content/tutorial-style-guide` +For more on tutorials, see :doc:`numpy-tutorials:content/tutorial-style-guide` ****************************************************************************** Is this page an example of a how-to? diff --git a/doc/source/user/how-to-index.rst b/doc/source/user/how-to-index.rst new file mode 100644 index 000000000000..e47e9a2042fc --- /dev/null +++ b/doc/source/user/how-to-index.rst @@ -0,0 +1,351 @@ +.. currentmodule:: numpy + +.. _how-to-index: + +***************************************** +How to index :class:`ndarrays <.ndarray>` +***************************************** + +.. seealso:: :ref:`basics.indexing` + +This page tackles common examples. For an in-depth look into indexing, refer +to :ref:`basics.indexing`. + +Access specific/arbitrary rows and columns +========================================== + +Use :ref:`basic-indexing` features like :ref:`slicing-and-striding`, and +:ref:`dimensional-indexing-tools`. + + >>> a = np.arange(30).reshape(2, 3, 5) + >>> a + array([[[ 0, 1, 2, 3, 4], + [ 5, 6, 7, 8, 9], + [10, 11, 12, 13, 14]], + + [[15, 16, 17, 18, 19], + [20, 21, 22, 23, 24], + [25, 26, 27, 28, 29]]]) + >>> a[0, 2, :] + array([10, 11, 12, 13, 14]) + >>> a[0, :, 3] + array([ 3, 8, 13]) + +Note that the output from indexing operations can have different shape from the +original object. To preserve the original dimensions after indexing, you can +use :func:`newaxis`. To use other such tools, refer to +:ref:`dimensional-indexing-tools`. + + >>> a[0, :, 3].shape + (3,) + >>> a[0, :, 3, np.newaxis].shape + (3, 1) + >>> a[0, :, 3, np.newaxis, np.newaxis].shape + (3, 1, 1) + +Variables can also be used to index:: + + >>> y = 0 + >>> a[y, :, y+3] + array([ 3, 8, 13]) + +Refer to :ref:`dealing-with-variable-indices` to see how to use +:term:`python:slice` and :py:data:`Ellipsis` in your index variables. + +Index columns +------------- + +To index columns, you have to index the last axis. Use +:ref:`dimensional-indexing-tools` to get the desired number of dimensions:: + + >>> a = np.arange(24).reshape(2, 3, 4) + >>> a + array([[[ 0, 1, 2, 3], + [ 4, 5, 6, 7], + [ 8, 9, 10, 11]], + + [[12, 13, 14, 15], + [16, 17, 18, 19], + [20, 21, 22, 23]]]) + >>> a[..., 3] + array([[ 3, 7, 11], + [15, 19, 23]]) + +To index specific elements in each column, make use of :ref:`advanced-indexing` +as below:: + + >>> arr = np.arange(3*4).reshape(3, 4) + >>> arr + array([[ 0, 1, 2, 3], + [ 4, 5, 6, 7], + [ 8, 9, 10, 11]]) + >>> column_indices = [[1, 3], [0, 2], [2, 2]] + >>> np.arange(arr.shape[0]) + array([0, 1, 2]) + >>> row_indices = np.arange(arr.shape[0])[:, np.newaxis] + >>> row_indices + array([[0], + [1], + [2]]) + +Use the ``row_indices`` and ``column_indices`` for advanced +indexing:: + + >>> arr[row_indices, column_indices] + array([[ 1, 3], + [ 4, 6], + [10, 10]]) + +Index along a specific axis +--------------------------- + +Use :meth:`take`. See also :meth:`take_along_axis` and +:meth:`put_along_axis`. + + >>> a = np.arange(30).reshape(2, 3, 5) + >>> a + array([[[ 0, 1, 2, 3, 4], + [ 5, 6, 7, 8, 9], + [10, 11, 12, 13, 14]], + + [[15, 16, 17, 18, 19], + [20, 21, 22, 23, 24], + [25, 26, 27, 28, 29]]]) + >>> np.take(a, [2, 3], axis=2) + array([[[ 2, 3], + [ 7, 8], + [12, 13]], + + [[17, 18], + [22, 23], + [27, 28]]]) + >>> np.take(a, [2], axis=1) + array([[[10, 11, 12, 13, 14]], + + [[25, 26, 27, 28, 29]]]) + +Create subsets of larger matrices +================================= + +Use :ref:`slicing-and-striding` to access chunks of a large array:: + + >>> a = np.arange(100).reshape(10, 10) + >>> a + array([[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9], + [10, 11, 12, 13, 14, 15, 16, 17, 18, 19], + [20, 21, 22, 23, 24, 25, 26, 27, 28, 29], + [30, 31, 32, 33, 34, 35, 36, 37, 38, 39], + [40, 41, 42, 43, 44, 45, 46, 47, 48, 49], + [50, 51, 52, 53, 54, 55, 56, 57, 58, 59], + [60, 61, 62, 63, 64, 65, 66, 67, 68, 69], + [70, 71, 72, 73, 74, 75, 76, 77, 78, 79], + [80, 81, 82, 83, 84, 85, 86, 87, 88, 89], + [90, 91, 92, 93, 94, 95, 96, 97, 98, 99]]) + >>> a[2:5, 2:5] + array([[22, 23, 24], + [32, 33, 34], + [42, 43, 44]]) + >>> a[2:5, 1:3] + array([[21, 22], + [31, 32], + [41, 42]]) + >>> a[:5, :5] + array([[ 0, 1, 2, 3, 4], + [10, 11, 12, 13, 14], + [20, 21, 22, 23, 24], + [30, 31, 32, 33, 34], + [40, 41, 42, 43, 44]]) + +The same thing can be done with advanced indexing in a slightly more complex +way. Remember that +:ref:`advanced indexing creates a copy `:: + + >>> a[np.arange(5)[:, None], np.arange(5)[None, :]] + array([[ 0, 1, 2, 3, 4], + [10, 11, 12, 13, 14], + [20, 21, 22, 23, 24], + [30, 31, 32, 33, 34], + [40, 41, 42, 43, 44]]) + +You can also use :meth:`mgrid` to generate indices:: + + >>> indices = np.mgrid[0:6:2] + >>> indices + array([0, 2, 4]) + >>> a[:, indices] + array([[ 0, 2, 4], + [10, 12, 14], + [20, 22, 24], + [30, 32, 34], + [40, 42, 44], + [50, 52, 54], + [60, 62, 64], + [70, 72, 74], + [80, 82, 84], + [90, 92, 94]]) + +Filter values +============= + +Non-zero elements +----------------- + +Use :meth:`nonzero` to get a tuple of array indices of non-zero elements +corresponding to every dimension:: + + >>> z = np.array([[1, 2, 3, 0], [0, 0, 5, 3], [4, 6, 0, 0]]) + >>> z + array([[1, 2, 3, 0], + [0, 0, 5, 3], + [4, 6, 0, 0]]) + >>> np.nonzero(z) + (array([0, 0, 0, 1, 1, 2, 2]), array([0, 1, 2, 2, 3, 0, 1])) + +Use :meth:`flatnonzero` to fetch indices of elements that are non-zero in +the flattened version of the ndarray:: + + >>> np.flatnonzero(z) + array([0, 1, 2, 6, 7, 8, 9]) + +Arbitrary conditions +-------------------- + +Use :meth:`where` to generate indices based on conditions and then +use :ref:`advanced-indexing`. + + >>> a = np.arange(30).reshape(2, 3, 5) + >>> indices = np.where(a % 2 == 0) + >>> indices + (array([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1]), + array([0, 0, 0, 1, 1, 2, 2, 2, 0, 0, 1, 1, 1, 2, 2]), + array([0, 2, 4, 1, 3, 0, 2, 4, 1, 3, 0, 2, 4, 1, 3])) + >>> a[indices] + array([ 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]) + +Or, use :ref:`boolean-indexing`:: + + >>> a > 14 + array([[[False, False, False, False, False], + [False, False, False, False, False], + [False, False, False, False, False]], + + [[ True, True, True, True, True], + [ True, True, True, True, True], + [ True, True, True, True, True]]]) + >>> a[a > 14] + array([15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]) + +Replace values after filtering +------------------------------ + +Use assignment with filtering to replace desired values:: + + >>> p = np.arange(-10, 10).reshape(2, 2, 5) + >>> p + array([[[-10, -9, -8, -7, -6], + [ -5, -4, -3, -2, -1]], + + [[ 0, 1, 2, 3, 4], + [ 5, 6, 7, 8, 9]]]) + >>> q = p < 0 + >>> q + array([[[ True, True, True, True, True], + [ True, True, True, True, True]], + + [[False, False, False, False, False], + [False, False, False, False, False]]]) + >>> p[q] = 0 + >>> p + array([[[0, 0, 0, 0, 0], + [0, 0, 0, 0, 0]], + + [[0, 1, 2, 3, 4], + [5, 6, 7, 8, 9]]]) + +Fetch indices of max/min values +=============================== + +Use :meth:`argmax` and :meth:`argmin`:: + + >>> a = np.arange(30).reshape(2, 3, 5) + >>> np.argmax(a) + 29 + >>> np.argmin(a) + 0 + +Use the ``axis`` keyword to get the indices of maximum and minimum +values along a specific axis:: + + >>> np.argmax(a, axis=0) + array([[1, 1, 1, 1, 1], + [1, 1, 1, 1, 1], + [1, 1, 1, 1, 1]]) + >>> np.argmax(a, axis=1) + array([[2, 2, 2, 2, 2], + [2, 2, 2, 2, 2]]) + >>> np.argmax(a, axis=2) + array([[4, 4, 4], + [4, 4, 4]]) + + >>> np.argmin(a, axis=1) + array([[0, 0, 0, 0, 0], + [0, 0, 0, 0, 0]]) + >>> np.argmin(a, axis=2) + array([[0, 0, 0], + [0, 0, 0]]) + +Set ``keepdims`` to ``True`` to keep the axes which are reduced in the +result as dimensions with size one:: + + >>> np.argmin(a, axis=2, keepdims=True) + array([[[0], + [0], + [0]], + + [[0], + [0], + [0]]]) + >>> np.argmax(a, axis=1, keepdims=True) + array([[[2, 2, 2, 2, 2]], + + [[2, 2, 2, 2, 2]]]) + +Index the same ndarray multiple times efficiently +================================================= + +It must be kept in mind that basic indexing produces :term:`views ` +and advanced indexing produces :term:`copies `, which are +computationally less efficient. Hence, you should take care to use basic +indexing wherever possible instead of advanced indexing. + +Further reading +=============== + +Nicolas Rougier's `100 NumPy exercises `_ +provide a good insight into how indexing is combined with other operations. +Exercises `6`_, `8`_, `10`_, `15`_, `16`_, `19`_, `20`_, `45`_, `59`_, +`64`_, `65`_, `70`_, `71`_, `72`_, `76`_, `80`_, `81`_, `84`_, `87`_, `90`_, +`93`_, `94`_ are specially focused on indexing. + +.. _6: https://github.com/rougier/numpy-100/blob/master/100_Numpy_exercises_with_solutions.md#6-create-a-null-vector-of-size-10-but-the-fifth-value-which-is-1- +.. _8: https://github.com/rougier/numpy-100/blob/master/100_Numpy_exercises_with_solutions.md#8-reverse-a-vector-first-element-becomes-last- +.. _10: https://github.com/rougier/numpy-100/blob/master/100_Numpy_exercises_with_solutions.md#10-find-indices-of-non-zero-elements-from-120040- +.. _15: https://github.com/rougier/numpy-100/blob/master/100_Numpy_exercises_with_solutions.md#15-create-a-2d-array-with-1-on-the-border-and-0-inside- +.. _16: https://github.com/rougier/numpy-100/blob/master/100_Numpy_exercises_with_solutions.md#16-how-to-add-a-border-filled-with-0s-around-an-existing-array- +.. _19: https://github.com/rougier/numpy-100/blob/master/100_Numpy_exercises_with_solutions.md#19-create-a-8x8-matrix-and-fill-it-with-a-checkerboard-pattern- +.. _20: https://github.com/rougier/numpy-100/blob/master/100_Numpy_exercises_with_solutions.md#20-consider-a-678-shape-array-what-is-the-index-xyz-of-the-100th-element- +.. _45: https://github.com/rougier/numpy-100/blob/master/100_Numpy_exercises_with_solutions.md#45-create-random-vector-of-size-10-and-replace-the-maximum-value-by-0- +.. _59: https://github.com/rougier/numpy-100/blob/master/100_Numpy_exercises_with_solutions.md#59-how-to-sort-an-array-by-the-nth-column- +.. _64: https://github.com/rougier/numpy-100/blob/master/100_Numpy_exercises_with_solutions.md#64-consider-a-given-vector-how-to-add-1-to-each-element-indexed-by-a-second-vector-be-careful-with-repeated-indices- +.. _65: https://github.com/rougier/numpy-100/blob/master/100_Numpy_exercises_with_solutions.md#65-how-to-accumulate-elements-of-a-vector-x-to-an-array-f-based-on-an-index-list-i- +.. _70: https://github.com/rougier/numpy-100/blob/master/100_Numpy_exercises_with_solutions.md#70-consider-the-vector-1-2-3-4-5-how-to-build-a-new-vector-with-3-consecutive-zeros-interleaved-between-each-value- +.. _71: https://github.com/rougier/numpy-100/blob/master/100_Numpy_exercises_with_solutions.md#71-consider-an-array-of-dimension-553-how-to-mulitply-it-by-an-array-with-dimensions-55- +.. _72: https://github.com/rougier/numpy-100/blob/master/100_Numpy_exercises_with_solutions.md#72-how-to-swap-two-rows-of-an-array- +.. _76: https://github.com/rougier/numpy-100/blob/master/100_Numpy_exercises_with_solutions.md#76-consider-a-one-dimensional-array-z-build-a-two-dimensional-array-whose-first-row-is-z0z1z2-and-each-subsequent-row-is--shifted-by-1-last-row-should-be-z-3z-2z-1- +.. _80: https://github.com/rougier/numpy-100/blob/master/100_Numpy_exercises_with_solutions.md#80-consider-an-arbitrary-array-write-a-function-that-extract-a-subpart-with-a-fixed-shape-and-centered-on-a-given-element-pad-with-a-fill-value-when-necessary- +.. _81: https://github.com/rougier/numpy-100/blob/master/100_Numpy_exercises_with_solutions.md#81-consider-an-array-z--1234567891011121314-how-to-generate-an-array-r--1234-2345-3456--11121314- +.. _84: https://github.com/rougier/numpy-100/blob/master/100_Numpy_exercises_with_solutions.md#84-extract-all-the-contiguous-3x3-blocks-from-a-random-10x10-matrix- +.. _87: https://github.com/rougier/numpy-100/blob/master/100_Numpy_exercises_with_solutions.md#87-consider-a-16x16-array-how-to-get-the-block-sum-block-size-is-4x4- +.. _90: https://github.com/rougier/numpy-100/blob/master/100_Numpy_exercises_with_solutions.md#90-given-an-arbitrary-number-of-vectors-build-the-cartesian-product-every-combinations-of-every-item- +.. _93: https://github.com/rougier/numpy-100/blob/master/100_Numpy_exercises_with_solutions.md#93-consider-two-arrays-a-and-b-of-shape-83-and-22-how-to-find-rows-of-a-that-contain-elements-of-each-row-of-b-regardless-of-the-order-of-the-elements-in-b- +.. _94: https://github.com/rougier/numpy-100/blob/master/100_Numpy_exercises_with_solutions.md#94-considering-a-10x3-matrix-extract-rows-with-unequal-values-eg-223- \ No newline at end of file diff --git a/doc/source/user/how-to-io.rst b/doc/source/user/how-to-io.rst index d238ccbb605e..6a4127e8f00a 100644 --- a/doc/source/user/how-to-io.rst +++ b/doc/source/user/how-to-io.rst @@ -1,26 +1,43 @@ .. _how-to-io: -############################################################################## -Reading and writing files -############################################################################## +.. Setting up files temporarily to be used in the examples below. Clear-up + has to be done at the end of the document. + +.. testsetup:: + + >>> from numpy.testing import temppath + >>> with open("csv.txt", "wt") as f: + ... _ = f.write("1, 2, 3\n4,, 6\n7, 8, 9") + >>> with open("fixedwidth.txt", "wt") as f: + ... _ = f.write("1 2 3\n44 6\n7 88889") + >>> with open("nan.txt", "wt") as f: + ... _ = f.write("1 2 3\n44 x 6\n7 8888 9") + >>> with open("skip.txt", "wt") as f: + ... _ = f.write("1 2 3\n44 6\n7 888 9") + >>> with open("tabs.txt", "wt") as f: + ... _ = f.write("1\t2\t3\n44\t \t6\n7\t888\t9") + + +=========================== + Reading and writing files +=========================== This page tackles common applications; for the full collection of I/O routines, see :ref:`routines.io`. -****************************************************************************** Reading text and CSV_ files -****************************************************************************** +=========================== .. _CSV: https://en.wikipedia.org/wiki/Comma-separated_values With no missing values -============================================================================== +---------------------- Use :func:`numpy.loadtxt`. With missing values -============================================================================== +------------------- Use :func:`numpy.genfromtxt`. @@ -33,20 +50,20 @@ Use :func:`numpy.genfromtxt`. ``filling_values`` (default is ``np.nan`` for float, -1 for int). With non-whitespace delimiters ------------------------------------------------------------------------------- -:: +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - >>> print(open("csv.txt").read()) # doctest: +SKIP + + >>> with open("csv.txt", "r") as f: + ... print(f.read()) 1, 2, 3 4,, 6 7, 8, 9 Masked-array output -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -:: ++++++++++++++++++++ - >>> np.genfromtxt("csv.txt", delimiter=",", usemask=True) # doctest: +SKIP + >>> np.genfromtxt("csv.txt", delimiter=",", usemask=True) masked_array( data=[[1.0, 2.0, 3.0], [4.0, --, 6.0], @@ -57,73 +74,72 @@ Masked-array output fill_value=1e+20) Array output -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -:: +++++++++++++ - >>> np.genfromtxt("csv.txt", delimiter=",") # doctest: +SKIP + >>> np.genfromtxt("csv.txt", delimiter=",") array([[ 1., 2., 3.], [ 4., nan, 6.], [ 7., 8., 9.]]) Array output, specified fill-in value -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -:: ++++++++++++++++++++++++++++++++++++++ + - >>> np.genfromtxt("csv.txt", delimiter=",", dtype=np.int8, filling_values=99) # doctest: +SKIP + >>> np.genfromtxt("csv.txt", delimiter=",", dtype=np.int8, filling_values=99) array([[ 1, 2, 3], [ 4, 99, 6], [ 7, 8, 9]], dtype=int8) Whitespace-delimited -------------------------------------------------------------------------------- +~~~~~~~~~~~~~~~~~~~~ :func:`numpy.genfromtxt` can also parse whitespace-delimited data files that have missing values if * **Each field has a fixed width**: Use the width as the `delimiter` argument. - :: # File with width=4. The data does not have to be justified (for example, # the 2 in row 1), the last column can be less than width (for example, the 6 # in row 2), and no delimiting character is required (for instance 8888 and 9 # in row 3) - >>> f = open("fixedwidth.txt").read() # doctest: +SKIP - >>> print(f) # doctest: +SKIP + >>> with open("fixedwidth.txt", "r") as f: + ... data = (f.read()) + >>> print(data) 1 2 3 44 6 7 88889 # Showing spaces as ^ - >>> print(f.replace(" ","^")) # doctest: +SKIP + >>> print(data.replace(" ","^")) 1^^^2^^^^^^3 44^^^^^^6 7^^^88889 - >>> np.genfromtxt("fixedwidth.txt", delimiter=4) # doctest: +SKIP + >>> np.genfromtxt("fixedwidth.txt", delimiter=4) array([[1.000e+00, 2.000e+00, 3.000e+00], [4.400e+01, nan, 6.000e+00], [7.000e+00, 8.888e+03, 9.000e+00]]) * **A special value (e.g. "x") indicates a missing field**: Use it as the `missing_values` argument. - :: - >>> print(open("nan.txt").read()) # doctest: +SKIP + >>> with open("nan.txt", "r") as f: + ... print(f.read()) 1 2 3 44 x 6 7 8888 9 - >>> np.genfromtxt("nan.txt", missing_values="x") # doctest: +SKIP + >>> np.genfromtxt("nan.txt", missing_values="x") array([[1.000e+00, 2.000e+00, 3.000e+00], [4.400e+01, nan, 6.000e+00], [7.000e+00, 8.888e+03, 9.000e+00]]) * **You want to skip the rows with missing values**: Set `invalid_raise=False`. - :: - >>> print(open("skip.txt").read()) # doctest: +SKIP + >>> with open("skip.txt", "r") as f: + ... print(f.read()) 1 2 3 44 6 7 888 9 @@ -139,28 +155,27 @@ that have missing values if indicates missing data**. For instance, if columns are delimited by ``\t``, then missing data will be recognized if it consists of one or more spaces. - :: - >>> f = open("tabs.txt").read() # doctest: +SKIP - >>> print(f) # doctest: +SKIP + >>> with open("tabs.txt", "r") as f: + ... data = (f.read()) + >>> print(data) 1 2 3 44 6 7 888 9 # Tabs vs. spaces - >>> print(f.replace("\t","^")) # doctest: +SKIP + >>> print(data.replace("\t","^")) 1^2^3 44^ ^6 7^888^9 - >>> np.genfromtxt("tabs.txt", delimiter="\t", missing_values=" +") # doctest: +SKIP + >>> np.genfromtxt("tabs.txt", delimiter="\t", missing_values=" +") array([[ 1., 2., 3.], [ 44., nan, 6.], [ 7., 888., 9.]]) -****************************************************************************** Read a file in .npy or .npz format -****************************************************************************** +================================== Choices: @@ -169,12 +184,11 @@ Choices: - Use memory mapping. See `numpy.lib.format.open_memmap`. -****************************************************************************** Write to a file to be read back by NumPy -****************************************************************************** +======================================== Binary -=============================================================================== +------ Use :func:`numpy.save`, or to store multiple arrays :func:`numpy.savez` @@ -188,20 +202,19 @@ Masked arrays :any:`can't currently be saved `, nor can other arbitrary array subclasses. Human-readable -============================================================================== +-------------- :func:`numpy.save` and :func:`numpy.savez` create binary files. To **write a human-readable file**, use :func:`numpy.savetxt`. The array can only be 1- or 2-dimensional, and there's no ` savetxtz` for multiple files. Large arrays -============================================================================== +------------ See :ref:`how-to-io-large-arrays`. -****************************************************************************** Read an arbitrarily formatted binary file ("binary blob") -****************************************************************************** +========================================================= Use a :doc:`structured array `. @@ -255,9 +268,8 @@ under `CC BY 4.0 `_.) .. _how-to-io-large-arrays: -****************************************************************************** Write or read large arrays -****************************************************************************** +========================== **Arrays too large to fit in memory** can be treated like ordinary in-memory arrays using memory mapping. @@ -282,16 +294,14 @@ full-featured formats and libraries usable with NumPy include: For tradeoffs among memmap, Zarr, and HDF5, see `pythonspeed.com `_. -****************************************************************************** Write files for reading by other (non-NumPy) tools -****************************************************************************** +================================================== Formats for **exchanging data** with other tools include HDF5, Zarr, and NetCDF (see :ref:`how-to-io-large-arrays`). -****************************************************************************** Write or read a JSON file -****************************************************************************** +========================= NumPy arrays are **not** directly `JSON serializable `_. @@ -299,9 +309,8 @@ NumPy arrays are **not** directly .. _how-to-io-pickle-file: -****************************************************************************** Save/restore using a pickle file -****************************************************************************** +================================ Avoid when possible; :doc:`pickles ` are not secure against erroneous or maliciously constructed data. @@ -310,15 +319,13 @@ Use :func:`numpy.save` and :func:`numpy.load`. Set ``allow_pickle=False``, unless the array dtype includes Python objects, in which case pickling is required. -****************************************************************************** Convert from a pandas DataFrame to a NumPy array -****************************************************************************** +================================================ See :meth:`pandas.DataFrame.to_numpy`. -****************************************************************************** - Save/restore using `~numpy.ndarray.tofile` and `~numpy.fromfile` -****************************************************************************** +Save/restore using `~numpy.ndarray.tofile` and `~numpy.fromfile` +================================================================ In general, prefer :func:`numpy.save` and :func:`numpy.load`. @@ -326,3 +333,11 @@ In general, prefer :func:`numpy.save` and :func:`numpy.load`. endianness and precision and so are unsuitable for anything but scratch storage. + +.. testcleanup:: + + >>> import os + >>> # list all files created in testsetup. If needed there are + >>> # convenienes in e.g. astroquery to do this more automatically + >>> for filename in ['csv.txt', 'fixedwidth.txt', 'nan.txt', 'skip.txt', 'tabs.txt']: + ... os.remove(filename) diff --git a/doc/source/user/how-to-partition.rst b/doc/source/user/how-to-partition.rst new file mode 100644 index 000000000000..224519364650 --- /dev/null +++ b/doc/source/user/how-to-partition.rst @@ -0,0 +1,268 @@ +.. _how-to-partition: + +================================================= +How to create arrays with regularly-spaced values +================================================= + +There are a few NumPy functions that are similar in application, but which +provide slightly different results, which may cause confusion if one is not sure +when and how to use them. The following guide aims to list these functions and +describe their recommended usage. + +The functions mentioned here are + +* `numpy.linspace` +* `numpy.arange` +* `numpy.geomspace` +* `numpy.logspace` +* `numpy.meshgrid` +* `numpy.mgrid` +* `numpy.ogrid` + +1D domains (intervals) +====================== + +``linspace`` vs. ``arange`` +--------------------------- + +Both `numpy.linspace` and `numpy.arange` provide ways to partition an interval +(a 1D domain) into equal-length subintervals. These partitions will vary +depending on the chosen starting and ending points, and the **step** (the length +of the subintervals). + +* **Use** `numpy.arange` **if you want integer steps.** + + `numpy.arange` relies on step size to determine how many elements are in the + returned array, which excludes the endpoint. This is determined through the + ``step`` argument to ``arange``. + + Example:: + + >>> np.arange(0, 10, 2) # np.arange(start, stop, step) + array([0, 2, 4, 6, 8]) + + The arguments ``start`` and ``stop`` should be integer or real, but not + complex numbers. `numpy.arange` is similar to the Python built-in + :py:class:`range`. + + Floating-point inaccuracies can make ``arange`` results with floating-point + numbers confusing. In this case, you should use `numpy.linspace` instead. + +* **Use** `numpy.linspace` **if you want the endpoint to be included in the + result, or if you are using a non-integer step size.** + + `numpy.linspace` *can* include the endpoint and determines step size from the + `num` argument, which specifies the number of elements in the returned + array. + + The inclusion of the endpoint is determined by an optional boolean + argument ``endpoint``, which defaults to ``True``. Note that selecting + ``endpoint=False`` will change the step size computation, and the subsequent + output for the function. + + Example:: + + >>> np.linspace(0.1, 0.2, num=5) # np.linspace(start, stop, num) + array([0.1 , 0.125, 0.15 , 0.175, 0.2 ]) + >>> np.linspace(0.1, 0.2, num=5, endpoint=False) + array([0.1, 0.12, 0.14, 0.16, 0.18]) + + `numpy.linspace` can also be used with complex arguments:: + + >>> np.linspace(1+1.j, 4, 5, dtype=np.complex64) + array([1. +1.j , 1.75+0.75j, 2.5 +0.5j , 3.25+0.25j, 4. +0.j ], + dtype=complex64) + +Other examples +-------------- + +1. Unexpected results may happen if floating point values are used as ``step`` + in ``numpy.arange``. To avoid this, make sure all floating point conversion + happens after the computation of results. For example, replace + + :: + + >>> list(np.arange(0.1,0.4,0.1).round(1)) + [0.1, 0.2, 0.3, 0.4] # endpoint should not be included! + + with + + :: + + >>> list(np.arange(1, 4, 1) / 10.0) + [0.1, 0.2, 0.3] # expected result + +2. Note that + + :: + + >>> np.arange(0, 1.12, 0.04) + array([0. , 0.04, 0.08, 0.12, 0.16, 0.2 , 0.24, 0.28, 0.32, 0.36, 0.4 , + 0.44, 0.48, 0.52, 0.56, 0.6 , 0.64, 0.68, 0.72, 0.76, 0.8 , 0.84, + 0.88, 0.92, 0.96, 1. , 1.04, 1.08, 1.12]) + + and + + :: + + >>> np.arange(0, 1.08, 0.04) + array([0. , 0.04, 0.08, 0.12, 0.16, 0.2 , 0.24, 0.28, 0.32, 0.36, 0.4 , + 0.44, 0.48, 0.52, 0.56, 0.6 , 0.64, 0.68, 0.72, 0.76, 0.8 , 0.84, + 0.88, 0.92, 0.96, 1. , 1.04]) + + These differ because of numeric noise. When using floating point values, it + is possible that ``0 + 0.04 * 28 < 1.12``, and so ``1.12`` is in the + interval. In fact, this is exactly the case:: + + >>> 1.12/0.04 + 28.000000000000004 + + But ``0 + 0.04 * 27 >= 1.08`` so that 1.08 is excluded:: + + >>> 1.08/0.04 + 27.0 + + Alternatively, you could use ``np.arange(0, 28)*0.04`` which would always + give you precise control of the end point since it is integral:: + + >>> np.arange(0, 28)*0.04 + array([0. , 0.04, 0.08, 0.12, 0.16, 0.2 , 0.24, 0.28, 0.32, 0.36, 0.4 , + 0.44, 0.48, 0.52, 0.56, 0.6 , 0.64, 0.68, 0.72, 0.76, 0.8 , 0.84, + 0.88, 0.92, 0.96, 1. , 1.04, 1.08]) + + +``geomspace`` and ``logspace`` +------------------------------ + +``numpy.geomspace`` is similar to ``numpy.linspace``, but with numbers spaced +evenly on a log scale (a geometric progression). The endpoint is included in the +result. + +Example:: + + >>> np.geomspace(2, 3, num=5) + array([2. , 2.21336384, 2.44948974, 2.71080601, 3. ]) + +``numpy.logspace`` is similar to ``numpy.geomspace``, but with the start and end +points specified as logarithms (with base 10 as default):: + + >>> np.logspace(2, 3, num=5) + array([ 100. , 177.827941 , 316.22776602, 562.34132519, 1000. ]) + +In linear space, the sequence starts at ``base ** start`` (``base`` to the power +of ``start``) and ends with ``base ** stop``:: + + >>> np.logspace(2, 3, num=5, base=2) + array([4. , 4.75682846, 5.65685425, 6.72717132, 8. ]) + +nD domains +========== + +nD domains can be partitioned into *grids*. This can be done using one of the +following functions. + +``meshgrid`` +------------ + +The purpose of ``numpy.meshgrid`` is to create a rectangular grid out of a set +of one-dimensional coordinate arrays. + +Given arrays + + :: + + >>> x = np.array([0, 1, 2, 3]) + >>> y = np.array([0, 1, 2, 3, 4, 5]) + +``meshgrid`` will create two coordinate arrays, which can be used to generate +the coordinate pairs determining this grid. + + :: + + >>> xx, yy = np.meshgrid(x, y) + >>> xx + array([[0, 1, 2, 3], + [0, 1, 2, 3], + [0, 1, 2, 3], + [0, 1, 2, 3], + [0, 1, 2, 3], + [0, 1, 2, 3]]) + >>> yy + array([[0, 0, 0, 0], + [1, 1, 1, 1], + [2, 2, 2, 2], + [3, 3, 3, 3], + [4, 4, 4, 4], + [5, 5, 5, 5]]) + + >>> import matplotlib.pyplot as plt + >>> plt.plot(xx, yy, marker='.', color='k', linestyle='none') + +.. plot:: user/plots/meshgrid_plot.py + :align: center + :include-source: 0 + +``mgrid`` +--------- + +``numpy.mgrid`` can be used as a shortcut for creating meshgrids. It is not a +function, but when indexed, returns a multidimensional meshgrid. + +:: + + >>> xx, yy = np.meshgrid(np.array([0, 1, 2, 3]), np.array([0, 1, 2, 3, 4, 5])) + >>> xx.T, yy.T + (array([[0, 0, 0, 0, 0, 0], + [1, 1, 1, 1, 1, 1], + [2, 2, 2, 2, 2, 2], + [3, 3, 3, 3, 3, 3]]), + array([[0, 1, 2, 3, 4, 5], + [0, 1, 2, 3, 4, 5], + [0, 1, 2, 3, 4, 5], + [0, 1, 2, 3, 4, 5]])) + + >>> np.mgrid[0:4, 0:6] + array([[[0, 0, 0, 0, 0, 0], + [1, 1, 1, 1, 1, 1], + [2, 2, 2, 2, 2, 2], + [3, 3, 3, 3, 3, 3]], + + [[0, 1, 2, 3, 4, 5], + [0, 1, 2, 3, 4, 5], + [0, 1, 2, 3, 4, 5], + [0, 1, 2, 3, 4, 5]]]) + + +``ogrid`` +--------- + +Similar to ``numpy.mgrid``, ``numpy.ogrid`` returns an *open* multidimensional +meshgrid. This means that when it is indexed, only one dimension of each +returned array is greater than 1. This avoids repeating the data and thus saves +memory, which is often desirable. + +These sparse coordinate grids are intended to be use with :ref:`broadcasting`. +When all coordinates are used in an expression, broadcasting still leads to a +fully-dimensonal result array. + +:: + + >>> np.ogrid[0:4, 0:6] + [array([[0], + [1], + [2], + [3]]), array([[0, 1, 2, 3, 4, 5]])] + +All three methods described here can be used to evaluate function values on a +grid. + +:: + + >>> g = np.ogrid[0:4, 0:6] + >>> zg = np.sqrt(g[0]**2 + g[1]**2) + >>> g[0].shape, g[1].shape, zg.shape + ((4, 1), (1, 6), (4, 6)) + >>> m = np.mgrid[0:4, 0:6] + >>> zm = np.sqrt(m[0]**2 + m[1]**2) + >>> np.array_equal(zm, zg) + True diff --git a/doc/source/user/how-to-verify-bug.rst b/doc/source/user/how-to-verify-bug.rst new file mode 100644 index 000000000000..4fc58c707bd4 --- /dev/null +++ b/doc/source/user/how-to-verify-bug.rst @@ -0,0 +1,168 @@ +.. _how-to-verify-bug: + +##################################### +Verifying bugs and bug fixes in NumPy +##################################### + +In this how-to you will learn how to: + +- Verify the existence of a bug in NumPy +- Verify the fix, if any, made for the bug + +While you walk through the verification process, you will learn how to: + +- Set up a Python virtual environment (using ``virtualenv``) +- Install appropriate versions of NumPy, first to see the bug in action, then to + verify its fix + +`Issue 16354 `_ is used as an +example. + +This issue was: + + **Title**: *np.polymul return type is np.float64 or np.complex128 when given + an all-zero argument* + + *np.polymul returns an object with type np.float64 when one argument is all + zero, and both arguments have type np.int64 or np.float32. Something + similar happens with all zero np.complex64 giving result type + np.complex128.* + + *This doesn't happen with non-zero arguments; there the result is as + expected.* + + *This bug isn't present in np.convolve.* + + **Reproducing code example**:: + + >>> import numpy as np + >>> np.__version__ + '1.18.4' + >>> a = np.array([1,2,3]) + >>> z = np.array([0,0,0]) + >>> np.polymul(a.astype(np.int64), a.astype(np.int64)).dtype + dtype('int64') + >>> np.polymul(a.astype(np.int64), z.astype(np.int64)).dtype + dtype('float64') + >>> np.polymul(a.astype(np.float32), z.astype(np.float32)).dtype + dtype('float64') + >>> np.polymul(a.astype(np.complex64), z.astype(np.complex64)).dtype + dtype('complex128') + Numpy/Python version information: + >>> import sys, numpy; print(numpy.__version__, sys.version) + 1.18.4 3.7.5 (default, Nov 7 2019, 10:50:52) [GCC 8.3.0] + +******************************* +1. Set up a virtual environment +******************************* + +Create a new directory, enter into it, and set up a virtual environment using +your preferred method. For example, this is how to do it using +``virtualenv`` on linux or macOS: + +:: + + virtualenv venv_np_bug + source venv_np_bug/bin/activate + +This ensures the system/global/default Python/NumPy installation will not be +altered. + +********************************************************** +2. Install the NumPy version in which the bug was reported +********************************************************** + +The report references NumPy version 1.18.4, so that is the version you need to +install in this case. + +Since this bug is tied to a release and not a specific commit, a pre-built wheel +installed in your virtual environment via `pip` will suffice:: + + pip install numpy==1.18.4 + +Some bugs may require you to build the NumPy version referenced in the issue +report. To learn how to do that, visit +:ref:`Building from source `. + + +******************** +1. Reproduce the bug +******************** + +The issue reported in `#16354 `_ is +that the wrong ``dtype`` is returned if one of the inputs of the method +`numpy.polymul` is a zero array. + +To reproduce the bug, start a Python terminal, enter the code snippet +shown in the bug report, and ensure that the results match those in the issue:: + + >>> import numpy as np + >>> np.__version__ + '...' # 1.18.4 + >>> a = np.array([1,2,3]) + >>> z = np.array([0,0,0]) + >>> np.polymul(a.astype(np.int64), a.astype(np.int64)).dtype + dtype('int64') + >>> np.polymul(a.astype(np.int64), z.astype(np.int64)).dtype + dtype('...') # float64 + >>> np.polymul(a.astype(np.float32), z.astype(np.float32)).dtype + dtype('...') # float64 + >>> np.polymul(a.astype(np.complex64), z.astype(np.complex64)).dtype + dtype('...') # complex128 + +As reported, whenever the zero array, ``z`` in the example above, is one of the +arguments to `numpy.polymul`, an incorrect ``dtype`` is returned. + + +************************************************* +4. Check for fixes in the latest version of NumPy +************************************************* + +If the issue report for your bug has not yet been resolved, further action or +patches need to be submitted. + +In this case, however, the issue was resolved by +`PR 17577 `_ and is now closed. So +you can try to verify the fix. + +To verify the fix: + +1. Uninstall the version of NumPy in which the bug still exists:: + + pip uninstall numpy + +2. Install the latest version of NumPy:: + + pip install numpy + +3. In your Python terminal, run the reported code snippet you used to verify the + existence of the bug and confirm that the issue has been resolved:: + + >>> import numpy as np + >>> np.__version__ + '...' # 1.18.4 + >>> a = np.array([1,2,3]) + >>> z = np.array([0,0,0]) + >>> np.polymul(a.astype(np.int64), a.astype(np.int64)).dtype + dtype('int64') + >>> np.polymul(a.astype(np.int64), z.astype(np.int64)).dtype + dtype('int64') + >>> np.polymul(a.astype(np.float32), z.astype(np.float32)).dtype + dtype('float32') + >>> np.polymul(a.astype(np.complex64), z.astype(np.complex64)).dtype + dtype('complex64') + +Note that the correct ``dtype`` is now returned even when a zero array is one of +the arguments to `numpy.polymul`. + +********************************************************* +5. Support NumPy development by verifying and fixing bugs +********************************************************* + +Go to the `NumPy GitHub issues page `_ +and see if you can confirm the existence of any other bugs which have not been +confirmed yet. In particular, it is useful for the developers to know if a bug +can be reproduced on a newer version of NumPy. + +Comments verifying the existence of bugs alert the NumPy developers that more +than one user can reproduce the issue. diff --git a/doc/source/user/howtos_index.rst b/doc/source/user/howtos_index.rst index 89a6f54e791c..4a0a22900c74 100644 --- a/doc/source/user/howtos_index.rst +++ b/doc/source/user/howtos_index.rst @@ -13,3 +13,6 @@ the package, see the :ref:`API reference `. how-to-how-to how-to-io + how-to-index + how-to-verify-bug + how-to-partition diff --git a/doc/source/user/index.rst b/doc/source/user/index.rst index e5c51351e073..163aee93e9b2 100644 --- a/doc/source/user/index.rst +++ b/doc/source/user/index.rst @@ -1,5 +1,3 @@ -:orphan: - .. _user: ################ @@ -10,21 +8,36 @@ This guide is an overview and explains the important features; details are found in :ref:`reference`. .. toctree:: + :caption: Getting started :maxdepth: 1 whatisnumpy Installation quickstart absolute_beginners + +.. toctree:: + :caption: Fundamentals and usage + :maxdepth: 2 + basics - misc + +.. toctree:: + :maxdepth: 1 + numpy-for-matlab-users - building - c-info NumPy Tutorials howtos_index - depending_on_numpy +.. toctree:: + :caption: Advanced usage and interoperability + :maxdepth: 1 + + building + c-info + ../f2py/index + ../dev/underthehood + basics.interoperability .. Links to these files are placed directly in the top-level html (doc/source/_templates/indexcontent.html, which appears for the URLs @@ -34,10 +47,8 @@ details are found in :ref:`reference`. .. toctree:: :hidden: + :caption: Extras - ../f2py/index ../glossary - ../dev/underthehood - ../bugs ../release ../license diff --git a/doc/source/user/misc.rst b/doc/source/user/misc.rst index 31647315146d..f0408f1812a2 100644 --- a/doc/source/user/misc.rst +++ b/doc/source/user/misc.rst @@ -1,3 +1,5 @@ +:orphan: + ************* Miscellaneous ************* @@ -19,10 +21,10 @@ Note: cannot use equality to test NaNs. E.g.: :: False >>> myarr[myarr == np.nan] = 0. # doesn't work >>> myarr - array([ 1., 0., NaN, 3.]) + array([ 1., 0., nan, 3.]) >>> myarr[np.isnan(myarr)] = 0. # use this instead find >>> myarr - array([ 1., 0., 0., 3.]) + array([1., 0., 0., 3.]) Other related special value functions: :: @@ -79,20 +81,24 @@ Examples >>> oldsettings = np.seterr(all='warn') >>> np.zeros(5,dtype=np.float32)/0. - invalid value encountered in divide + Traceback (most recent call last): + ... + RuntimeWarning: invalid value encountered in divide >>> j = np.seterr(under='ignore') >>> np.array([1.e-100])**10 + array([0.]) >>> j = np.seterr(invalid='raise') >>> np.sqrt(np.array([-1.])) + Traceback (most recent call last): + ... FloatingPointError: invalid value encountered in sqrt >>> def errorhandler(errstr, errflag): ... print("saw stupid error!") >>> np.seterrcall(errorhandler) - >>> j = np.seterr(all='call') >>> np.zeros(5, dtype=np.int32)/0 - FloatingPointError: invalid value encountered in divide saw stupid error! + array([nan, nan, nan, nan, nan]) >>> j = np.seterr(**oldsettings) # restore previous ... # error-handling settings @@ -119,8 +125,6 @@ Only a survey of the choices. Little detail on how each works. - getting it wrong leads to memory leaks, and worse, segfaults - - API will change for Python 3.0! - 2) Cython - Plusses: @@ -179,21 +183,7 @@ Only a survey of the choices. Little detail on how each works. - doesn't necessarily avoid reference counting issues or needing to know API's -5) scipy.weave - - - Plusses: - - - can turn many numpy expressions into C code - - dynamic compiling and loading of generated C code - - can embed pure C code in Python module and have weave extract, generate - interfaces and compile, etc. - - - Minuses: - - - Future very uncertain: it's the only part of Scipy not ported to Python 3 - and is effectively deprecated in favor of Cython. - -6) Psyco +5) Psyco - Plusses: @@ -222,5 +212,3 @@ Interfacing to C++: 3) Boost.python 4) SWIG 5) SIP (used mainly in PyQT) - - diff --git a/doc/source/user/numpy-for-matlab-users.rst b/doc/source/user/numpy-for-matlab-users.rst index 21e23482adeb..3344b87bbb69 100644 --- a/doc/source/user/numpy-for-matlab-users.rst +++ b/doc/source/user/numpy-for-matlab-users.rst @@ -9,7 +9,7 @@ Introduction MATLAB® and NumPy have a lot in common, but NumPy was created to work with Python, not to be a MATLAB clone. This guide will help MATLAB users get started -with NumPy. +with NumPy. .. raw:: html @@ -28,7 +28,7 @@ Some key differences 2D arrays of double precision floating point numbers, unless you specify the number of dimensions and type. Operations on the 2D instances of these arrays are modeled on matrix operations in - linear algebra. + linear algebra. - In NumPy, the basic type is a multidimensional ``array``. Array assignments in NumPy are usually stored as :ref:`n-dimensional arrays` with the @@ -47,7 +47,7 @@ Some key differences * - MATLAB's scripting language was created for linear algebra so the syntax for some array manipulations is more compact than - NumPy's. On the other hand, the API for adding GUIs and creating + NumPy's. On the other hand, the API for adding GUIs and creating full-fledged applications is more or less an afterthought. - NumPy is based on Python, a general-purpose language. The advantage to NumPy @@ -56,14 +56,14 @@ Some key differences `Pandas `_, `OpenCV `_, and more. In addition, Python is often `embedded as a scripting language `_ - in other software, allowing NumPy to be used there too. + in other software, allowing NumPy to be used there too. * - MATLAB array slicing uses pass-by-value semantics, with a lazy copy-on-write scheme to prevent creating copies until they are needed. Slicing operations copy parts of the array. - NumPy array slicing uses pass-by-reference, that does not copy the arguments. Slicing operations are views into an array. - + Rough equivalents ======================================= @@ -79,7 +79,7 @@ commands in Python: import numpy as np from scipy import io, integrate, linalg, signal - from scipy.sparse.linalg import eigs + from scipy.sparse.linalg import cg, eigs Also assume below that if the Notes talk about "matrix" that the arguments are two-dimensional entities. @@ -134,7 +134,7 @@ General purpose equivalents scalar arguments only * - .. code:: matlab - + >> 4 == 4 ans = 1 >> 4 == 5 @@ -149,7 +149,7 @@ General purpose equivalents - The :ref:`boolean objects ` in Python are ``True`` and ``False``, as opposed to MATLAB - logical types of ``1`` and ``0``. + logical types of ``1`` and ``0``. * - .. code:: matlab @@ -165,7 +165,7 @@ General purpose equivalents a = 4 if a == 4: print('a = 4') - elif a == 5: + elif a == 5: print('a = 5') - create an if-else statement to check if ``a`` is 4 or 5 and print result @@ -176,8 +176,8 @@ General purpose equivalents * - ``eps`` - ``np.finfo(float).eps`` or ``np.spacing(1)`` - - Upper bound to relative error due to rounding in 64-bit floating point - arithmetic. + - distance from 1 to the next larger representable real number in double + precision * - ``load data.mat`` - ``io.loadmat('data.mat')`` @@ -223,7 +223,7 @@ Linear algebra equivalents See note :ref:`INDEXING `) * - ``[ 1 2 3; 4 5 6 ]`` - - ``np.array([[1. ,2. ,3.], [4. ,5. ,6.]])`` + - ``np.array([[1., 2., 3.], [4., 5., 6.]])`` - define a 2x3 2D array * - ``[ a b; c d ]`` @@ -253,7 +253,7 @@ Linear algebra equivalents * - ``a(1:3,5:9)`` - ``a[0:3, 4:9]`` - - The first through third rows and fifth through ninth columns of a 2D array, ``a``. + - The first through third rows and fifth through ninth columns of a 2D array, ``a``. * - ``a([2,4,5],[1,3])`` - ``a[np.ix_([1, 3, 4], [0, 2])]`` @@ -266,7 +266,7 @@ Linear algebra equivalents twenty-first * - ``a(1:2:end,:)`` - - ``a[ ::2,:]`` + - ``a[::2, :]`` - every other row of ``a``, starting with the first * - ``a(end:-1:1,:)`` or ``flipud(a)`` @@ -384,7 +384,7 @@ Linear algebra equivalents vector, ``v`` * - .. code:: matlab - + rng(42,'twister') rand(3,4) @@ -392,7 +392,7 @@ Linear algebra equivalents from numpy.random import default_rng rng = default_rng(42) - rng.random(3, 4) + rng.random(3, 4) or older version: ``random.rand((3, 4))`` @@ -404,7 +404,7 @@ Linear algebra equivalents - 4 equally spaced samples between 1 and 3, inclusive * - ``[x,y]=meshgrid(0:8,0:5)`` - - ``np.mgrid[0:9.,0:6.]`` or ``np.meshgrid(r_[0:9.],r_[0:6.]`` + - ``np.mgrid[0:9.,0:6.]`` or ``np.meshgrid(r_[0:9.],r_[0:6.])`` - two 2D arrays: one of x values, the other of y values * - @@ -416,7 +416,7 @@ Linear algebra equivalents - * - - - ``ix_([1,2,4],[2,4,5])`` + - ``np.ix_([1,2,4],[2,4,5])`` - the best way to eval functions on a grid * - ``repmat(a, m, n)`` @@ -481,7 +481,7 @@ Linear algebra equivalents - pseudo-inverse of 2D array ``a`` * - ``rank(a)`` - - ``linalg.matrix_rank(a)`` + - ``np.linalg.matrix_rank(a)`` - matrix rank of a 2D array ``a`` * - ``a\b`` @@ -494,48 +494,47 @@ Linear algebra equivalents - solution of x a = b for x * - ``[U,S,V]=svd(a)`` - - ``U, S, Vh = linalg.svd(a), V = Vh.T`` + - ``U, S, Vh = linalg.svd(a); V = Vh.T`` - singular value decomposition of ``a`` - * - ``c=chol(a)`` where ``a==c'*c`` - - ``c = linalg.cholesky(a)`` where ``a == c@c.T`` - - Cholesky factorization of a 2D array (``chol(a)`` in MATLAB returns an - upper triangular 2D array, but :func:`~scipy.linalg.cholesky` returns a lower - triangular 2D array) + * - ``chol(a)`` + - ``linalg.cholesky(a)`` + - Cholesky factorization of a 2D array * - ``[V,D]=eig(a)`` - ``D,V = linalg.eig(a)`` - - eigenvalues :math:`\lambda` and eigenvectors :math:`\bar{v}` of ``a``, - where :math:`\lambda\bar{v}=\mathbf{a}\bar{v}` + - eigenvalues :math:`\lambda` and eigenvectors :math:`v` of ``a``, + where :math:`\mathbf{a} v = \lambda v` * - ``[V,D]=eig(a,b)`` - ``D,V = linalg.eig(a, b)`` - - eigenvalues :math:`\lambda` and eigenvectors :math:`\bar{v}` of + - eigenvalues :math:`\lambda` and eigenvectors :math:`v` of ``a``, ``b`` - where :math:`\lambda\mathbf{b}\bar{v}=\mathbf{a}\bar{v}` + where :math:`\mathbf{a} v = \lambda \mathbf{b} v` * - ``[V,D]=eigs(a,3)`` - - ``D,V = eigs(a, k = 3)`` + - ``D,V = eigs(a, k=3)`` - find the ``k=3`` largest eigenvalues and eigenvectors of 2D array, ``a`` - * - ``[Q,R,P]=qr(a,0)`` + * - ``[Q,R]=qr(a,0)`` - ``Q,R = linalg.qr(a)`` - QR decomposition * - ``[L,U,P]=lu(a)`` where ``a==P'*L*U`` - ``P,L,U = linalg.lu(a)`` where ``a == P@L@U`` - - LU decomposition (note: P(MATLAB) == transpose(P(NumPy))) + - LU decomposition with partial pivoting + (note: P(MATLAB) == transpose(P(NumPy))) * - ``conjgrad`` - ``cg`` - - Conjugate gradients solver + - conjugate gradients solver * - ``fft(a)`` - - ``np.fft(a)`` + - ``np.fft.fft(a)`` - Fourier transform of ``a`` * - ``ifft(a)`` - - ``np.ifft(a)`` + - ``np.fft.ifft(a)`` - inverse Fourier transform of ``a`` * - ``sort(a)`` @@ -543,7 +542,7 @@ Linear algebra equivalents - sort each column of a 2D array, ``a`` * - ``sort(a, 2)`` - - ``np.sort(a, axis = 1)`` or ``a.sort(axis = 1)`` + - ``np.sort(a, axis=1)`` or ``a.sort(axis=1)`` - sort the each row of 2D array, ``a`` * - ``[b,I]=sortrows(a,1)`` @@ -786,7 +785,7 @@ this is just an example, not a statement of "best practices"): # Make all numpy available via shorter 'np' prefix import numpy as np - # + # # Make the SciPy linear algebra functions available as linalg.func() # e.g. linalg.lu, linalg.eig (for general l*B@u==A@u solution) from scipy import linalg @@ -801,7 +800,7 @@ this is just an example, not a statement of "best practices"): To use the deprecated `matrix` and other `matlib` functions: :: - + # Make all matlib functions accessible at the top level via M.func() import numpy.matlib as M # Make some matlib functions accessible directly at the top level via, e.g. rand(3,3) diff --git a/doc/source/user/plot_approx.py b/doc/source/user/plot_approx.py deleted file mode 100644 index a2d6981d9b85..000000000000 --- a/doc/source/user/plot_approx.py +++ /dev/null @@ -1,19 +0,0 @@ -from scipy import misc -import matplotlib.pyplot as plt -import numpy as np -from numpy import linalg - -img = misc.face() -img_array = img / 255 -img_gray = img_array @ [0.2126, 0.7152, 0.0722] - -U, s, Vt = linalg.svd(img_gray) - -Sigma = np.zeros((768, 1024)) -for i in range(768): - Sigma[i, i] = s[i] - -k = 10 - -approx = U @ Sigma[:, :k] @ Vt[:k, :] -plt.imshow(approx, cmap="gray") diff --git a/doc/source/user/plot_face.py b/doc/source/user/plot_face.py deleted file mode 100644 index c0891e770fef..000000000000 --- a/doc/source/user/plot_face.py +++ /dev/null @@ -1,5 +0,0 @@ -from scipy import misc -import matplotlib.pyplot as plt - -img = misc.face() -plt.imshow(img) diff --git a/doc/source/user/plot_final.py b/doc/source/user/plot_final.py deleted file mode 100644 index 10cb097dd97e..000000000000 --- a/doc/source/user/plot_final.py +++ /dev/null @@ -1,19 +0,0 @@ -from scipy import misc -import matplotlib.pyplot as plt -import numpy as np -from numpy import linalg - -img = misc.face() -img_array = img / 255 -img_array_transposed = np.transpose(img_array, (2, 0, 1)) - -U, s, Vt = linalg.svd(img_array_transposed) - -Sigma = np.zeros((3, 768, 1024)) -for j in range(3): - np.fill_diagonal(Sigma[j, :, :], s[j, :]) - -k = 10 - -approx_img = U @ Sigma[..., :k] @ Vt[..., :k, :] -plt.imshow(np.transpose(approx_img, (1, 2, 0))) diff --git a/doc/source/user/plot_gray.py b/doc/source/user/plot_gray.py deleted file mode 100644 index 6cb46bbe461d..000000000000 --- a/doc/source/user/plot_gray.py +++ /dev/null @@ -1,8 +0,0 @@ -from scipy import misc -import matplotlib.pyplot as plt -import numpy as np - -img = misc.face() -img_array = img / 255 -img_gray = img_array @ [0.2126, 0.7152, 0.0722] -plt.imshow(img_gray, cmap="gray") diff --git a/doc/source/user/plot_gray_svd.py b/doc/source/user/plot_gray_svd.py deleted file mode 100644 index 95439939daf8..000000000000 --- a/doc/source/user/plot_gray_svd.py +++ /dev/null @@ -1,16 +0,0 @@ -from scipy import misc -import matplotlib.pyplot as plt -import numpy as np -from numpy import linalg - -img = misc.face() -img_array = img / 255 -img_gray = img_array @ [0.2126, 0.7152, 0.0722] - -U, s, Vt = linalg.svd(img_gray) - -Sigma = np.zeros((768, 1024)) -for i in range(768): - Sigma[i, i] = s[i] - -plt.plot(s) diff --git a/doc/source/user/plot_reconstructed.py b/doc/source/user/plot_reconstructed.py deleted file mode 100644 index 37cf3c626cd7..000000000000 --- a/doc/source/user/plot_reconstructed.py +++ /dev/null @@ -1,17 +0,0 @@ -from scipy import misc -import matplotlib.pyplot as plt -import numpy as np -from numpy import linalg - -img = misc.face() -img_array = img / 255 -img_array_transposed = np.transpose(img_array, (2, 0, 1)) - -U, s, Vt = linalg.svd(img_array_transposed) - -Sigma = np.zeros((3, 768, 1024)) -for j in range(3): - np.fill_diagonal(Sigma[j, :, :], s[j, :]) - -reconstructed = U @ Sigma @ Vt -plt.imshow(np.transpose(reconstructed, (1, 2, 0))) diff --git a/doc/source/user/plots/meshgrid_plot.py b/doc/source/user/plots/meshgrid_plot.py new file mode 100644 index 000000000000..91032145af68 --- /dev/null +++ b/doc/source/user/plots/meshgrid_plot.py @@ -0,0 +1,7 @@ +import numpy as np +import matplotlib.pyplot as plt + +x = np.array([0, 1, 2, 3]) +y = np.array([0, 1, 2, 3, 4, 5]) +xx, yy = np.meshgrid(x, y) +plt.plot(xx, yy, marker='o', color='k', linestyle='none') diff --git a/doc/source/user/quickstart.rst b/doc/source/user/quickstart.rst index a9cfeca31553..d138242d7a23 100644 --- a/doc/source/user/quickstart.rst +++ b/doc/source/user/quickstart.rst @@ -193,7 +193,7 @@ state of the memory. By default, the dtype of the created array is [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]], dtype=int16) - >>> np.empty((2, 3)) + >>> np.empty((2, 3)) #doctest: +SKIP array([[3.73603959e-262, 6.02658058e-154, 6.55490914e-260], # may vary [5.30498948e-313, 3.14673309e-307, 1.00000000e+000]]) @@ -868,9 +868,9 @@ copy. >>> def f(x): ... print(id(x)) ... - >>> id(a) # id is a unique identifier of an object + >>> id(a) # id is a unique identifier of an object #doctest: +SKIP 148293216 # may vary - >>> f(a) + >>> f(a) #doctest: +SKIP 148293216 # may vary View or Shallow Copy @@ -1272,6 +1272,7 @@ set `__: ... z[diverge] = r # avoid diverging too much ... ... return divtime + >>> plt.clf() >>> plt.imshow(mandelbrot(400, 400)) The second way of indexing with booleans is more similar to integer @@ -1468,9 +1469,10 @@ that ``pylab.hist`` plots the histogram automatically, while >>> v = rg.normal(mu, sigma, 10000) >>> # Plot a normalized histogram with 50 bins >>> plt.hist(v, bins=50, density=True) # matplotlib version (plot) + (array...) >>> # Compute the histogram with numpy and then plot it >>> (n, bins) = np.histogram(v, bins=50, density=True) # NumPy version (no plot) - >>> plt.plot(.5 * (bins[1:] + bins[:-1]), n) + >>> plt.plot(.5 * (bins[1:] + bins[:-1]), n) #doctest: +SKIP With Matplotlib >=3.4 you can also use ``plt.stairs(n, bins)``. @@ -1483,4 +1485,4 @@ Further reading - `SciPy Tutorial `__ - `SciPy Lecture Notes `__ - A `matlab, R, IDL, NumPy/SciPy dictionary `__ -- :doc:`tutorial-svd ` +- :doc:`tutorial-svd ` diff --git a/doc/source/user/troubleshooting-importerror.rst b/doc/source/user/troubleshooting-importerror.rst index 1f99491a1e95..2227d7b07b04 100644 --- a/doc/source/user/troubleshooting-importerror.rst +++ b/doc/source/user/troubleshooting-importerror.rst @@ -146,3 +146,40 @@ following in python:: This may mainly help you if you are not running the python and/or NumPy version you are expecting to run. + + +C-API incompatibility +--------------------------- + +If you see an error like: + + + RuntimeError: module compiled against API version v1 but this version of numpy is v2 + + +You may have: + +* A bad extension "wheel" (binary install) that should use + `oldest-support-numpy `_ ( + with manual constraints if necessary) to build their binary packages. + +* An environment issue messing with package versions. + +* Incompatible package versions somehow enforced manually. + +* An extension module compiled locally against a very recent version + followed by a NumPy downgrade. + +* A compiled extension copied to a different computer with an + older NumPy version. + +The best thing to do if you see this error is to contact +the maintainers of the package that is causing problem +so that they can solve the problem properly. + +However, while you wait for a solution, a work around +that usually works is to upgrade the NumPy version:: + + + pip install numpy --upgrade + diff --git a/doc/source/user/whatisnumpy.rst b/doc/source/user/whatisnumpy.rst index e152a4ae2ee5..892ac5347090 100644 --- a/doc/source/user/whatisnumpy.rst +++ b/doc/source/user/whatisnumpy.rst @@ -60,7 +60,7 @@ and initializations, memory allocation, etc.) :: - for (i = 0; i < rows; i++): { + for (i = 0; i < rows; i++) { c[i] = a[i]*b[i]; } @@ -72,8 +72,8 @@ array, for example, the C code (abridged as before) expands to :: - for (i = 0; i < rows; i++): { - for (j = 0; j < columns; j++): { + for (i = 0; i < rows; i++) { + for (j = 0; j < columns; j++) { c[i][j] = a[i][j]*b[i][j]; } } diff --git a/doc/ufuncs.rst.txt b/doc/ufuncs.rst similarity index 100% rename from doc/ufuncs.rst.txt rename to doc/ufuncs.rst diff --git a/doc_requirements.txt b/doc_requirements.txt index 5324d4d0ce15..4c7396efe3f3 100644 --- a/doc_requirements.txt +++ b/doc_requirements.txt @@ -1,8 +1,13 @@ -sphinx==4.2.0 -numpydoc==1.1.0 -ipython +# doxygen required, use apt-get or dnf +sphinx>=4.5.0 +numpydoc==1.4 +pydata-sphinx-theme==0.9.0 +sphinx-design +ipython!=8.1.0 scipy matplotlib pandas -pydata-sphinx-theme breathe + +# needed to build release notes +towncrier diff --git a/environment.yml b/environment.yml index 1bc8b44a791a..b99fa12565fc 100644 --- a/environment.yml +++ b/environment.yml @@ -7,28 +7,32 @@ name: numpy-dev channels: - conda-forge dependencies: - - python - - cython + - python=3.9 #need to pin to avoid issues with builds + - cython>=0.29.30 - compilers - openblas - nomkl - - setuptools=58.4 + - setuptools=59.2.0 # For testing - pytest - pytest-cov - pytest-xdist - hypothesis # For type annotations - - mypy=0.910 + - mypy=0.981 + - typing_extensions>=4.2.0 # For building docs - - sphinx=4.1.1 - - numpydoc=1.1.0 + - sphinx>=4.5.0 + - sphinx-design + - numpydoc=1.4.0 - ipython - scipy - pandas - matplotlib - - pydata-sphinx-theme - - breathe + - pydata-sphinx-theme=0.9.0 + - doxygen + # NOTE: breathe 4.33.0 collides with sphinx.ext.graphviz + - breathe>4.33.0 # For linting - pycodestyle=2.7.0 - gitpython diff --git a/numpy/__init__.cython-30.pxd b/numpy/__init__.cython-30.pxd index 42a46d0b832b..5fd6086e0701 100644 --- a/numpy/__init__.cython-30.pxd +++ b/numpy/__init__.cython-30.pxd @@ -133,7 +133,6 @@ cdef extern from "numpy/arrayobject.h": NPY_ALIGNED NPY_NOTSWAPPED NPY_WRITEABLE - NPY_UPDATEIFCOPY NPY_ARR_HAS_DESCR NPY_BEHAVED @@ -165,7 +164,7 @@ cdef extern from "numpy/arrayobject.h": NPY_ARRAY_ALIGNED NPY_ARRAY_NOTSWAPPED NPY_ARRAY_WRITEABLE - NPY_ARRAY_UPDATEIFCOPY + NPY_ARRAY_WRITEBACKIFCOPY NPY_ARRAY_BEHAVED NPY_ARRAY_BEHAVED_NS diff --git a/numpy/__init__.pxd b/numpy/__init__.pxd index 97f3da2e5673..03db9a0c12fa 100644 --- a/numpy/__init__.pxd +++ b/numpy/__init__.pxd @@ -130,7 +130,6 @@ cdef extern from "numpy/arrayobject.h": NPY_ALIGNED NPY_NOTSWAPPED NPY_WRITEABLE - NPY_UPDATEIFCOPY NPY_ARR_HAS_DESCR NPY_BEHAVED @@ -162,7 +161,7 @@ cdef extern from "numpy/arrayobject.h": NPY_ARRAY_ALIGNED NPY_ARRAY_NOTSWAPPED NPY_ARRAY_WRITEABLE - NPY_ARRAY_UPDATEIFCOPY + NPY_ARRAY_WRITEBACKIFCOPY NPY_ARRAY_BEHAVED NPY_ARRAY_BEHAVED_NS diff --git a/numpy/__init__.py b/numpy/__init__.py index e8d1820a1406..e20a83ab1e7b 100644 --- a/numpy/__init__.py +++ b/numpy/__init__.py @@ -11,14 +11,14 @@ ---------------------------- Documentation is available in two forms: docstrings provided with the code, and a loose standing reference guide, available from -`the NumPy homepage `_. +`the NumPy homepage `_. We recommend exploring the docstrings using `IPython `_, an advanced Python shell with TAB-completion and introspection capabilities. See below for further instructions. -The docstring examples assume that `numpy` has been imported as `np`:: +The docstring examples assume that `numpy` has been imported as ``np``:: >>> import numpy as np @@ -52,8 +52,6 @@ Available subpackages --------------------- -doc - Topical documentation on broadcasting, indexing, etc. lib Basic functions used by several sub-packages. random @@ -66,8 +64,6 @@ Polynomial tools testing NumPy testing tools -f2py - Fortran to Python Interface Generator. distutils Enhancements to distutils with support for Fortran compilers support and more. @@ -89,10 +85,11 @@ Viewing documentation using IPython ----------------------------------- -Start IPython with the NumPy profile (``ipython -p numpy``), which will -import `numpy` under the alias `np`. Then, use the ``cpaste`` command to -paste examples into the shell. To see which functions are available in -`numpy`, type ``np.`` (where ```` refers to the TAB key), or use + +Start IPython and import `numpy` usually under the alias ``np``: `import +numpy as np`. Then, directly past or use the ``%cpaste`` magic to paste +examples into the shell. To see which functions are available in `numpy`, +type ``np.`` (where ```` refers to the TAB key), or use ``np.*cos*?`` (where ```` refers to the ENTER key) to narrow down the list. To view the docstring for a function, use ``np.cos?`` (to view the docstring) and ``np.cos??`` (to view @@ -162,11 +159,13 @@ import builtins as _builtins _msg = ( - "`np.{n}` is a deprecated alias for the builtin `{n}`. " - "To silence this warning, use `{n}` by itself. Doing this will not " - "modify any behavior and is safe. {extended_msg}\n" - "Deprecated in NumPy 1.20; for more details and guidance: " - "https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations") + "module 'numpy' has no attribute '{n}'.\n" + "`np.{n}` was a deprecated alias for the builtin `{n}`. " + "To avoid this error in existing code, use `{n}` by itself. " + "Doing this will not modify any behavior and is safe. {extended_msg}\n" + "The aliases was originally deprecated in NumPy 1.20; for more " + "details and guidance see the original release note at:\n" + " https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations") _specific_msg = ( "If you specifically wanted the numpy scalar type, use `np.{}` here.") @@ -185,44 +184,39 @@ ("str", _specific_msg.format("str_")), ("int", _int_extended_msg.format("int"))] - __deprecated_attrs__.update({ - n: (getattr(_builtins, n), _msg.format(n=n, extended_msg=extended_msg)) - for n, extended_msg in _type_info - }) - - # Numpy 1.20.0, 2020-10-19 - __deprecated_attrs__["typeDict"] = ( - core.numerictypes.typeDict, - "`np.typeDict` is a deprecated alias for `np.sctypeDict`." - ) - - # NumPy 1.22, 2021-10-20 - __deprecated_attrs__["MachAr"] = ( - core._machar.MachAr, - "`np.MachAr` is deprecated (NumPy 1.22)." - ) + __former_attrs__ = { + n: _msg.format(n=n, extended_msg=extended_msg) + for n, extended_msg in _type_info + } + # Future warning introduced in NumPy 1.24.0, 2022-11-17 _msg = ( - "`np.{n}` is a deprecated alias for `np.compat.{n}`. " - "To silence this warning, use `np.compat.{n}` by itself. " - "In the likely event your code does not need to work on Python 2 " - "you can use the builtin `{n2}` for which `np.compat.{n}` is itself " - "an alias. Doing this will not modify any behaviour and is safe. " - "{extended_msg}\n" - "Deprecated in NumPy 1.20; for more details and guidance: " - "https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations") - - __deprecated_attrs__["long"] = ( - getattr(compat, "long"), - _msg.format(n="long", n2="int", - extended_msg=_int_extended_msg.format("long"))) - - __deprecated_attrs__["unicode"] = ( - getattr(compat, "unicode"), - _msg.format(n="unicode", n2="str", - extended_msg=_specific_msg.format("str_"))) - - del _msg, _specific_msg, _int_extended_msg, _type_info, _builtins + "`np.{n}` is a deprecated alias for `{an}`. (Deprecated NumPy 1.24)") + + # Some of these are awkward (since `np.str` may be preferable in the long + # term), but overall the names ending in 0 seem undesireable + _type_info = [ + ("bool8", bool_, "np.bool_"), + ("int0", intp, "np.intp"), + ("uint0", uintp, "np.uintp"), + ("str0", str_, "np.str_"), + ("bytes0", bytes_, "np.bytes_"), + ("void0", void, "np.void"), + ("object0", object_, + "`np.object0` is a deprecated alias for `np.object_`. " + "`object` can be used instead. (Deprecated NumPy 1.24)")] + + # Some of these could be defined right away, but most were aliases to + # the Python objects and only removed in NumPy 1.24. Defining them should + # probably wait for NumPy 1.26 or 2.0. + # When defined, these should possibly not be added to `__all__` to avoid + # import with `from numpy import *`. + __future_scalars__ = {"bool", "long", "ulong", "str", "bytes", "object"} + + __deprecated_attrs__.update({ + n: (alias, _msg.format(n=n, an=an)) for n, alias, an in _type_info}) + + del _msg, _type_info from .core import round, abs, max, min # now that numpy modules are imported, can initialize limits @@ -278,6 +272,7 @@ def __getattr__(attr): # Warn for expired attributes, and return a dummy function # that always raises an exception. + import warnings try: msg = __expired_functions__[attr] except KeyError: @@ -299,6 +294,16 @@ def _expired(*args, **kwds): warnings.warn(msg, DeprecationWarning, stacklevel=2) return val + if attr in __future_scalars__: + # And future warnings for those that will change, but also give + # the AttributeError + warnings.warn( + f"In the future `np.{attr}` will be defined as the " + "corresponding NumPy scalar.", FutureWarning, stacklevel=2) + + if attr in __former_attrs__: + raise AttributeError(__former_attrs__[attr]) + # Importing Tester requires importing all of UnitTest which is not a # cheap import Since it is mainly used in test suits, we lazy import it # here to save on the order of 10 ms of import time for most users @@ -316,7 +321,11 @@ def _expired(*args, **kwds): "{!r}".format(__name__, attr)) def __dir__(): - return list(globals().keys() | {'Tester', 'testing'}) + public_symbols = globals().keys() | {'Tester', 'testing'} + public_symbols -= { + "core", "matrixlib", + } + return list(public_symbols) # Pytest testing from numpy._pytesttester import PytestTester @@ -336,7 +345,7 @@ def _sanity_check(): """ try: x = ones(2, dtype=float32) - if not abs(x.dot(x) - 2.0) < 1e-5: + if not abs(x.dot(x) - float32(2.0)) < 1e-5: raise AssertionError() except AssertionError: msg = ("The current Numpy installation ({!r}) fails to " @@ -362,7 +371,6 @@ def _mac_os_check(): except ValueError: pass - import sys if sys.platform == "darwin": with warnings.catch_warnings(record=True) as w: _mac_os_check() @@ -413,6 +421,19 @@ def _mac_os_check(): # it is tidier organized. core.multiarray._multiarray_umath._reload_guard() + core._set_promotion_state(os.environ.get("NPY_PROMOTION_STATE", "legacy")) + + # Tell PyInstaller where to find hook-numpy.py + def _pyinstaller_hooks_dir(): + from pathlib import Path + return [str(Path(__file__).with_name("_pyinstaller").resolve())] + + # Remove symbols imported for internal use + del os + # get the version using versioneer from .version import __version__, git_revision as __git_version__ + +# Remove symbols imported for internal use +del sys, warnings diff --git a/numpy/__init__.pyi b/numpy/__init__.pyi index e01df7c90b27..853444f23cb2 100644 --- a/numpy/__init__.pyi +++ b/numpy/__init__.pyi @@ -9,6 +9,7 @@ import enum from abc import abstractmethod from types import TracebackType, MappingProxyType from contextlib import ContextDecorator +from contextlib import contextmanager if sys.version_info >= (3, 9): from types import GenericAlias @@ -16,7 +17,7 @@ if sys.version_info >= (3, 9): from numpy._pytesttester import PytestTester from numpy.core._internal import _ctypes -from numpy.typing import ( +from numpy._typing import ( # Arrays ArrayLike, NDArray, @@ -35,9 +36,13 @@ from numpy.typing import ( _ArrayLikeObject_co, _ArrayLikeStr_co, _ArrayLikeBytes_co, + _ArrayLikeUnknown, + _UnknownType, # DTypes DTypeLike, + _DTypeLike, + _DTypeLikeVoid, _SupportsDType, _VoidDTypeLike, @@ -125,7 +130,7 @@ from numpy.typing import ( _GUFunc_Nin2_Nout1, ) -from numpy.typing._callable import ( +from numpy._typing._callable import ( _BoolOp, _BoolBitOp, _BoolSub, @@ -152,7 +157,7 @@ from numpy.typing._callable import ( # NOTE: Numpy's mypy plugin is used for removing the types unavailable # to the specific platform -from numpy.typing._extended_precision import ( +from numpy._typing._extended_precision import ( uint128 as uint128, uint256 as uint256, int128 as int128, @@ -167,31 +172,26 @@ from numpy.typing._extended_precision import ( complex512 as complex512, ) -from typing import ( - Literal as L, - Any, - ByteString, +from collections.abc import ( Callable, Container, - Callable, - Dict, - Generic, - IO, Iterable, Iterator, - List, Mapping, - NoReturn, - Optional, - overload, Sequence, Sized, +) +from typing import ( + Literal as L, + Any, + Generator, + Generic, + IO, + NoReturn, + overload, SupportsComplex, SupportsFloat, SupportsInt, - Text, - Tuple, - Type, TypeVar, Union, Protocol, @@ -199,7 +199,6 @@ from typing import ( Final, final, ClassVar, - Set, ) # Ensures that the stubs are picked up @@ -209,7 +208,6 @@ from numpy import ( lib as lib, linalg as linalg, ma as ma, - matrixlib as matrixlib, polynomial as polynomial, random as random, testing as testing, @@ -459,7 +457,6 @@ from numpy.lib.function_base import ( digitize as digitize, cov as cov, corrcoef as corrcoef, - msort as msort, median as median, sinc as sinc, hamming as hamming, @@ -623,6 +620,7 @@ from numpy.lib.utils import ( lookfor as lookfor, byte_bounds as byte_bounds, safe_eval as safe_eval, + show_runtime as show_runtime, ) from numpy.matrixlib import ( @@ -655,8 +653,8 @@ class _MemMapIOProtocol(Protocol): class _SupportsWrite(Protocol[_AnyStr_contra]): def write(self, s: _AnyStr_contra, /) -> object: ... -__all__: List[str] -__path__: List[str] +__all__: list[str] +__path__: list[str] __version__: str __git_version__: str test: PytestTester @@ -682,13 +680,14 @@ _NdArraySubClass = TypeVar("_NdArraySubClass", bound=ndarray) _DTypeScalar_co = TypeVar("_DTypeScalar_co", covariant=True, bound=generic) _ByteOrder = L["S", "<", ">", "=", "|", "L", "B", "N", "I"] +@final class dtype(Generic[_DTypeScalar_co]): - names: None | Tuple[builtins.str, ...] + names: None | tuple[builtins.str, ...] # Overload for subclass of generic @overload def __new__( cls, - dtype: Type[_DTypeScalar_co], + dtype: type[_DTypeScalar_co], align: bool = ..., copy: bool = ..., ) -> dtype[_DTypeScalar_co]: ... @@ -702,64 +701,64 @@ class dtype(Generic[_DTypeScalar_co]): # first. # Builtin types @overload - def __new__(cls, dtype: Type[bool], align: bool = ..., copy: bool = ...) -> dtype[bool_]: ... + def __new__(cls, dtype: type[bool], align: bool = ..., copy: bool = ...) -> dtype[bool_]: ... @overload - def __new__(cls, dtype: Type[int], align: bool = ..., copy: bool = ...) -> dtype[int_]: ... + def __new__(cls, dtype: type[int], align: bool = ..., copy: bool = ...) -> dtype[int_]: ... @overload - def __new__(cls, dtype: None | Type[float], align: bool = ..., copy: bool = ...) -> dtype[float_]: ... + def __new__(cls, dtype: None | type[float], align: bool = ..., copy: bool = ...) -> dtype[float_]: ... @overload - def __new__(cls, dtype: Type[complex], align: bool = ..., copy: bool = ...) -> dtype[complex_]: ... + def __new__(cls, dtype: type[complex], align: bool = ..., copy: bool = ...) -> dtype[complex_]: ... @overload - def __new__(cls, dtype: Type[builtins.str], align: bool = ..., copy: bool = ...) -> dtype[str_]: ... + def __new__(cls, dtype: type[builtins.str], align: bool = ..., copy: bool = ...) -> dtype[str_]: ... @overload - def __new__(cls, dtype: Type[bytes], align: bool = ..., copy: bool = ...) -> dtype[bytes_]: ... + def __new__(cls, dtype: type[bytes], align: bool = ..., copy: bool = ...) -> dtype[bytes_]: ... # `unsignedinteger` string-based representations and ctypes @overload - def __new__(cls, dtype: _UInt8Codes | Type[ct.c_uint8], align: bool = ..., copy: bool = ...) -> dtype[uint8]: ... + def __new__(cls, dtype: _UInt8Codes | type[ct.c_uint8], align: bool = ..., copy: bool = ...) -> dtype[uint8]: ... @overload - def __new__(cls, dtype: _UInt16Codes | Type[ct.c_uint16], align: bool = ..., copy: bool = ...) -> dtype[uint16]: ... + def __new__(cls, dtype: _UInt16Codes | type[ct.c_uint16], align: bool = ..., copy: bool = ...) -> dtype[uint16]: ... @overload - def __new__(cls, dtype: _UInt32Codes | Type[ct.c_uint32], align: bool = ..., copy: bool = ...) -> dtype[uint32]: ... + def __new__(cls, dtype: _UInt32Codes | type[ct.c_uint32], align: bool = ..., copy: bool = ...) -> dtype[uint32]: ... @overload - def __new__(cls, dtype: _UInt64Codes | Type[ct.c_uint64], align: bool = ..., copy: bool = ...) -> dtype[uint64]: ... + def __new__(cls, dtype: _UInt64Codes | type[ct.c_uint64], align: bool = ..., copy: bool = ...) -> dtype[uint64]: ... @overload - def __new__(cls, dtype: _UByteCodes | Type[ct.c_ubyte], align: bool = ..., copy: bool = ...) -> dtype[ubyte]: ... + def __new__(cls, dtype: _UByteCodes | type[ct.c_ubyte], align: bool = ..., copy: bool = ...) -> dtype[ubyte]: ... @overload - def __new__(cls, dtype: _UShortCodes | Type[ct.c_ushort], align: bool = ..., copy: bool = ...) -> dtype[ushort]: ... + def __new__(cls, dtype: _UShortCodes | type[ct.c_ushort], align: bool = ..., copy: bool = ...) -> dtype[ushort]: ... @overload - def __new__(cls, dtype: _UIntCCodes | Type[ct.c_uint], align: bool = ..., copy: bool = ...) -> dtype[uintc]: ... + def __new__(cls, dtype: _UIntCCodes | type[ct.c_uint], align: bool = ..., copy: bool = ...) -> dtype[uintc]: ... # NOTE: We're assuming here that `uint_ptr_t == size_t`, # an assumption that does not hold in rare cases (same for `ssize_t`) @overload - def __new__(cls, dtype: _UIntPCodes | Type[ct.c_void_p] | Type[ct.c_size_t], align: bool = ..., copy: bool = ...) -> dtype[uintp]: ... + def __new__(cls, dtype: _UIntPCodes | type[ct.c_void_p] | type[ct.c_size_t], align: bool = ..., copy: bool = ...) -> dtype[uintp]: ... @overload - def __new__(cls, dtype: _UIntCodes | Type[ct.c_ulong], align: bool = ..., copy: bool = ...) -> dtype[uint]: ... + def __new__(cls, dtype: _UIntCodes | type[ct.c_ulong], align: bool = ..., copy: bool = ...) -> dtype[uint]: ... @overload - def __new__(cls, dtype: _ULongLongCodes | Type[ct.c_ulonglong], align: bool = ..., copy: bool = ...) -> dtype[ulonglong]: ... + def __new__(cls, dtype: _ULongLongCodes | type[ct.c_ulonglong], align: bool = ..., copy: bool = ...) -> dtype[ulonglong]: ... # `signedinteger` string-based representations and ctypes @overload - def __new__(cls, dtype: _Int8Codes | Type[ct.c_int8], align: bool = ..., copy: bool = ...) -> dtype[int8]: ... + def __new__(cls, dtype: _Int8Codes | type[ct.c_int8], align: bool = ..., copy: bool = ...) -> dtype[int8]: ... @overload - def __new__(cls, dtype: _Int16Codes | Type[ct.c_int16], align: bool = ..., copy: bool = ...) -> dtype[int16]: ... + def __new__(cls, dtype: _Int16Codes | type[ct.c_int16], align: bool = ..., copy: bool = ...) -> dtype[int16]: ... @overload - def __new__(cls, dtype: _Int32Codes | Type[ct.c_int32], align: bool = ..., copy: bool = ...) -> dtype[int32]: ... + def __new__(cls, dtype: _Int32Codes | type[ct.c_int32], align: bool = ..., copy: bool = ...) -> dtype[int32]: ... @overload - def __new__(cls, dtype: _Int64Codes | Type[ct.c_int64], align: bool = ..., copy: bool = ...) -> dtype[int64]: ... + def __new__(cls, dtype: _Int64Codes | type[ct.c_int64], align: bool = ..., copy: bool = ...) -> dtype[int64]: ... @overload - def __new__(cls, dtype: _ByteCodes | Type[ct.c_byte], align: bool = ..., copy: bool = ...) -> dtype[byte]: ... + def __new__(cls, dtype: _ByteCodes | type[ct.c_byte], align: bool = ..., copy: bool = ...) -> dtype[byte]: ... @overload - def __new__(cls, dtype: _ShortCodes | Type[ct.c_short], align: bool = ..., copy: bool = ...) -> dtype[short]: ... + def __new__(cls, dtype: _ShortCodes | type[ct.c_short], align: bool = ..., copy: bool = ...) -> dtype[short]: ... @overload - def __new__(cls, dtype: _IntCCodes | Type[ct.c_int], align: bool = ..., copy: bool = ...) -> dtype[intc]: ... + def __new__(cls, dtype: _IntCCodes | type[ct.c_int], align: bool = ..., copy: bool = ...) -> dtype[intc]: ... @overload - def __new__(cls, dtype: _IntPCodes | Type[ct.c_ssize_t], align: bool = ..., copy: bool = ...) -> dtype[intp]: ... + def __new__(cls, dtype: _IntPCodes | type[ct.c_ssize_t], align: bool = ..., copy: bool = ...) -> dtype[intp]: ... @overload - def __new__(cls, dtype: _IntCodes | Type[ct.c_long], align: bool = ..., copy: bool = ...) -> dtype[int_]: ... + def __new__(cls, dtype: _IntCodes | type[ct.c_long], align: bool = ..., copy: bool = ...) -> dtype[int_]: ... @overload - def __new__(cls, dtype: _LongLongCodes | Type[ct.c_longlong], align: bool = ..., copy: bool = ...) -> dtype[longlong]: ... + def __new__(cls, dtype: _LongLongCodes | type[ct.c_longlong], align: bool = ..., copy: bool = ...) -> dtype[longlong]: ... # `floating` string-based representations and ctypes @overload @@ -771,11 +770,11 @@ class dtype(Generic[_DTypeScalar_co]): @overload def __new__(cls, dtype: _HalfCodes, align: bool = ..., copy: bool = ...) -> dtype[half]: ... @overload - def __new__(cls, dtype: _SingleCodes | Type[ct.c_float], align: bool = ..., copy: bool = ...) -> dtype[single]: ... + def __new__(cls, dtype: _SingleCodes | type[ct.c_float], align: bool = ..., copy: bool = ...) -> dtype[single]: ... @overload - def __new__(cls, dtype: _DoubleCodes | Type[ct.c_double], align: bool = ..., copy: bool = ...) -> dtype[double]: ... + def __new__(cls, dtype: _DoubleCodes | type[ct.c_double], align: bool = ..., copy: bool = ...) -> dtype[double]: ... @overload - def __new__(cls, dtype: _LongDoubleCodes | Type[ct.c_longdouble], align: bool = ..., copy: bool = ...) -> dtype[longdouble]: ... + def __new__(cls, dtype: _LongDoubleCodes | type[ct.c_longdouble], align: bool = ..., copy: bool = ...) -> dtype[longdouble]: ... # `complexfloating` string-based representations @overload @@ -791,7 +790,7 @@ class dtype(Generic[_DTypeScalar_co]): # Miscellaneous string-based representations and ctypes @overload - def __new__(cls, dtype: _BoolCodes | Type[ct.c_bool], align: bool = ..., copy: bool = ...) -> dtype[bool_]: ... + def __new__(cls, dtype: _BoolCodes | type[ct.c_bool], align: bool = ..., copy: bool = ...) -> dtype[bool_]: ... @overload def __new__(cls, dtype: _TD64Codes, align: bool = ..., copy: bool = ...) -> dtype[timedelta64]: ... @overload @@ -799,11 +798,11 @@ class dtype(Generic[_DTypeScalar_co]): @overload def __new__(cls, dtype: _StrCodes, align: bool = ..., copy: bool = ...) -> dtype[str_]: ... @overload - def __new__(cls, dtype: _BytesCodes | Type[ct.c_char], align: bool = ..., copy: bool = ...) -> dtype[bytes_]: ... + def __new__(cls, dtype: _BytesCodes | type[ct.c_char], align: bool = ..., copy: bool = ...) -> dtype[bytes_]: ... @overload def __new__(cls, dtype: _VoidCodes, align: bool = ..., copy: bool = ...) -> dtype[void]: ... @overload - def __new__(cls, dtype: _ObjectCodes | Type[ct.py_object], align: bool = ..., copy: bool = ...) -> dtype[object_]: ... + def __new__(cls, dtype: _ObjectCodes | type[ct.py_object], align: bool = ..., copy: bool = ...) -> dtype[object_]: ... # dtype of a dtype is the same dtype @overload @@ -840,7 +839,7 @@ class dtype(Generic[_DTypeScalar_co]): @overload def __new__( cls, - dtype: Type[object], + dtype: type[object], align: bool = ..., copy: bool = ..., ) -> dtype[object_]: ... @@ -849,7 +848,7 @@ class dtype(Generic[_DTypeScalar_co]): def __class_getitem__(self, item: Any) -> GenericAlias: ... @overload - def __getitem__(self: dtype[void], key: List[builtins.str]) -> dtype[void]: ... + def __getitem__(self: dtype[void], key: list[builtins.str]) -> dtype[void]: ... @overload def __getitem__(self: dtype[void], key: builtins.str | SupportsIndex) -> dtype[Any]: ... @@ -889,11 +888,11 @@ class dtype(Generic[_DTypeScalar_co]): @property def char(self) -> builtins.str: ... @property - def descr(self) -> List[Tuple[builtins.str, builtins.str] | Tuple[builtins.str, builtins.str, _Shape]]: ... + def descr(self) -> list[tuple[builtins.str, builtins.str] | tuple[builtins.str, builtins.str, _Shape]]: ... @property def fields( self, - ) -> None | MappingProxyType[builtins.str, Tuple[dtype[Any], int] | Tuple[dtype[Any], int, Any]]: ... + ) -> None | MappingProxyType[builtins.str, tuple[dtype[Any], int] | tuple[dtype[Any], int, Any]]: ... @property def flags(self) -> int: ... @property @@ -919,12 +918,12 @@ class dtype(Generic[_DTypeScalar_co]): @property def ndim(self) -> int: ... @property - def subdtype(self) -> None | Tuple[dtype[Any], _Shape]: ... + def subdtype(self) -> None | tuple[dtype[Any], _Shape]: ... def newbyteorder(self: _DType, __new_order: _ByteOrder = ...) -> _DType: ... @property def str(self) -> builtins.str: ... @property - def type(self) -> Type[_DTypeScalar_co]: ... + def type(self) -> type[_DTypeScalar_co]: ... _ArrayLikeInt = Union[ int, @@ -936,7 +935,9 @@ _ArrayLikeInt = Union[ _FlatIterSelf = TypeVar("_FlatIterSelf", bound=flatiter) +@final class flatiter(Generic[_NdArraySubClass]): + __hash__: ClassVar[None] @property def base(self) -> _NdArraySubClass: ... @property @@ -950,20 +951,30 @@ class flatiter(Generic[_NdArraySubClass]): @overload def __getitem__( self: flatiter[ndarray[Any, dtype[_ScalarType]]], - key: Union[int, integer], + key: int | integer | tuple[int | integer], ) -> _ScalarType: ... @overload def __getitem__( - self, key: Union[_ArrayLikeInt, slice, ellipsis], + self, + key: _ArrayLikeInt | slice | ellipsis | tuple[_ArrayLikeInt | slice | ellipsis], ) -> _NdArraySubClass: ... + # TODO: `__setitem__` operates via `unsafe` casting rules, and can + # thus accept any type accepted by the relevant underlying `np.generic` + # constructor. + # This means that `value` must in reality be a supertype of `npt.ArrayLike`. + def __setitem__( + self, + key: _ArrayLikeInt | slice | ellipsis | tuple[_ArrayLikeInt | slice | ellipsis], + value: Any, + ) -> None: ... @overload def __array__(self: flatiter[ndarray[Any, _DType]], dtype: None = ..., /) -> ndarray[Any, _DType]: ... @overload def __array__(self, dtype: _DType, /) -> ndarray[Any, _DType]: ... -_OrderKACF = Optional[L["K", "A", "C", "F"]] -_OrderACF = Optional[L["A", "C", "F"]] -_OrderCF = Optional[L["C", "F"]] +_OrderKACF = L[None, "K", "A", "C", "F"] +_OrderACF = L[None, "A", "C", "F"] +_OrderCF = L[None, "C", "F"] _ModeKind = L["raise", "wrap", "clip"] _PartitionKind = L["introselect"] @@ -988,7 +999,7 @@ class _ArrayOrScalarCommon: def __str__(self) -> str: ... def __repr__(self) -> str: ... def __copy__(self: _ArraySelf) -> _ArraySelf: ... - def __deepcopy__(self: _ArraySelf, memo: None | Dict[int, Any], /) -> _ArraySelf: ... + def __deepcopy__(self: _ArraySelf, memo: None | dict[int, Any], /) -> _ArraySelf: ... # TODO: How to deal with the non-commutative nature of `==` and `!=`? # xref numpy/numpy#17368 @@ -1010,17 +1021,17 @@ class _ArrayOrScalarCommon: def tolist(self) -> Any: ... @property - def __array_interface__(self) -> Dict[str, Any]: ... + def __array_interface__(self) -> dict[str, Any]: ... @property def __array_priority__(self) -> float: ... @property def __array_struct__(self) -> Any: ... # builtins.PyCapsule - def __setstate__(self, state: Tuple[ + def __setstate__(self, state: tuple[ SupportsIndex, # version _ShapeLike, # Shape _DType_co, # DType bool, # F-continuous - bytes | List[Any], # Data + bytes | list[Any], # Data ], /) -> None: ... # a `bool_` is returned when `keepdims=True` and `self` is a 0d array @@ -1030,20 +1041,26 @@ class _ArrayOrScalarCommon: axis: None = ..., out: None = ..., keepdims: L[False] = ..., + *, + where: _ArrayLikeBool_co = ..., ) -> bool_: ... @overload def all( self, - axis: Optional[_ShapeLike] = ..., + axis: None | _ShapeLike = ..., out: None = ..., keepdims: bool = ..., + *, + where: _ArrayLikeBool_co = ..., ) -> Any: ... @overload def all( self, - axis: Optional[_ShapeLike] = ..., + axis: None | _ShapeLike = ..., out: _NdArraySubClass = ..., keepdims: bool = ..., + *, + where: _ArrayLikeBool_co = ..., ) -> _NdArraySubClass: ... @overload @@ -1052,20 +1069,26 @@ class _ArrayOrScalarCommon: axis: None = ..., out: None = ..., keepdims: L[False] = ..., + *, + where: _ArrayLikeBool_co = ..., ) -> bool_: ... @overload def any( self, - axis: Optional[_ShapeLike] = ..., + axis: None | _ShapeLike = ..., out: None = ..., keepdims: bool = ..., + *, + where: _ArrayLikeBool_co = ..., ) -> Any: ... @overload def any( self, - axis: Optional[_ShapeLike] = ..., + axis: None | _ShapeLike = ..., out: _NdArraySubClass = ..., keepdims: bool = ..., + *, + where: _ArrayLikeBool_co = ..., ) -> _NdArraySubClass: ... @overload @@ -1079,7 +1102,7 @@ class _ArrayOrScalarCommon: @overload def argmax( self, - axis: _ShapeLike = ..., + axis: SupportsIndex = ..., out: None = ..., *, keepdims: bool = ..., @@ -1087,7 +1110,7 @@ class _ArrayOrScalarCommon: @overload def argmax( self, - axis: Optional[_ShapeLike] = ..., + axis: None | SupportsIndex = ..., out: _NdArraySubClass = ..., *, keepdims: bool = ..., @@ -1104,7 +1127,7 @@ class _ArrayOrScalarCommon: @overload def argmin( self, - axis: _ShapeLike = ..., + axis: SupportsIndex = ..., out: None = ..., *, keepdims: bool = ..., @@ -1112,7 +1135,7 @@ class _ArrayOrScalarCommon: @overload def argmin( self, - axis: Optional[_ShapeLike] = ..., + axis: None | SupportsIndex = ..., out: _NdArraySubClass = ..., *, keepdims: bool = ..., @@ -1120,9 +1143,9 @@ class _ArrayOrScalarCommon: def argsort( self, - axis: Optional[SupportsIndex] = ..., - kind: Optional[_SortKind] = ..., - order: Union[None, str, Sequence[str]] = ..., + axis: None | SupportsIndex = ..., + kind: None | _SortKind = ..., + order: None | str | Sequence[str] = ..., ) -> ndarray: ... @overload @@ -1144,7 +1167,7 @@ class _ArrayOrScalarCommon: def clip( self, min: ArrayLike = ..., - max: Optional[ArrayLike] = ..., + max: None | ArrayLike = ..., out: None = ..., **kwargs: Any, ) -> ndarray: ... @@ -1160,7 +1183,7 @@ class _ArrayOrScalarCommon: def clip( self, min: ArrayLike = ..., - max: Optional[ArrayLike] = ..., + max: None | ArrayLike = ..., out: _NdArraySubClass = ..., **kwargs: Any, ) -> _NdArraySubClass: ... @@ -1177,14 +1200,14 @@ class _ArrayOrScalarCommon: def compress( self, a: ArrayLike, - axis: Optional[SupportsIndex] = ..., + axis: None | SupportsIndex = ..., out: None = ..., ) -> ndarray: ... @overload def compress( self, a: ArrayLike, - axis: Optional[SupportsIndex] = ..., + axis: None | SupportsIndex = ..., out: _NdArraySubClass = ..., ) -> _NdArraySubClass: ... @@ -1195,14 +1218,14 @@ class _ArrayOrScalarCommon: @overload def cumprod( self, - axis: Optional[SupportsIndex] = ..., + axis: None | SupportsIndex = ..., dtype: DTypeLike = ..., out: None = ..., ) -> ndarray: ... @overload def cumprod( self, - axis: Optional[SupportsIndex] = ..., + axis: None | SupportsIndex = ..., dtype: DTypeLike = ..., out: _NdArraySubClass = ..., ) -> _NdArraySubClass: ... @@ -1210,14 +1233,14 @@ class _ArrayOrScalarCommon: @overload def cumsum( self, - axis: Optional[SupportsIndex] = ..., + axis: None | SupportsIndex = ..., dtype: DTypeLike = ..., out: None = ..., ) -> ndarray: ... @overload def cumsum( self, - axis: Optional[SupportsIndex] = ..., + axis: None | SupportsIndex = ..., dtype: DTypeLike = ..., out: _NdArraySubClass = ..., ) -> _NdArraySubClass: ... @@ -1225,7 +1248,7 @@ class _ArrayOrScalarCommon: @overload def max( self, - axis: Optional[_ShapeLike] = ..., + axis: None | _ShapeLike = ..., out: None = ..., keepdims: bool = ..., initial: _NumberLike_co = ..., @@ -1234,7 +1257,7 @@ class _ArrayOrScalarCommon: @overload def max( self, - axis: Optional[_ShapeLike] = ..., + axis: None | _ShapeLike = ..., out: _NdArraySubClass = ..., keepdims: bool = ..., initial: _NumberLike_co = ..., @@ -1244,24 +1267,28 @@ class _ArrayOrScalarCommon: @overload def mean( self, - axis: Optional[_ShapeLike] = ..., + axis: None | _ShapeLike = ..., dtype: DTypeLike = ..., out: None = ..., keepdims: bool = ..., + *, + where: _ArrayLikeBool_co = ..., ) -> Any: ... @overload def mean( self, - axis: Optional[_ShapeLike] = ..., + axis: None | _ShapeLike = ..., dtype: DTypeLike = ..., out: _NdArraySubClass = ..., keepdims: bool = ..., + *, + where: _ArrayLikeBool_co = ..., ) -> _NdArraySubClass: ... @overload def min( self, - axis: Optional[_ShapeLike] = ..., + axis: None | _ShapeLike = ..., out: None = ..., keepdims: bool = ..., initial: _NumberLike_co = ..., @@ -1270,7 +1297,7 @@ class _ArrayOrScalarCommon: @overload def min( self, - axis: Optional[_ShapeLike] = ..., + axis: None | _ShapeLike = ..., out: _NdArraySubClass = ..., keepdims: bool = ..., initial: _NumberLike_co = ..., @@ -1285,7 +1312,7 @@ class _ArrayOrScalarCommon: @overload def prod( self, - axis: Optional[_ShapeLike] = ..., + axis: None | _ShapeLike = ..., dtype: DTypeLike = ..., out: None = ..., keepdims: bool = ..., @@ -1295,7 +1322,7 @@ class _ArrayOrScalarCommon: @overload def prod( self, - axis: Optional[_ShapeLike] = ..., + axis: None | _ShapeLike = ..., dtype: DTypeLike = ..., out: _NdArraySubClass = ..., keepdims: bool = ..., @@ -1306,14 +1333,14 @@ class _ArrayOrScalarCommon: @overload def ptp( self, - axis: Optional[_ShapeLike] = ..., + axis: None | _ShapeLike = ..., out: None = ..., keepdims: bool = ..., ) -> Any: ... @overload def ptp( self, - axis: Optional[_ShapeLike] = ..., + axis: None | _ShapeLike = ..., out: _NdArraySubClass = ..., keepdims: bool = ..., ) -> _NdArraySubClass: ... @@ -1334,26 +1361,30 @@ class _ArrayOrScalarCommon: @overload def std( self, - axis: Optional[_ShapeLike] = ..., + axis: None | _ShapeLike = ..., dtype: DTypeLike = ..., out: None = ..., - ddof: int = ..., + ddof: float = ..., keepdims: bool = ..., + *, + where: _ArrayLikeBool_co = ..., ) -> Any: ... @overload def std( self, - axis: Optional[_ShapeLike] = ..., + axis: None | _ShapeLike = ..., dtype: DTypeLike = ..., out: _NdArraySubClass = ..., - ddof: int = ..., + ddof: float = ..., keepdims: bool = ..., + *, + where: _ArrayLikeBool_co = ..., ) -> _NdArraySubClass: ... @overload def sum( self, - axis: Optional[_ShapeLike] = ..., + axis: None | _ShapeLike = ..., dtype: DTypeLike = ..., out: None = ..., keepdims: bool = ..., @@ -1363,7 +1394,7 @@ class _ArrayOrScalarCommon: @overload def sum( self, - axis: Optional[_ShapeLike] = ..., + axis: None | _ShapeLike = ..., dtype: DTypeLike = ..., out: _NdArraySubClass = ..., keepdims: bool = ..., @@ -1374,20 +1405,24 @@ class _ArrayOrScalarCommon: @overload def var( self, - axis: Optional[_ShapeLike] = ..., + axis: None | _ShapeLike = ..., dtype: DTypeLike = ..., out: None = ..., - ddof: int = ..., + ddof: float = ..., keepdims: bool = ..., + *, + where: _ArrayLikeBool_co = ..., ) -> Any: ... @overload def var( self, - axis: Optional[_ShapeLike] = ..., + axis: None | _ShapeLike = ..., dtype: DTypeLike = ..., out: _NdArraySubClass = ..., - ddof: int = ..., + ddof: float = ..., keepdims: bool = ..., + *, + where: _ArrayLikeBool_co = ..., ) -> _NdArraySubClass: ... _DType = TypeVar("_DType", bound=dtype[Any]) @@ -1401,7 +1436,7 @@ _ShapeType2 = TypeVar("_ShapeType2", bound=Any) _NumberType = TypeVar("_NumberType", bound=number[Any]) # There is currently no exhaustive way to type the buffer protocol, -# as it is implemented exclusivelly in the C API (python/typing#593) +# as it is implemented exclusively in the C API (python/typing#593) _SupportsBuffer = Union[ bytes, bytearray, @@ -1415,15 +1450,9 @@ _SupportsBuffer = Union[ _T = TypeVar("_T") _T_co = TypeVar("_T_co", covariant=True) _T_contra = TypeVar("_T_contra", contravariant=True) -_2Tuple = Tuple[_T, _T] +_2Tuple = tuple[_T, _T] _CastingKind = L["no", "equiv", "safe", "same_kind", "unsafe"] -_DTypeLike = Union[ - dtype[_ScalarType], - Type[_ScalarType], - _SupportsDType[dtype[_ScalarType]], -] - _ArrayUInt_co = NDArray[Union[bool_, unsignedinteger[Any]]] _ArrayInt_co = NDArray[Union[bool_, integer[Any]]] _ArrayFloat_co = NDArray[Union[bool_, integer[Any], floating[Any]]] @@ -1450,26 +1479,27 @@ class _SupportsImag(Protocol[_T_co]): def imag(self) -> _T_co: ... class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]): + __hash__: ClassVar[None] @property - def base(self) -> Optional[ndarray]: ... + def base(self) -> None | ndarray: ... @property def ndim(self) -> int: ... @property def size(self) -> int: ... @property def real( - self: NDArray[_SupportsReal[_ScalarType]], # type: ignore[type-var] + self: ndarray[_ShapeType, dtype[_SupportsReal[_ScalarType]]], # type: ignore[type-var] ) -> ndarray[_ShapeType, _dtype[_ScalarType]]: ... @real.setter def real(self, value: ArrayLike) -> None: ... @property def imag( - self: NDArray[_SupportsImag[_ScalarType]], # type: ignore[type-var] + self: ndarray[_ShapeType, dtype[_SupportsImag[_ScalarType]]], # type: ignore[type-var] ) -> ndarray[_ShapeType, _dtype[_ScalarType]]: ... @imag.setter def imag(self, value: ArrayLike) -> None: ... def __new__( - cls: Type[_ArraySelf], + cls: type[_ArraySelf], shape: _ShapeLike, dtype: DTypeLike = ..., buffer: None | _SupportsBuffer = ..., @@ -1502,38 +1532,42 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]): kwargs: Mapping[str, Any], ) -> Any: ... - @property - def __array_finalize__(self) -> None: ... + # NOTE: In practice any object is accepted by `obj`, but as `__array_finalize__` + # is a pseudo-abstract method the type has been narrowed down in order to + # grant subclasses a bit more flexiblity + def __array_finalize__(self, obj: None | NDArray[Any], /) -> None: ... def __array_wrap__( self, array: ndarray[_ShapeType2, _DType], - context: None | Tuple[ufunc, Tuple[Any, ...], int] = ..., + context: None | tuple[ufunc, tuple[Any, ...], int] = ..., /, ) -> ndarray[_ShapeType2, _DType]: ... def __array_prepare__( self, array: ndarray[_ShapeType2, _DType], - context: None | Tuple[ufunc, Tuple[Any, ...], int] = ..., + context: None | tuple[ufunc, tuple[Any, ...], int] = ..., /, ) -> ndarray[_ShapeType2, _DType]: ... @overload - def __getitem__(self, key: Union[ - SupportsIndex, - _ArrayLikeInt_co, - Tuple[SupportsIndex | _ArrayLikeInt_co, ...], - ]) -> Any: ... + def __getitem__(self, key: ( + NDArray[integer[Any]] + | NDArray[bool_] + | tuple[NDArray[integer[Any]] | NDArray[bool_], ...] + )) -> ndarray[Any, _DType_co]: ... + @overload + def __getitem__(self, key: SupportsIndex | tuple[SupportsIndex, ...]) -> Any: ... @overload - def __getitem__(self, key: Union[ - None, - slice, - ellipsis, - SupportsIndex, - _ArrayLikeInt_co, - Tuple[None | slice | ellipsis | _ArrayLikeInt_co | SupportsIndex, ...], - ]) -> ndarray[Any, _DType_co]: ... + def __getitem__(self, key: ( + None + | slice + | ellipsis + | SupportsIndex + | _ArrayLikeInt_co + | tuple[None | slice | ellipsis | _ArrayLikeInt_co | SupportsIndex, ...] + )) -> ndarray[Any, _DType_co]: ... @overload def __getitem__(self: NDArray[void], key: str) -> NDArray[Any]: ... @overload @@ -1563,7 +1597,7 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]): @overload def item( self: ndarray[Any, _dtype[_SupportsItem[_T]]], # type: ignore[type-var] - args: Tuple[SupportsIndex, ...], + args: tuple[SupportsIndex, ...], /, ) -> _T: ... @@ -1583,7 +1617,7 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]): def squeeze( self, - axis: Union[SupportsIndex, Tuple[SupportsIndex, ...]] = ..., + axis: None | SupportsIndex | tuple[SupportsIndex, ...] = ..., ) -> ndarray[Any, _DType_co]: ... def swapaxes( @@ -1593,16 +1627,16 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]): ) -> ndarray[Any, _DType_co]: ... @overload - def transpose(self: _ArraySelf, axes: _ShapeLike, /) -> _ArraySelf: ... + def transpose(self: _ArraySelf, axes: None | _ShapeLike, /) -> _ArraySelf: ... @overload def transpose(self: _ArraySelf, *axes: SupportsIndex) -> _ArraySelf: ... def argpartition( self, kth: _ArrayLikeInt_co, - axis: Optional[SupportsIndex] = ..., + axis: None | SupportsIndex = ..., kind: _PartitionKind = ..., - order: Union[None, str, Sequence[str]] = ..., + order: None | str | Sequence[str] = ..., ) -> ndarray[Any, _dtype[intp]]: ... def diagonal( @@ -1622,14 +1656,14 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]): def dot(self, b: ArrayLike, out: _NdArraySubClass) -> _NdArraySubClass: ... # `nonzero()` is deprecated for 0d arrays/generics - def nonzero(self) -> Tuple[ndarray[Any, _dtype[intp]], ...]: ... + def nonzero(self) -> tuple[ndarray[Any, _dtype[intp]], ...]: ... def partition( self, kth: _ArrayLikeInt_co, axis: SupportsIndex = ..., kind: _PartitionKind = ..., - order: Union[None, str, Sequence[str]] = ..., + order: None | str | Sequence[str] = ..., ) -> None: ... # `put` is technically available to `generic`, @@ -1646,14 +1680,14 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]): self, # >= 1D array v: _ScalarLike_co, # 0D array-like side: _SortSide = ..., - sorter: Optional[_ArrayLikeInt_co] = ..., + sorter: None | _ArrayLikeInt_co = ..., ) -> intp: ... @overload def searchsorted( self, # >= 1D array v: ArrayLike, side: _SortSide = ..., - sorter: Optional[_ArrayLikeInt_co] = ..., + sorter: None | _ArrayLikeInt_co = ..., ) -> ndarray[Any, _dtype[intp]]: ... def setfield( @@ -1666,8 +1700,8 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]): def sort( self, axis: SupportsIndex = ..., - kind: Optional[_SortKind] = ..., - order: Union[None, str, Sequence[str]] = ..., + kind: None | _SortKind = ..., + order: None | str | Sequence[str] = ..., ) -> None: ... @overload @@ -1693,7 +1727,7 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]): def take( # type: ignore[misc] self: ndarray[Any, _dtype[_ScalarType]], indices: _IntLike_co, - axis: Optional[SupportsIndex] = ..., + axis: None | SupportsIndex = ..., out: None = ..., mode: _ModeKind = ..., ) -> _ScalarType: ... @@ -1701,7 +1735,7 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]): def take( # type: ignore[misc] self, indices: _ArrayLikeInt_co, - axis: Optional[SupportsIndex] = ..., + axis: None | SupportsIndex = ..., out: None = ..., mode: _ModeKind = ..., ) -> ndarray[Any, _DType_co]: ... @@ -1709,7 +1743,7 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]): def take( self, indices: _ArrayLikeInt_co, - axis: Optional[SupportsIndex] = ..., + axis: None | SupportsIndex = ..., out: _NdArraySubClass = ..., mode: _ModeKind = ..., ) -> _NdArraySubClass: ... @@ -1717,7 +1751,7 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]): def repeat( self, repeats: _ArrayLikeInt_co, - axis: Optional[SupportsIndex] = ..., + axis: None | SupportsIndex = ..., ) -> ndarray[Any, _DType_co]: ... def flatten( @@ -1761,7 +1795,7 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]): @overload def view(self: _ArraySelf) -> _ArraySelf: ... @overload - def view(self, type: Type[_NdArraySubClass]) -> _NdArraySubClass: ... + def view(self, type: type[_NdArraySubClass]) -> _NdArraySubClass: ... @overload def view(self, dtype: _DTypeLike[_ScalarType]) -> NDArray[_ScalarType]: ... @overload @@ -1770,7 +1804,7 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]): def view( self, dtype: DTypeLike, - type: Type[_NdArraySubClass], + type: type[_NdArraySubClass], ) -> _NdArraySubClass: ... @overload @@ -1904,6 +1938,8 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]): @overload def __matmul__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ... @overload + def __matmul__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co) -> NDArray[number[Any]]: ... + @overload def __matmul__(self: NDArray[object_], other: Any) -> Any: ... @overload def __matmul__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... @@ -1919,6 +1955,8 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]): @overload def __rmatmul__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ... @overload + def __rmatmul__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co) -> NDArray[number[Any]]: ... + @overload def __rmatmul__(self: NDArray[object_], other: Any) -> Any: ... @overload def __rmatmul__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... @@ -1962,7 +2000,7 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]): @overload def __divmod__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co) -> _2Tuple[NDArray[floating[Any]]]: ... # type: ignore[misc] @overload - def __divmod__(self: _ArrayTD64_co, other: _SupportsArray[_dtype[timedelta64]] | _NestedSequence[_SupportsArray[_dtype[timedelta64]]]) -> Tuple[NDArray[int64], NDArray[timedelta64]]: ... + def __divmod__(self: _ArrayTD64_co, other: _SupportsArray[_dtype[timedelta64]] | _NestedSequence[_SupportsArray[_dtype[timedelta64]]]) -> tuple[NDArray[int64], NDArray[timedelta64]]: ... @overload def __rdivmod__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> _2Tuple[NDArray[int8]]: ... # type: ignore[misc] @@ -1973,7 +2011,7 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]): @overload def __rdivmod__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co) -> _2Tuple[NDArray[floating[Any]]]: ... # type: ignore[misc] @overload - def __rdivmod__(self: _ArrayTD64_co, other: _SupportsArray[_dtype[timedelta64]] | _NestedSequence[_SupportsArray[_dtype[timedelta64]]]) -> Tuple[NDArray[int64], NDArray[timedelta64]]: ... + def __rdivmod__(self: _ArrayTD64_co, other: _SupportsArray[_dtype[timedelta64]] | _NestedSequence[_SupportsArray[_dtype[timedelta64]]]) -> tuple[NDArray[int64], NDArray[timedelta64]]: ... @overload def __add__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[bool_]: ... # type: ignore[misc] @@ -1986,6 +2024,8 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]): @overload def __add__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ... # type: ignore[misc] @overload + def __add__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co) -> NDArray[number[Any]]: ... + @overload def __add__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co) -> NDArray[timedelta64]: ... # type: ignore[misc] @overload def __add__(self: _ArrayTD64_co, other: _ArrayLikeDT64_co) -> NDArray[datetime64]: ... @@ -2007,6 +2047,8 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]): @overload def __radd__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ... # type: ignore[misc] @overload + def __radd__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co) -> NDArray[number[Any]]: ... + @overload def __radd__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co) -> NDArray[timedelta64]: ... # type: ignore[misc] @overload def __radd__(self: _ArrayTD64_co, other: _ArrayLikeDT64_co) -> NDArray[datetime64]: ... @@ -2017,6 +2059,8 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]): @overload def __radd__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... + @overload + def __sub__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown) -> NDArray[Any]: ... @overload def __sub__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NoReturn: ... @overload @@ -2028,6 +2072,8 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]): @overload def __sub__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ... # type: ignore[misc] @overload + def __sub__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co) -> NDArray[number[Any]]: ... + @overload def __sub__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co) -> NDArray[timedelta64]: ... # type: ignore[misc] @overload def __sub__(self: NDArray[datetime64], other: _ArrayLikeTD64_co) -> NDArray[datetime64]: ... @@ -2038,6 +2084,8 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]): @overload def __sub__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... + @overload + def __rsub__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown) -> NDArray[Any]: ... @overload def __rsub__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NoReturn: ... @overload @@ -2049,6 +2097,8 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]): @overload def __rsub__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ... # type: ignore[misc] @overload + def __rsub__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co) -> NDArray[number[Any]]: ... + @overload def __rsub__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co) -> NDArray[timedelta64]: ... # type: ignore[misc] @overload def __rsub__(self: _ArrayTD64_co, other: _ArrayLikeDT64_co) -> NDArray[datetime64]: ... # type: ignore[misc] @@ -2070,6 +2120,8 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]): @overload def __mul__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ... # type: ignore[misc] @overload + def __mul__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co) -> NDArray[number[Any]]: ... + @overload def __mul__(self: _ArrayTD64_co, other: _ArrayLikeFloat_co) -> NDArray[timedelta64]: ... @overload def __mul__(self: _ArrayFloat_co, other: _ArrayLikeTD64_co) -> NDArray[timedelta64]: ... @@ -2089,6 +2141,8 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]): @overload def __rmul__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ... # type: ignore[misc] @overload + def __rmul__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co) -> NDArray[number[Any]]: ... + @overload def __rmul__(self: _ArrayTD64_co, other: _ArrayLikeFloat_co) -> NDArray[timedelta64]: ... @overload def __rmul__(self: _ArrayFloat_co, other: _ArrayLikeTD64_co) -> NDArray[timedelta64]: ... @@ -2146,6 +2200,8 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]): @overload def __pow__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ... @overload + def __pow__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co) -> NDArray[number[Any]]: ... + @overload def __pow__(self: NDArray[object_], other: Any) -> Any: ... @overload def __pow__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... @@ -2161,6 +2217,8 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]): @overload def __rpow__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ... @overload + def __rpow__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co) -> NDArray[number[Any]]: ... + @overload def __rpow__(self: NDArray[object_], other: Any) -> Any: ... @overload def __rpow__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... @@ -2172,6 +2230,8 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]): @overload def __truediv__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ... # type: ignore[misc] @overload + def __truediv__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co) -> NDArray[number[Any]]: ... + @overload def __truediv__(self: NDArray[timedelta64], other: _SupportsArray[_dtype[timedelta64]] | _NestedSequence[_SupportsArray[_dtype[timedelta64]]]) -> NDArray[float64]: ... @overload def __truediv__(self: NDArray[timedelta64], other: _ArrayLikeBool_co) -> NoReturn: ... @@ -2189,6 +2249,8 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]): @overload def __rtruediv__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ... # type: ignore[misc] @overload + def __rtruediv__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co) -> NDArray[number[Any]]: ... + @overload def __rtruediv__(self: NDArray[timedelta64], other: _SupportsArray[_dtype[timedelta64]] | _NestedSequence[_SupportsArray[_dtype[timedelta64]]]) -> NDArray[float64]: ... @overload def __rtruediv__(self: NDArray[bool_], other: _ArrayLikeTD64_co) -> NoReturn: ... @@ -2310,10 +2372,15 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]): def __ror__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... # `np.generic` does not support inplace operations + + # NOTE: Inplace ops generally use "same_kind" casting w.r.t. to the left + # operand. An exception to this rule are unsigned integers though, which + # also accepts a signed integer for the right operand as long it is a 0D + # object and its value is >= 0 @overload def __iadd__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[bool_]: ... @overload - def __iadd__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[_NBit1]]: ... + def __iadd__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co) -> NDArray[unsignedinteger[_NBit1]]: ... @overload def __iadd__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co) -> NDArray[signedinteger[_NBit1]]: ... @overload @@ -2328,7 +2395,7 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]): def __iadd__(self: NDArray[object_], other: Any) -> NDArray[object_]: ... @overload - def __isub__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[_NBit1]]: ... + def __isub__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co) -> NDArray[unsignedinteger[_NBit1]]: ... @overload def __isub__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co) -> NDArray[signedinteger[_NBit1]]: ... @overload @@ -2345,7 +2412,7 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]): @overload def __imul__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[bool_]: ... @overload - def __imul__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[_NBit1]]: ... + def __imul__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co) -> NDArray[unsignedinteger[_NBit1]]: ... @overload def __imul__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co) -> NDArray[signedinteger[_NBit1]]: ... @overload @@ -2369,7 +2436,7 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]): def __itruediv__(self: NDArray[object_], other: Any) -> NDArray[object_]: ... @overload - def __ifloordiv__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[_NBit1]]: ... + def __ifloordiv__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co) -> NDArray[unsignedinteger[_NBit1]]: ... @overload def __ifloordiv__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co) -> NDArray[signedinteger[_NBit1]]: ... @overload @@ -2384,7 +2451,7 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]): def __ifloordiv__(self: NDArray[object_], other: Any) -> NDArray[object_]: ... @overload - def __ipow__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[_NBit1]]: ... + def __ipow__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co) -> NDArray[unsignedinteger[_NBit1]]: ... @overload def __ipow__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co) -> NDArray[signedinteger[_NBit1]]: ... @overload @@ -2395,7 +2462,7 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]): def __ipow__(self: NDArray[object_], other: Any) -> NDArray[object_]: ... @overload - def __imod__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[_NBit1]]: ... + def __imod__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co) -> NDArray[unsignedinteger[_NBit1]]: ... @overload def __imod__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co) -> NDArray[signedinteger[_NBit1]]: ... @overload @@ -2406,14 +2473,14 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]): def __imod__(self: NDArray[object_], other: Any) -> NDArray[object_]: ... @overload - def __ilshift__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[_NBit1]]: ... + def __ilshift__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co) -> NDArray[unsignedinteger[_NBit1]]: ... @overload def __ilshift__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co) -> NDArray[signedinteger[_NBit1]]: ... @overload def __ilshift__(self: NDArray[object_], other: Any) -> NDArray[object_]: ... @overload - def __irshift__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[_NBit1]]: ... + def __irshift__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co) -> NDArray[unsignedinteger[_NBit1]]: ... @overload def __irshift__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co) -> NDArray[signedinteger[_NBit1]]: ... @overload @@ -2422,7 +2489,7 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]): @overload def __iand__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[bool_]: ... @overload - def __iand__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[_NBit1]]: ... + def __iand__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co) -> NDArray[unsignedinteger[_NBit1]]: ... @overload def __iand__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co) -> NDArray[signedinteger[_NBit1]]: ... @overload @@ -2431,7 +2498,7 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]): @overload def __ixor__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[bool_]: ... @overload - def __ixor__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[_NBit1]]: ... + def __ixor__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co) -> NDArray[unsignedinteger[_NBit1]]: ... @overload def __ixor__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co) -> NDArray[signedinteger[_NBit1]]: ... @overload @@ -2440,17 +2507,14 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]): @overload def __ior__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[bool_]: ... @overload - def __ior__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[_NBit1]]: ... + def __ior__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co) -> NDArray[unsignedinteger[_NBit1]]: ... @overload def __ior__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co) -> NDArray[signedinteger[_NBit1]]: ... @overload def __ior__(self: NDArray[object_], other: Any) -> NDArray[object_]: ... - @overload - def __ior__(self: NDArray[_ScalarType], other: _RecursiveSequence) -> NDArray[_ScalarType]: ... - @overload + def __dlpack__(self: NDArray[number[Any]], *, stream: None = ...) -> _PyCapsule: ... - @overload - def __dlpack_device__(self) -> Tuple[int, L[0]]: ... + def __dlpack_device__(self) -> tuple[int, L[0]]: ... # Keep `dtype` at the bottom to avoid name conflicts with `np.dtype` @property @@ -2482,9 +2546,9 @@ class generic(_ArrayOrScalarCommon): @property def size(self) -> L[1]: ... @property - def shape(self) -> Tuple[()]: ... + def shape(self) -> tuple[()]: ... @property - def strides(self) -> Tuple[()]: ... + def strides(self) -> tuple[()]: ... def byteswap(self: _ScalarType, inplace: L[False] = ...) -> _ScalarType: ... @property def flat(self: _ScalarType) -> flatiter[ndarray[Any, _dtype[_ScalarType]]]: ... @@ -2513,19 +2577,19 @@ class generic(_ArrayOrScalarCommon): @overload def view( self: _ScalarType, - type: Type[ndarray[Any, Any]] = ..., + type: type[ndarray[Any, Any]] = ..., ) -> _ScalarType: ... @overload def view( self, dtype: _DTypeLike[_ScalarType], - type: Type[ndarray[Any, Any]] = ..., + type: type[ndarray[Any, Any]] = ..., ) -> _ScalarType: ... @overload def view( self, dtype: DTypeLike, - type: Type[ndarray[Any, Any]] = ..., + type: type[ndarray[Any, Any]] = ..., ) -> Any: ... @overload @@ -2542,14 +2606,14 @@ class generic(_ArrayOrScalarCommon): ) -> Any: ... def item( - self, args: L[0] | Tuple[()] | Tuple[L[0]] = ..., /, + self, args: L[0] | tuple[()] | tuple[L[0]] = ..., /, ) -> Any: ... @overload def take( # type: ignore[misc] self: _ScalarType, indices: _IntLike_co, - axis: Optional[SupportsIndex] = ..., + axis: None | SupportsIndex = ..., out: None = ..., mode: _ModeKind = ..., ) -> _ScalarType: ... @@ -2557,7 +2621,7 @@ class generic(_ArrayOrScalarCommon): def take( # type: ignore[misc] self: _ScalarType, indices: _ArrayLikeInt_co, - axis: Optional[SupportsIndex] = ..., + axis: None | SupportsIndex = ..., out: None = ..., mode: _ModeKind = ..., ) -> ndarray[Any, _dtype[_ScalarType]]: ... @@ -2565,7 +2629,7 @@ class generic(_ArrayOrScalarCommon): def take( self, indices: _ArrayLikeInt_co, - axis: Optional[SupportsIndex] = ..., + axis: None | SupportsIndex = ..., out: _NdArraySubClass = ..., mode: _ModeKind = ..., ) -> _NdArraySubClass: ... @@ -2573,7 +2637,7 @@ class generic(_ArrayOrScalarCommon): def repeat( self: _ScalarType, repeats: _ArrayLikeInt_co, - axis: Optional[SupportsIndex] = ..., + axis: None | SupportsIndex = ..., ) -> ndarray[Any, _dtype[_ScalarType]]: ... def flatten( @@ -2596,9 +2660,9 @@ class generic(_ArrayOrScalarCommon): ) -> ndarray[Any, _dtype[_ScalarType]]: ... def squeeze( - self: _ScalarType, axis: Union[L[0], Tuple[()]] = ... + self: _ScalarType, axis: None | L[0] | tuple[()] = ... ) -> _ScalarType: ... - def transpose(self: _ScalarType, axes: Tuple[()] = ..., /) -> _ScalarType: ... + def transpose(self: _ScalarType, axes: None | tuple[()] = ..., /) -> _ScalarType: ... # Keep `dtype` at the bottom to avoid name conflicts with `np.dtype` @property def dtype(self: _ScalarType) -> _dtype[_ScalarType]: ... @@ -2637,7 +2701,7 @@ class number(generic, Generic[_NBit1]): # type: ignore class bool_(generic): def __init__(self, value: object = ..., /) -> None: ... def item( - self, args: L[0] | Tuple[()] | Tuple[L[0]] = ..., /, + self, args: L[0] | tuple[()] | tuple[L[0]] = ..., /, ) -> bool: ... def tolist(self) -> bool: ... @property @@ -2680,8 +2744,6 @@ class bool_(generic): __gt__: _ComparisonOp[_NumberLike_co, _ArrayLikeNumber_co] __ge__: _ComparisonOp[_NumberLike_co, _ArrayLikeNumber_co] -bool8 = bool_ - class object_(generic): def __init__(self, value: object = ..., /) -> None: ... @property @@ -2694,8 +2756,6 @@ class object_(generic): def __float__(self) -> float: ... def __complex__(self) -> complex: ... -object0 = object_ - # The `datetime64` constructors requires an object with the three attributes below, # and thus supports datetime duck typing class _DatetimeScalar(Protocol): @@ -2713,14 +2773,14 @@ class datetime64(generic): def __init__( self, value: None | datetime64 | _CharLike_co | _DatetimeScalar = ..., - format: _CharLike_co | Tuple[_CharLike_co, _IntLike_co] = ..., + format: _CharLike_co | tuple[_CharLike_co, _IntLike_co] = ..., /, ) -> None: ... @overload def __init__( self, value: int, - format: _CharLike_co | Tuple[_CharLike_co, _IntLike_co], + format: _CharLike_co | tuple[_CharLike_co, _IntLike_co], /, ) -> None: ... def __add__(self, other: _TD64Like_co) -> datetime64: ... @@ -2759,7 +2819,7 @@ class integer(number[_NBit1]): # type: ignore # NOTE: `__index__` is technically defined in the bottom-most # sub-classes (`int64`, `uint32`, etc) def item( - self, args: L[0] | Tuple[()] | Tuple[L[0]] = ..., /, + self, args: L[0] | tuple[()] | tuple[L[0]] = ..., /, ) -> int: ... def tolist(self) -> int: ... def is_integer(self) -> L[True]: ... @@ -2818,7 +2878,6 @@ byte = signedinteger[_NBitByte] short = signedinteger[_NBitShort] intc = signedinteger[_NBitIntC] intp = signedinteger[_NBitIntP] -int0 = signedinteger[_NBitIntP] int_ = signedinteger[_NBitInt] longlong = signedinteger[_NBitLongLong] @@ -2828,7 +2887,7 @@ class timedelta64(generic): def __init__( self, value: None | int | _CharLike_co | dt.timedelta | timedelta64 = ..., - format: _CharLike_co | Tuple[_CharLike_co, _IntLike_co] = ..., + format: _CharLike_co | tuple[_CharLike_co, _IntLike_co] = ..., /, ) -> None: ... @property @@ -2856,8 +2915,8 @@ class timedelta64(generic): def __rfloordiv__(self, other: timedelta64) -> int64: ... def __mod__(self, other: timedelta64) -> timedelta64: ... def __rmod__(self, other: timedelta64) -> timedelta64: ... - def __divmod__(self, other: timedelta64) -> Tuple[int64, timedelta64]: ... - def __rdivmod__(self, other: timedelta64) -> Tuple[int64, timedelta64]: ... + def __divmod__(self, other: timedelta64) -> tuple[int64, timedelta64]: ... + def __rdivmod__(self, other: timedelta64) -> tuple[int64, timedelta64]: ... __lt__: _ComparisonOp[_TD64Like_co, _ArrayLikeTD64_co] __le__: _ComparisonOp[_TD64Like_co, _ArrayLikeTD64_co] __gt__: _ComparisonOp[_TD64Like_co, _ArrayLikeTD64_co] @@ -2900,12 +2959,11 @@ ubyte = unsignedinteger[_NBitByte] ushort = unsignedinteger[_NBitShort] uintc = unsignedinteger[_NBitIntC] uintp = unsignedinteger[_NBitIntP] -uint0 = unsignedinteger[_NBitIntP] uint = unsignedinteger[_NBitInt] ulonglong = unsignedinteger[_NBitLongLong] class inexact(number[_NBit1]): # type: ignore - def __getnewargs__(self: inexact[_64Bit]) -> Tuple[float, ...]: ... + def __getnewargs__(self: inexact[_64Bit]) -> tuple[float, ...]: ... _IntType = TypeVar("_IntType", bound=integer) _FloatType = TypeVar('_FloatType', bound=floating) @@ -2913,20 +2971,20 @@ _FloatType = TypeVar('_FloatType', bound=floating) class floating(inexact[_NBit1]): def __init__(self, value: _FloatValue = ..., /) -> None: ... def item( - self, args: L[0] | Tuple[()] | Tuple[L[0]] = ..., + self, args: L[0] | tuple[()] | tuple[L[0]] = ..., /, ) -> float: ... def tolist(self) -> float: ... def is_integer(self) -> bool: ... def hex(self: float64) -> str: ... @classmethod - def fromhex(cls: Type[float64], string: str, /) -> float64: ... - def as_integer_ratio(self) -> Tuple[int, int]: ... + def fromhex(cls: type[float64], string: str, /) -> float64: ... + def as_integer_ratio(self) -> tuple[int, int]: ... if sys.version_info >= (3, 9): def __ceil__(self: float64) -> int: ... def __floor__(self: float64) -> int: ... def __trunc__(self: float64) -> int: ... - def __getnewargs__(self: float64) -> Tuple[float]: ... + def __getnewargs__(self: float64) -> tuple[float]: ... def __getformat__(self: float64, typestr: L["double", "float"], /) -> str: ... @overload def __round__(self, ndigits: None = ...) -> int: ... @@ -2967,7 +3025,7 @@ longfloat = floating[_NBitLongDouble] class complexfloating(inexact[_NBit1], Generic[_NBit1, _NBit2]): def __init__(self, value: _ComplexValue = ..., /) -> None: ... def item( - self, args: L[0] | Tuple[()] | Tuple[L[0]] = ..., /, + self, args: L[0] | tuple[()] | tuple[L[0]] = ..., /, ) -> complex: ... def tolist(self) -> complex: ... @property @@ -2975,7 +3033,7 @@ class complexfloating(inexact[_NBit1], Generic[_NBit1, _NBit2]): @property def imag(self) -> floating[_NBit2]: ... # type: ignore[override] def __abs__(self) -> floating[_NBit1]: ... # type: ignore[override] - def __getnewargs__(self: complex128) -> Tuple[float, float]: ... + def __getnewargs__(self: complex128) -> tuple[float, float]: ... # NOTE: Deprecated # def __round__(self, ndigits=...): ... __add__: _ComplexOp[_NBit1] @@ -3007,7 +3065,10 @@ class flexible(generic): ... # type: ignore # depending on whether or not it's used as an opaque bytes sequence # or a structure class void(flexible): - def __init__(self, value: _IntLike_co | bytes, /) -> None: ... + @overload + def __init__(self, value: _IntLike_co | bytes, /, dtype : None = ...) -> None: ... + @overload + def __init__(self, value: Any, /, dtype: _DTypeLikeVoid) -> None: ... @property def real(self: _ArraySelf) -> _ArraySelf: ... @property @@ -3021,12 +3082,10 @@ class void(flexible): def __getitem__(self, key: list[str]) -> void: ... def __setitem__( self, - key: str | List[str] | SupportsIndex, + key: str | list[str] | SupportsIndex, value: ArrayLike, ) -> None: ... -void0 = void - class character(flexible): # type: ignore def __int__(self) -> int: ... def __float__(self) -> float: ... @@ -3042,12 +3101,11 @@ class bytes_(character, bytes): self, value: str, /, encoding: str = ..., errors: str = ... ) -> None: ... def item( - self, args: L[0] | Tuple[()] | Tuple[L[0]] = ..., /, + self, args: L[0] | tuple[()] | tuple[L[0]] = ..., /, ) -> bytes: ... def tolist(self) -> bytes: ... string_ = bytes_ -bytes0 = bytes_ class str_(character, str): @overload @@ -3057,12 +3115,11 @@ class str_(character, str): self, value: bytes, /, encoding: str = ..., errors: str = ... ) -> None: ... def item( - self, args: L[0] | Tuple[()] | Tuple[L[0]] = ..., /, + self, args: L[0] | tuple[()] | tuple[L[0]] = ..., /, ) -> str: ... def tolist(self) -> str: ... unicode_ = str_ -str0 = str_ # # Constants @@ -3083,10 +3140,6 @@ infty: Final[float] nan: Final[float] pi: Final[float] -CLIP: L[0] -WRAP: L[1] -RAISE: L[2] - ERR_IGNORE: L[0] ERR_WARN: L[1] ERR_RAISE: L[2] @@ -3116,7 +3169,8 @@ UFUNC_PYVALS_NAME: L["UFUNC_PYVALS"] newaxis: None -# See `npt._ufunc` for more concrete nin-/nout-specific stubs +# See `numpy._typing._ufunc` for more concrete nin-/nout-specific stubs +@final class ufunc: @property def __name__(self) -> str: ... @@ -3132,7 +3186,7 @@ class ufunc: @property def ntypes(self) -> int: ... @property - def types(self) -> List[str]: ... + def types(self) -> list[str]: ... # Broad return type because it has to encompass things like # # >>> np.logical_and.identity is True @@ -3147,14 +3201,14 @@ class ufunc: def identity(self) -> Any: ... # This is None for ufuncs and a string for gufuncs. @property - def signature(self) -> Optional[str]: ... + def signature(self) -> None | str: ... # The next four methods will always exist, but they will just # raise a ValueError ufuncs with that don't accept two input # arguments and return one output argument. Because of that we # can't type them very precisely. reduce: Any accumulate: Any - reduce: Any + reduceat: Any outer: Any # Similarly at won't be defined for ufuncs that return multiple # outputs, so we can't type it very precisely. @@ -3276,7 +3330,7 @@ class AxisError(ValueError, IndexError): @overload def __init__(self, axis: int, ndim: int, msg_prefix: None | str = ...) -> None: ... -_CallType = TypeVar("_CallType", bound=Union[_ErrFunc, _SupportsWrite[str]]) +_CallType = TypeVar("_CallType", bound=_ErrFunc | _SupportsWrite[str]) class errstate(Generic[_CallType], ContextDecorator): call: _CallType @@ -3287,21 +3341,26 @@ class errstate(Generic[_CallType], ContextDecorator): self, *, call: _CallType = ..., - all: Optional[_ErrKind] = ..., - divide: Optional[_ErrKind] = ..., - over: Optional[_ErrKind] = ..., - under: Optional[_ErrKind] = ..., - invalid: Optional[_ErrKind] = ..., + all: None | _ErrKind = ..., + divide: None | _ErrKind = ..., + over: None | _ErrKind = ..., + under: None | _ErrKind = ..., + invalid: None | _ErrKind = ..., ) -> None: ... def __enter__(self) -> None: ... def __exit__( self, - exc_type: Optional[Type[BaseException]], - exc_value: Optional[BaseException], - traceback: Optional[TracebackType], + exc_type: None | type[BaseException], + exc_value: None | BaseException, + traceback: None | TracebackType, /, ) -> None: ... +@contextmanager +def _no_nep50_warning() -> Generator[None, None, None]: ... +def _get_promotion_state() -> str: ... +def _set_promotion_state(state: str, /) -> None: ... + class ndenumerate(Generic[_ScalarType]): iter: flatiter[NDArray[_ScalarType]] @overload @@ -3320,10 +3379,13 @@ class ndenumerate(Generic[_ScalarType]): def __new__(cls, arr: float | _NestedSequence[float]) -> ndenumerate[float_]: ... @overload def __new__(cls, arr: complex | _NestedSequence[complex]) -> ndenumerate[complex_]: ... - def __next__(self: ndenumerate[_ScalarType]) -> Tuple[_Shape, _ScalarType]: ... + def __next__(self: ndenumerate[_ScalarType]) -> tuple[_Shape, _ScalarType]: ... def __iter__(self: _T) -> _T: ... class ndindex: + @overload + def __init__(self, shape: tuple[SupportsIndex, ...], /) -> None: ... + @overload def __init__(self, *shape: SupportsIndex) -> None: ... def __iter__(self: _T) -> _T: ... def __next__(self) -> _Shape: ... @@ -3331,7 +3393,7 @@ class ndindex: class DataSource: def __init__( self, - destpath: Union[None, str, os.PathLike[str]] = ..., + destpath: None | str | os.PathLike[str] = ..., ) -> None: ... def __del__(self) -> None: ... def abspath(self, path: str) -> str: ... @@ -3343,19 +3405,20 @@ class DataSource: self, path: str, mode: str = ..., - encoding: Optional[str] = ..., - newline: Optional[str] = ..., + encoding: None | str = ..., + newline: None | str = ..., ) -> IO[Any]: ... # TODO: The type of each `__next__` and `iters` return-type depends # on the length and dtype of `args`; we can't describe this behavior yet # as we lack variadics (PEP 646). +@final class broadcast: def __new__(cls, *args: ArrayLike) -> broadcast: ... @property def index(self) -> int: ... @property - def iters(self) -> Tuple[flatiter[Any], ...]: ... + def iters(self) -> tuple[flatiter[Any], ...]: ... @property def nd(self) -> int: ... @property @@ -3366,15 +3429,16 @@ class broadcast: def shape(self) -> _Shape: ... @property def size(self) -> int: ... - def __next__(self) -> Tuple[Any, ...]: ... + def __next__(self) -> tuple[Any, ...]: ... def __iter__(self: _T) -> _T: ... def reset(self) -> None: ... +@final class busdaycalendar: def __new__( cls, weekmask: ArrayLike = ..., - holidays: ArrayLike = ..., + holidays: ArrayLike | dt.date | _NestedSequence[dt.date] = ..., ) -> busdaycalendar: ... @property def weekmask(self) -> NDArray[bool_]: ... @@ -3408,7 +3472,7 @@ class finfo(Generic[_FloatType]): ) -> finfo[floating[_NBit1]]: ... @overload def __new__( - cls, dtype: complex | float | Type[complex] | Type[float] + cls, dtype: complex | float | type[complex] | type[float] ) -> finfo[float_]: ... @overload def __new__( @@ -3428,7 +3492,7 @@ class iinfo(Generic[_IntType]): @overload def __new__(cls, dtype: _IntType | _DTypeLike[_IntType]) -> iinfo[_IntType]: ... @overload - def __new__(cls, dtype: int | Type[int]) -> iinfo[int_]: ... + def __new__(cls, dtype: int | type[int]) -> iinfo[int_]: ... @overload def __new__(cls, dtype: str) -> iinfo[Any]: ... @@ -3482,29 +3546,29 @@ class recarray(ndarray[_ShapeType, _DType_co]): def __getattribute__(self, attr: str) -> Any: ... def __setattr__(self, attr: str, val: ArrayLike) -> None: ... @overload - def __getitem__(self, indx: Union[ - SupportsIndex, - _ArrayLikeInt_co, - Tuple[SupportsIndex | _ArrayLikeInt_co, ...], - ]) -> Any: ... - @overload - def __getitem__(self: recarray[Any, dtype[void]], indx: Union[ - None, - slice, - ellipsis, - SupportsIndex, - _ArrayLikeInt_co, - Tuple[None | slice | ellipsis | _ArrayLikeInt_co | SupportsIndex, ...], - ]) -> recarray[Any, _DType_co]: ... - @overload - def __getitem__(self, indx: Union[ - None, - slice, - ellipsis, - SupportsIndex, - _ArrayLikeInt_co, - Tuple[None | slice | ellipsis | _ArrayLikeInt_co | SupportsIndex, ...], - ]) -> ndarray[Any, _DType_co]: ... + def __getitem__(self, indx: ( + SupportsIndex + | _ArrayLikeInt_co + | tuple[SupportsIndex | _ArrayLikeInt_co, ...] + )) -> Any: ... + @overload + def __getitem__(self: recarray[Any, dtype[void]], indx: ( + None + | slice + | ellipsis + | SupportsIndex + | _ArrayLikeInt_co + | tuple[None | slice | ellipsis | _ArrayLikeInt_co | SupportsIndex, ...] + )) -> recarray[Any, _DType_co]: ... + @overload + def __getitem__(self, indx: ( + None + | slice + | ellipsis + | SupportsIndex + | _ArrayLikeInt_co + | tuple[None | slice | ellipsis | _ArrayLikeInt_co | SupportsIndex, ...] + )) -> ndarray[Any, _DType_co]: ... @overload def __getitem__(self, indx: str) -> NDArray[Any]: ... @overload @@ -3574,18 +3638,18 @@ class nditer: def __enter__(self) -> nditer: ... def __exit__( self, - exc_type: None | Type[BaseException], + exc_type: None | type[BaseException], exc_value: None | BaseException, traceback: None | TracebackType, ) -> None: ... def __iter__(self) -> nditer: ... - def __next__(self) -> Tuple[NDArray[Any], ...]: ... + def __next__(self) -> tuple[NDArray[Any], ...]: ... def __len__(self) -> int: ... def __copy__(self) -> nditer: ... @overload def __getitem__(self, index: SupportsIndex) -> NDArray[Any]: ... @overload - def __getitem__(self, index: slice) -> Tuple[NDArray[Any], ...]: ... + def __getitem__(self, index: slice) -> tuple[NDArray[Any], ...]: ... def __setitem__(self, index: slice | SupportsIndex, value: ArrayLike) -> None: ... def close(self) -> None: ... def copy(self) -> nditer: ... @@ -3596,7 +3660,7 @@ class nditer: def remove_multi_index(self) -> None: ... def reset(self) -> None: ... @property - def dtypes(self) -> Tuple[dtype[Any], ...]: ... + def dtypes(self) -> tuple[dtype[Any], ...]: ... @property def finished(self) -> bool: ... @property @@ -3612,23 +3676,23 @@ class nditer: @property def iterindex(self) -> int: ... @property - def iterrange(self) -> Tuple[int, ...]: ... + def iterrange(self) -> tuple[int, ...]: ... @property def itersize(self) -> int: ... @property - def itviews(self) -> Tuple[NDArray[Any], ...]: ... + def itviews(self) -> tuple[NDArray[Any], ...]: ... @property - def multi_index(self) -> Tuple[int, ...]: ... + def multi_index(self) -> tuple[int, ...]: ... @property def ndim(self) -> int: ... @property def nop(self) -> int: ... @property - def operands(self) -> Tuple[NDArray[Any], ...]: ... + def operands(self) -> tuple[NDArray[Any], ...]: ... @property - def shape(self) -> Tuple[int, ...]: ... + def shape(self) -> tuple[int, ...]: ... @property - def value(self) -> Tuple[NDArray[Any], ...]: ... + def value(self) -> tuple[NDArray[Any], ...]: ... _MemMapModeKind = L[ "readonly", "r", @@ -3646,10 +3710,10 @@ class memmap(ndarray[_ShapeType, _DType_co]): def __new__( subtype, filename: str | bytes | os.PathLike[str] | os.PathLike[bytes] | _MemMapIOProtocol, - dtype: Type[uint8] = ..., + dtype: type[uint8] = ..., mode: _MemMapModeKind = ..., offset: int = ..., - shape: None | int | Tuple[int, ...] = ..., + shape: None | int | tuple[int, ...] = ..., order: _OrderKACF = ..., ) -> memmap[Any, dtype[uint8]]: ... @overload @@ -3659,7 +3723,7 @@ class memmap(ndarray[_ShapeType, _DType_co]): dtype: _DTypeLike[_ScalarType], mode: _MemMapModeKind = ..., offset: int = ..., - shape: None | int | Tuple[int, ...] = ..., + shape: None | int | tuple[int, ...] = ..., order: _OrderKACF = ..., ) -> memmap[Any, dtype[_ScalarType]]: ... @overload @@ -3669,23 +3733,25 @@ class memmap(ndarray[_ShapeType, _DType_co]): dtype: DTypeLike, mode: _MemMapModeKind = ..., offset: int = ..., - shape: None | int | Tuple[int, ...] = ..., + shape: None | int | tuple[int, ...] = ..., order: _OrderKACF = ..., ) -> memmap[Any, dtype[Any]]: ... - def __array_finalize__(self, obj: memmap[Any, Any]) -> None: ... + def __array_finalize__(self, obj: object) -> None: ... def __array_wrap__( self, array: memmap[_ShapeType, _DType_co], - context: None | Tuple[ufunc, Tuple[Any, ...], int] = ..., + context: None | tuple[ufunc, tuple[Any, ...], int] = ..., ) -> Any: ... def flush(self) -> None: ... +# TODO: Add a mypy plugin for managing functions whose output type is dependent +# on the literal value of some sort of signature (e.g. `einsum` and `vectorize`) class vectorize: pyfunc: Callable[..., Any] cache: bool signature: None | str otypes: None | str - excluded: Set[int | str] + excluded: set[int | str] __doc__: None | str def __init__( self, @@ -3696,7 +3762,7 @@ class vectorize: cache: bool = ..., signature: None | str = ..., ) -> None: ... - def __call__(self, *args: Any, **kwargs: Any) -> NDArray[Any]: ... + def __call__(self, *args: Any, **kwargs: Any) -> Any: ... class poly1d: @property @@ -3730,7 +3796,7 @@ class poly1d: @coefficients.setter def coefficients(self, value: NDArray[Any]) -> None: ... - __hash__: None # type: ignore + __hash__: ClassVar[None] # type: ignore @overload def __array__(self, t: None = ...) -> NDArray[Any]: ... @@ -3782,23 +3848,23 @@ class matrix(ndarray[_ShapeType, _DType_co]): dtype: DTypeLike = ..., copy: bool = ..., ) -> matrix[Any, Any]: ... - def __array_finalize__(self, obj: NDArray[Any]) -> None: ... + def __array_finalize__(self, obj: object) -> None: ... @overload - def __getitem__(self, key: Union[ - SupportsIndex, - _ArrayLikeInt_co, - Tuple[SupportsIndex | _ArrayLikeInt_co, ...], - ]) -> Any: ... + def __getitem__(self, key: ( + SupportsIndex + | _ArrayLikeInt_co + | tuple[SupportsIndex | _ArrayLikeInt_co, ...] + )) -> Any: ... @overload - def __getitem__(self, key: Union[ - None, - slice, - ellipsis, - SupportsIndex, - _ArrayLikeInt_co, - Tuple[None | slice | ellipsis | _ArrayLikeInt_co | SupportsIndex, ...], - ]) -> matrix[Any, _DType_co]: ... + def __getitem__(self, key: ( + None + | slice + | ellipsis + | SupportsIndex + | _ArrayLikeInt_co + | tuple[None | slice | ellipsis | _ArrayLikeInt_co | SupportsIndex, ...] + )) -> matrix[Any, _DType_co]: ... @overload def __getitem__(self: NDArray[void], key: str) -> matrix[Any, dtype[Any]]: ... @overload @@ -3895,7 +3961,7 @@ class matrix(ndarray[_ShapeType, _DType_co]): def ptp(self, axis: None | _ShapeLike = ..., out: _NdArraySubClass = ...) -> _NdArraySubClass: ... def squeeze(self, axis: None | _ShapeLike = ...) -> matrix[Any, _DType_co]: ... - def tolist(self: matrix[Any, dtype[_SupportsItem[_T]]]) -> List[List[_T]]: ... # type: ignore[typevar] + def tolist(self: matrix[Any, dtype[_SupportsItem[_T]]]) -> list[list[_T]]: ... # type: ignore[typevar] def ravel(self, order: _OrderKACF = ...) -> matrix[Any, _DType_co]: ... def flatten(self, order: _OrderKACF = ...) -> matrix[Any, _DType_co]: ... @@ -3943,7 +4009,7 @@ class chararray(ndarray[_ShapeType, _CharDType]): order: _OrderKACF = ..., ) -> chararray[Any, dtype[str_]]: ... - def __array_finalize__(self, obj: NDArray[str_ | bytes_]) -> None: ... + def __array_finalize__(self, obj: object) -> None: ... def __mul__(self, other: _ArrayLikeInt_co) -> chararray[Any, _CharDType]: ... def __rmul__(self, other: _ArrayLikeInt_co) -> chararray[Any, _CharDType]: ... def __mod__(self, i: Any) -> chararray[Any, _CharDType]: ... @@ -4341,5 +4407,4 @@ class chararray(ndarray[_ShapeType, _CharDType]): class _SupportsDLPack(Protocol[_T_contra]): def __dlpack__(self, *, stream: None | _T_contra = ...) -> _PyCapsule: ... -def _from_dlpack(__obj: _SupportsDLPack[None]) -> NDArray[Any]: ... - +def from_dlpack(obj: _SupportsDLPack[None], /) -> NDArray[Any]: ... diff --git a/numpy/_globals.py b/numpy/_globals.py index c888747258c7..1e4f26cd86a4 100644 --- a/numpy/_globals.py +++ b/numpy/_globals.py @@ -83,10 +83,6 @@ def __new__(cls): cls.__instance = super().__new__(cls) return cls.__instance - # needed for python 2 to preserve identity through a pickle - def __reduce__(self): - return (self.__class__, ()) - def __repr__(self): return "" @@ -116,7 +112,7 @@ class _CopyMode(enum.Enum): NEVER = 2 def __bool__(self): - # For backwards compatiblity + # For backwards compatibility if self == _CopyMode.ALWAYS: return True diff --git a/numpy/_pyinstaller/__init__.py b/numpy/_pyinstaller/__init__.py new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/numpy/_pyinstaller/hook-numpy.py b/numpy/_pyinstaller/hook-numpy.py new file mode 100644 index 000000000000..a08b7c96304a --- /dev/null +++ b/numpy/_pyinstaller/hook-numpy.py @@ -0,0 +1,40 @@ +"""This hook should collect all binary files and any hidden modules that numpy +needs. + +Our (some-what inadequate) docs for writing PyInstaller hooks are kept here: +https://pyinstaller.readthedocs.io/en/stable/hooks.html + +""" +from PyInstaller.compat import is_conda, is_pure_conda +from PyInstaller.utils.hooks import collect_dynamic_libs, is_module_satisfies + +# Collect all DLLs inside numpy's installation folder, dump them into built +# app's root. +binaries = collect_dynamic_libs("numpy", ".") + +# If using Conda without any non-conda virtual environment manager: +if is_pure_conda: + # Assume running the NumPy from Conda-forge and collect it's DLLs from the + # communal Conda bin directory. DLLs from NumPy's dependencies must also be + # collected to capture MKL, OpenBlas, OpenMP, etc. + from PyInstaller.utils.hooks import conda_support + datas = conda_support.collect_dynamic_libs("numpy", dependencies=True) + +# Submodules PyInstaller cannot detect (probably because they are only imported +# by extension modules, which PyInstaller cannot read). +hiddenimports = ['numpy.core._dtype_ctypes'] +if is_conda: + hiddenimports.append("six") + +# Remove testing and building code and packages that are referenced throughout +# NumPy but are not really dependencies. +excludedimports = [ + "scipy", + "pytest", + "nose", + "f2py", + "setuptools", + "numpy.f2py", + "distutils", + "numpy.distutils", +] diff --git a/numpy/_pyinstaller/pyinstaller-smoke.py b/numpy/_pyinstaller/pyinstaller-smoke.py new file mode 100644 index 000000000000..eb28070e38ba --- /dev/null +++ b/numpy/_pyinstaller/pyinstaller-smoke.py @@ -0,0 +1,32 @@ +"""A crude *bit of everything* smoke test to verify PyInstaller compatibility. + +PyInstaller typically goes wrong by forgetting to package modules, extension +modules or shared libraries. This script should aim to touch as many of those +as possible in an attempt to trip a ModuleNotFoundError or a DLL load failure +due to an uncollected resource. Missing resources are unlikely to lead to +arithmetic errors so there's generally no need to verify any calculation's +output - merely that it made it to the end OK. This script should not +explicitly import any of numpy's submodules as that gives PyInstaller undue +hints that those submodules exist and should be collected (accessing implicitly +loaded submodules is OK). + +""" +import numpy as np + +a = np.arange(1., 10.).reshape((3, 3)) % 5 +np.linalg.det(a) +a @ a +a @ a.T +np.linalg.inv(a) +np.sin(np.exp(a)) +np.linalg.svd(a) +np.linalg.eigh(a) + +np.unique(np.random.randint(0, 10, 100)) +np.sort(np.random.uniform(0, 10, 100)) + +np.fft.fft(np.exp(2j * np.pi * np.arange(8) / 8)) +np.ma.masked_array(np.arange(10), np.random.rand(10) < .5).sum() +np.polynomial.Legendre([7, 8, 9]).roots() + +print("I made it!") diff --git a/numpy/_pyinstaller/test_pyinstaller.py b/numpy/_pyinstaller/test_pyinstaller.py new file mode 100644 index 000000000000..a9061da19b88 --- /dev/null +++ b/numpy/_pyinstaller/test_pyinstaller.py @@ -0,0 +1,35 @@ +import subprocess +from pathlib import Path + +import pytest + + +# PyInstaller has been very unproactive about replacing 'imp' with 'importlib'. +@pytest.mark.filterwarnings('ignore::DeprecationWarning') +# It also leaks io.BytesIO()s. +@pytest.mark.filterwarnings('ignore::ResourceWarning') +@pytest.mark.parametrize("mode", ["--onedir", "--onefile"]) +@pytest.mark.slow +def test_pyinstaller(mode, tmp_path): + """Compile and run pyinstaller-smoke.py using PyInstaller.""" + + pyinstaller_cli = pytest.importorskip("PyInstaller.__main__").run + + source = Path(__file__).with_name("pyinstaller-smoke.py").resolve() + args = [ + # Place all generated files in ``tmp_path``. + '--workpath', str(tmp_path / "build"), + '--distpath', str(tmp_path / "dist"), + '--specpath', str(tmp_path), + mode, + str(source), + ] + pyinstaller_cli(args) + + if mode == "--onefile": + exe = tmp_path / "dist" / source.stem + else: + exe = tmp_path / "dist" / source.stem / source.stem + + p = subprocess.run([str(exe)], check=True, stdout=subprocess.PIPE) + assert p.stdout.strip() == b"I made it!" diff --git a/numpy/_pytesttester.py b/numpy/_pytesttester.py index 8decb9dd79a1..01ddaaf98834 100644 --- a/numpy/_pytesttester.py +++ b/numpy/_pytesttester.py @@ -33,7 +33,6 @@ __all__ = ['PytestTester'] - def _show_numpy_info(): import numpy as np @@ -44,7 +43,6 @@ def _show_numpy_info(): print("NumPy CPU features: ", (info if info else 'nothing enabled')) - class PytestTester: """ Pytest test runner. @@ -167,7 +165,7 @@ def __call__(self, label='fast', verbose=1, extra_argv=None, ] if doctests: - raise ValueError("Doctests not supported") + pytest_args += ["--doctest-modules"] if extra_argv: pytest_args += list(extra_argv) diff --git a/numpy/_pytesttester.pyi b/numpy/_pytesttester.pyi index 0be64b3f7488..67ac87b33de1 100644 --- a/numpy/_pytesttester.pyi +++ b/numpy/_pytesttester.pyi @@ -1,6 +1,7 @@ -from typing import List, Iterable, Literal as L +from collections.abc import Iterable +from typing import Literal as L -__all__: List[str] +__all__: list[str] class PytestTester: module_name: str diff --git a/numpy/_typing/__init__.py b/numpy/_typing/__init__.py new file mode 100644 index 000000000000..b800c54b6fe7 --- /dev/null +++ b/numpy/_typing/__init__.py @@ -0,0 +1,225 @@ +"""Private counterpart of ``numpy.typing``.""" + +from __future__ import annotations + +from numpy import ufunc +from numpy.core.overrides import set_module +from typing import TYPE_CHECKING, final + + +@final # Disallow the creation of arbitrary `NBitBase` subclasses +@set_module("numpy.typing") +class NBitBase: + """ + A type representing `numpy.number` precision during static type checking. + + Used exclusively for the purpose static type checking, `NBitBase` + represents the base of a hierarchical set of subclasses. + Each subsequent subclass is herein used for representing a lower level + of precision, *e.g.* ``64Bit > 32Bit > 16Bit``. + + .. versionadded:: 1.20 + + Examples + -------- + Below is a typical usage example: `NBitBase` is herein used for annotating + a function that takes a float and integer of arbitrary precision + as arguments and returns a new float of whichever precision is largest + (*e.g.* ``np.float16 + np.int64 -> np.float64``). + + .. code-block:: python + + >>> from __future__ import annotations + >>> from typing import TypeVar, TYPE_CHECKING + >>> import numpy as np + >>> import numpy.typing as npt + + >>> T1 = TypeVar("T1", bound=npt.NBitBase) + >>> T2 = TypeVar("T2", bound=npt.NBitBase) + + >>> def add(a: np.floating[T1], b: np.integer[T2]) -> np.floating[T1 | T2]: + ... return a + b + + >>> a = np.float16() + >>> b = np.int64() + >>> out = add(a, b) + + >>> if TYPE_CHECKING: + ... reveal_locals() + ... # note: Revealed local types are: + ... # note: a: numpy.floating[numpy.typing._16Bit*] + ... # note: b: numpy.signedinteger[numpy.typing._64Bit*] + ... # note: out: numpy.floating[numpy.typing._64Bit*] + + """ + + def __init_subclass__(cls) -> None: + allowed_names = { + "NBitBase", "_256Bit", "_128Bit", "_96Bit", "_80Bit", + "_64Bit", "_32Bit", "_16Bit", "_8Bit", + } + if cls.__name__ not in allowed_names: + raise TypeError('cannot inherit from final class "NBitBase"') + super().__init_subclass__() + + +# Silence errors about subclassing a `@final`-decorated class +class _256Bit(NBitBase): # type: ignore[misc] + pass + +class _128Bit(_256Bit): # type: ignore[misc] + pass + +class _96Bit(_128Bit): # type: ignore[misc] + pass + +class _80Bit(_96Bit): # type: ignore[misc] + pass + +class _64Bit(_80Bit): # type: ignore[misc] + pass + +class _32Bit(_64Bit): # type: ignore[misc] + pass + +class _16Bit(_32Bit): # type: ignore[misc] + pass + +class _8Bit(_16Bit): # type: ignore[misc] + pass + + +from ._nested_sequence import ( + _NestedSequence as _NestedSequence, +) +from ._nbit import ( + _NBitByte as _NBitByte, + _NBitShort as _NBitShort, + _NBitIntC as _NBitIntC, + _NBitIntP as _NBitIntP, + _NBitInt as _NBitInt, + _NBitLongLong as _NBitLongLong, + _NBitHalf as _NBitHalf, + _NBitSingle as _NBitSingle, + _NBitDouble as _NBitDouble, + _NBitLongDouble as _NBitLongDouble, +) +from ._char_codes import ( + _BoolCodes as _BoolCodes, + _UInt8Codes as _UInt8Codes, + _UInt16Codes as _UInt16Codes, + _UInt32Codes as _UInt32Codes, + _UInt64Codes as _UInt64Codes, + _Int8Codes as _Int8Codes, + _Int16Codes as _Int16Codes, + _Int32Codes as _Int32Codes, + _Int64Codes as _Int64Codes, + _Float16Codes as _Float16Codes, + _Float32Codes as _Float32Codes, + _Float64Codes as _Float64Codes, + _Complex64Codes as _Complex64Codes, + _Complex128Codes as _Complex128Codes, + _ByteCodes as _ByteCodes, + _ShortCodes as _ShortCodes, + _IntCCodes as _IntCCodes, + _IntPCodes as _IntPCodes, + _IntCodes as _IntCodes, + _LongLongCodes as _LongLongCodes, + _UByteCodes as _UByteCodes, + _UShortCodes as _UShortCodes, + _UIntCCodes as _UIntCCodes, + _UIntPCodes as _UIntPCodes, + _UIntCodes as _UIntCodes, + _ULongLongCodes as _ULongLongCodes, + _HalfCodes as _HalfCodes, + _SingleCodes as _SingleCodes, + _DoubleCodes as _DoubleCodes, + _LongDoubleCodes as _LongDoubleCodes, + _CSingleCodes as _CSingleCodes, + _CDoubleCodes as _CDoubleCodes, + _CLongDoubleCodes as _CLongDoubleCodes, + _DT64Codes as _DT64Codes, + _TD64Codes as _TD64Codes, + _StrCodes as _StrCodes, + _BytesCodes as _BytesCodes, + _VoidCodes as _VoidCodes, + _ObjectCodes as _ObjectCodes, +) +from ._scalars import ( + _CharLike_co as _CharLike_co, + _BoolLike_co as _BoolLike_co, + _UIntLike_co as _UIntLike_co, + _IntLike_co as _IntLike_co, + _FloatLike_co as _FloatLike_co, + _ComplexLike_co as _ComplexLike_co, + _TD64Like_co as _TD64Like_co, + _NumberLike_co as _NumberLike_co, + _ScalarLike_co as _ScalarLike_co, + _VoidLike_co as _VoidLike_co, +) +from ._shape import ( + _Shape as _Shape, + _ShapeLike as _ShapeLike, +) +from ._dtype_like import ( + DTypeLike as DTypeLike, + _DTypeLike as _DTypeLike, + _SupportsDType as _SupportsDType, + _VoidDTypeLike as _VoidDTypeLike, + _DTypeLikeBool as _DTypeLikeBool, + _DTypeLikeUInt as _DTypeLikeUInt, + _DTypeLikeInt as _DTypeLikeInt, + _DTypeLikeFloat as _DTypeLikeFloat, + _DTypeLikeComplex as _DTypeLikeComplex, + _DTypeLikeTD64 as _DTypeLikeTD64, + _DTypeLikeDT64 as _DTypeLikeDT64, + _DTypeLikeObject as _DTypeLikeObject, + _DTypeLikeVoid as _DTypeLikeVoid, + _DTypeLikeStr as _DTypeLikeStr, + _DTypeLikeBytes as _DTypeLikeBytes, + _DTypeLikeComplex_co as _DTypeLikeComplex_co, +) +from ._array_like import ( + ArrayLike as ArrayLike, + _ArrayLike as _ArrayLike, + _FiniteNestedSequence as _FiniteNestedSequence, + _SupportsArray as _SupportsArray, + _SupportsArrayFunc as _SupportsArrayFunc, + _ArrayLikeInt as _ArrayLikeInt, + _ArrayLikeBool_co as _ArrayLikeBool_co, + _ArrayLikeUInt_co as _ArrayLikeUInt_co, + _ArrayLikeInt_co as _ArrayLikeInt_co, + _ArrayLikeFloat_co as _ArrayLikeFloat_co, + _ArrayLikeComplex_co as _ArrayLikeComplex_co, + _ArrayLikeNumber_co as _ArrayLikeNumber_co, + _ArrayLikeTD64_co as _ArrayLikeTD64_co, + _ArrayLikeDT64_co as _ArrayLikeDT64_co, + _ArrayLikeObject_co as _ArrayLikeObject_co, + _ArrayLikeVoid_co as _ArrayLikeVoid_co, + _ArrayLikeStr_co as _ArrayLikeStr_co, + _ArrayLikeBytes_co as _ArrayLikeBytes_co, + _ArrayLikeUnknown as _ArrayLikeUnknown, + _UnknownType as _UnknownType, +) +from ._generic_alias import ( + NDArray as NDArray, + _DType as _DType, + _GenericAlias as _GenericAlias, +) + +if TYPE_CHECKING: + from ._ufunc import ( + _UFunc_Nin1_Nout1 as _UFunc_Nin1_Nout1, + _UFunc_Nin2_Nout1 as _UFunc_Nin2_Nout1, + _UFunc_Nin1_Nout2 as _UFunc_Nin1_Nout2, + _UFunc_Nin2_Nout2 as _UFunc_Nin2_Nout2, + _GUFunc_Nin2_Nout1 as _GUFunc_Nin2_Nout1, + ) +else: + # Declare the (type-check-only) ufunc subclasses as ufunc aliases during + # runtime; this helps autocompletion tools such as Jedi (numpy/numpy#19834) + _UFunc_Nin1_Nout1 = ufunc + _UFunc_Nin2_Nout1 = ufunc + _UFunc_Nin1_Nout2 = ufunc + _UFunc_Nin2_Nout2 = ufunc + _GUFunc_Nin2_Nout1 = ufunc diff --git a/numpy/typing/_add_docstring.py b/numpy/_typing/_add_docstring.py similarity index 100% rename from numpy/typing/_add_docstring.py rename to numpy/_typing/_add_docstring.py diff --git a/numpy/typing/_array_like.py b/numpy/_typing/_array_like.py similarity index 61% rename from numpy/typing/_array_like.py rename to numpy/_typing/_array_like.py index 02e5ee573fc7..16c9defcf8bb 100644 --- a/numpy/typing/_array_like.py +++ b/numpy/_typing/_array_like.py @@ -1,6 +1,10 @@ from __future__ import annotations -from typing import Any, Sequence, Protocol, Union, TypeVar +# NOTE: Import `Sequence` from `typing` as we it is needed for a type-alias, +# not an annotation +import sys +from collections.abc import Collection, Callable +from typing import Any, Sequence, Protocol, Union, TypeVar, runtime_checkable from numpy import ( ndarray, dtype, @@ -30,10 +34,23 @@ # array. # Concrete implementations of the protocol are responsible for adding # any and all remaining overloads +@runtime_checkable class _SupportsArray(Protocol[_DType_co]): def __array__(self) -> ndarray[Any, _DType_co]: ... +@runtime_checkable +class _SupportsArrayFunc(Protocol): + """A protocol class representing `~class.__array_function__`.""" + def __array_function__( + self, + func: Callable[..., Any], + types: Collection[type[Any]], + args: tuple[Any, ...], + kwargs: dict[str, Any], + ) -> object: ... + + # TODO: Wait until mypy supports recursive objects in combination with typevars _FiniteNestedSequence = Union[ _T, @@ -43,10 +60,16 @@ def __array__(self) -> ndarray[Any, _DType_co]: ... Sequence[Sequence[Sequence[Sequence[_T]]]], ] +# A subset of `npt.ArrayLike` that can be parametrized w.r.t. `np.generic` +_ArrayLike = Union[ + _SupportsArray["dtype[_ScalarType]"], + _NestedSequence[_SupportsArray["dtype[_ScalarType]"]], +] + # A union representing array-like objects; consists of two typevars: # One representing types that can be parametrized w.r.t. `np.dtype` # and another one for the rest -_ArrayLike = Union[ +_DualArrayLike = Union[ _SupportsArray[_DType], _NestedSequence[_SupportsArray[_DType]], _T, @@ -60,38 +83,44 @@ def __array__(self) -> ndarray[Any, _DType_co]: ... # is resolved. See also the mypy issue: # # https://github.com/python/typing/issues/593 -ArrayLike = _ArrayLike[ - dtype, - Union[bool, int, float, complex, str, bytes], -] +if sys.version_info[:2] < (3, 9): + ArrayLike = _DualArrayLike[ + dtype, + Union[bool, int, float, complex, str, bytes], + ] +else: + ArrayLike = _DualArrayLike[ + dtype[Any], + Union[bool, int, float, complex, str, bytes], + ] # `ArrayLike_co`: array-like objects that can be coerced into `X` # given the casting rules `same_kind` -_ArrayLikeBool_co = _ArrayLike[ +_ArrayLikeBool_co = _DualArrayLike[ "dtype[bool_]", bool, ] -_ArrayLikeUInt_co = _ArrayLike[ +_ArrayLikeUInt_co = _DualArrayLike[ "dtype[Union[bool_, unsignedinteger[Any]]]", bool, ] -_ArrayLikeInt_co = _ArrayLike[ +_ArrayLikeInt_co = _DualArrayLike[ "dtype[Union[bool_, integer[Any]]]", Union[bool, int], ] -_ArrayLikeFloat_co = _ArrayLike[ +_ArrayLikeFloat_co = _DualArrayLike[ "dtype[Union[bool_, integer[Any], floating[Any]]]", Union[bool, int, float], ] -_ArrayLikeComplex_co = _ArrayLike[ +_ArrayLikeComplex_co = _DualArrayLike[ "dtype[Union[bool_, integer[Any], floating[Any], complexfloating[Any, Any]]]", Union[bool, int, float, complex], ] -_ArrayLikeNumber_co = _ArrayLike[ +_ArrayLikeNumber_co = _DualArrayLike[ "dtype[Union[bool_, number[Any]]]", Union[bool, int, float, complex], ] -_ArrayLikeTD64_co = _ArrayLike[ +_ArrayLikeTD64_co = _DualArrayLike[ "dtype[Union[bool_, integer[Any], timedelta64]]", Union[bool, int], ] @@ -108,16 +137,29 @@ def __array__(self) -> ndarray[Any, _DType_co]: ... _SupportsArray["dtype[void]"], _NestedSequence[_SupportsArray["dtype[void]"]], ] -_ArrayLikeStr_co = _ArrayLike[ +_ArrayLikeStr_co = _DualArrayLike[ "dtype[str_]", str, ] -_ArrayLikeBytes_co = _ArrayLike[ +_ArrayLikeBytes_co = _DualArrayLike[ "dtype[bytes_]", bytes, ] -_ArrayLikeInt = _ArrayLike[ +_ArrayLikeInt = _DualArrayLike[ "dtype[integer[Any]]", int, ] + +# Extra ArrayLike type so that pyright can deal with NDArray[Any] +# Used as the first overload, should only match NDArray[Any], +# not any actual types. +# https://github.com/numpy/numpy/pull/22193 +class _UnknownType: + ... + + +_ArrayLikeUnknown = _DualArrayLike[ + "dtype[_UnknownType]", + _UnknownType, +] diff --git a/numpy/typing/_callable.pyi b/numpy/_typing/_callable.pyi similarity index 95% rename from numpy/typing/_callable.pyi rename to numpy/_typing/_callable.pyi index e1149f26ae87..5dfe9e7c2342 100644 --- a/numpy/typing/_callable.pyi +++ b/numpy/_typing/_callable.pyi @@ -11,11 +11,9 @@ See the `Mypy documentation`_ on protocols for more details. from __future__ import annotations from typing import ( - Union, TypeVar, overload, Any, - Tuple, NoReturn, Protocol, ) @@ -46,12 +44,13 @@ from ._scalars import ( ) from . import NBitBase from ._generic_alias import NDArray +from ._nested_sequence import _NestedSequence _T1 = TypeVar("_T1") _T2 = TypeVar("_T2") _T1_contra = TypeVar("_T1_contra", contravariant=True) _T2_contra = TypeVar("_T2_contra", contravariant=True) -_2Tuple = Tuple[_T1, _T1] +_2Tuple = tuple[_T1, _T1] _NBit1 = TypeVar("_NBit1", bound=NBitBase) _NBit2 = TypeVar("_NBit2", bound=NBitBase) @@ -310,18 +309,30 @@ class _ComplexOp(Protocol[_NBit1]): @overload def __call__( self, - other: Union[ - integer[_NBit2], - floating[_NBit2], - complexfloating[_NBit2, _NBit2], - ], /, + other: ( + integer[_NBit2] + | floating[_NBit2] + | complexfloating[_NBit2, _NBit2] + ), /, ) -> complexfloating[_NBit1 | _NBit2, _NBit1 | _NBit2]: ... class _NumberOp(Protocol): def __call__(self, other: _NumberLike_co, /) -> Any: ... +class _SupportsLT(Protocol): + def __lt__(self, other: Any, /) -> object: ... + +class _SupportsGT(Protocol): + def __gt__(self, other: Any, /) -> object: ... + class _ComparisonOp(Protocol[_T1_contra, _T2_contra]): @overload def __call__(self, other: _T1_contra, /) -> bool_: ... @overload def __call__(self, other: _T2_contra, /) -> NDArray[bool_]: ... + @overload + def __call__( + self, + other: _SupportsLT | _SupportsGT | _NestedSequence[_SupportsLT | _SupportsGT], + /, + ) -> Any: ... diff --git a/numpy/typing/_char_codes.py b/numpy/_typing/_char_codes.py similarity index 98% rename from numpy/typing/_char_codes.py rename to numpy/_typing/_char_codes.py index 1394710841fe..f840d17bbca0 100644 --- a/numpy/typing/_char_codes.py +++ b/numpy/_typing/_char_codes.py @@ -30,7 +30,7 @@ _UShortCodes = Literal["ushort", "H", "=H", "H"] _UIntCCodes = Literal["uintc", "I", "=I", "I"] _UIntPCodes = Literal["uintp", "uint0", "P", "=P", "P"] -_UIntCodes = Literal["uint", "L", "=L", "L"] +_UIntCodes = Literal["ulong", "uint", "L", "=L", "L"] _ULongLongCodes = Literal["ulonglong", "Q", "=Q", "Q"] _HalfCodes = Literal["half", "e", "=e", "e"] diff --git a/numpy/typing/_dtype_like.py b/numpy/_typing/_dtype_like.py similarity index 95% rename from numpy/typing/_dtype_like.py rename to numpy/_typing/_dtype_like.py index c9bf1a137cb6..e92e17dd20cf 100644 --- a/numpy/typing/_dtype_like.py +++ b/numpy/_typing/_dtype_like.py @@ -8,6 +8,7 @@ TypeVar, Protocol, TypedDict, + runtime_checkable, ) import numpy as np @@ -57,9 +58,12 @@ _ObjectCodes, ) -_DTypeLikeNested = Any # TODO: wait for support for recursive types +_SCT = TypeVar("_SCT", bound=np.generic) _DType_co = TypeVar("_DType_co", covariant=True, bound=DType[Any]) +_DTypeLikeNested = Any # TODO: wait for support for recursive types + + # Mandatory keys class _DTypeDictBase(TypedDict): names: Sequence[str] @@ -77,11 +81,20 @@ class _DTypeDict(_DTypeDictBase, total=False): # A protocol for anything with the dtype attribute +@runtime_checkable class _SupportsDType(Protocol[_DType_co]): @property def dtype(self) -> _DType_co: ... +# A subset of `npt.DTypeLike` that can be parametrized w.r.t. `np.generic` +_DTypeLike = Union[ + "np.dtype[_SCT]", + Type[_SCT], + _SupportsDType["np.dtype[_SCT]"], +] + + # Would create a dtype[np.void] _VoidDTypeLike = Union[ # (flexible_dtype, itemsize) diff --git a/numpy/typing/_extended_precision.py b/numpy/_typing/_extended_precision.py similarity index 100% rename from numpy/typing/_extended_precision.py rename to numpy/_typing/_extended_precision.py diff --git a/numpy/typing/_generic_alias.py b/numpy/_typing/_generic_alias.py similarity index 73% rename from numpy/typing/_generic_alias.py rename to numpy/_typing/_generic_alias.py index 1eb2c8c05f02..01cd224adbe9 100644 --- a/numpy/typing/_generic_alias.py +++ b/numpy/_typing/_generic_alias.py @@ -2,17 +2,11 @@ import sys import types +from collections.abc import Generator, Iterable, Iterator from typing import ( Any, ClassVar, - FrozenSet, - Generator, - Iterable, - Iterator, - List, NoReturn, - Tuple, - Type, TypeVar, TYPE_CHECKING, ) @@ -70,7 +64,7 @@ def _reconstruct_alias(alias: _T, parameters: Iterator[TypeVar]) -> _T: args.append(value) cls = type(alias) - return cls(alias.__origin__, tuple(args)) + return cls(alias.__origin__, tuple(args), alias.__unpacked__) class _GenericAlias: @@ -86,45 +80,65 @@ class _GenericAlias: """ - __slots__ = ("__weakref__", "_origin", "_args", "_parameters", "_hash") + __slots__ = ( + "__weakref__", + "_origin", + "_args", + "_parameters", + "_hash", + "_starred", + ) @property def __origin__(self) -> type: return super().__getattribute__("_origin") @property - def __args__(self) -> Tuple[object, ...]: + def __args__(self) -> tuple[object, ...]: return super().__getattribute__("_args") @property - def __parameters__(self) -> Tuple[TypeVar, ...]: + def __parameters__(self) -> tuple[TypeVar, ...]: """Type variables in the ``GenericAlias``.""" return super().__getattribute__("_parameters") + @property + def __unpacked__(self) -> bool: + return super().__getattribute__("_starred") + + @property + def __typing_unpacked_tuple_args__(self) -> tuple[object, ...] | None: + # NOTE: This should return `__args__` if `__origin__` is a tuple, + # which should never be the case with how `_GenericAlias` is used + # within numpy + return None + def __init__( self, origin: type, - args: object | Tuple[object, ...], + args: object | tuple[object, ...], + starred: bool = False, ) -> None: self._origin = origin self._args = args if isinstance(args, tuple) else (args,) self._parameters = tuple(_parse_parameters(self.__args__)) + self._starred = starred @property - def __call__(self) -> type: + def __call__(self) -> type[Any]: return self.__origin__ - def __reduce__(self: _T) -> Tuple[ - Type[_T], - Tuple[type, Tuple[object, ...]], + def __reduce__(self: _T) -> tuple[ + type[_T], + tuple[type[Any], tuple[object, ...], bool], ]: cls = type(self) - return cls, (self.__origin__, self.__args__) + return cls, (self.__origin__, self.__args__, self.__unpacked__) - def __mro_entries__(self, bases: Iterable[object]) -> Tuple[type]: + def __mro_entries__(self, bases: Iterable[object]) -> tuple[type[Any]]: return (self.__origin__,) - def __dir__(self) -> List[str]: + def __dir__(self) -> list[str]: """Implement ``dir(self)``.""" cls = type(self) dir_origin = set(dir(self.__origin__)) @@ -136,7 +150,11 @@ def __hash__(self) -> int: try: return super().__getattribute__("_hash") except AttributeError: - self._hash: int = hash(self.__origin__) ^ hash(self.__args__) + self._hash: int = ( + hash(self.__origin__) ^ + hash(self.__args__) ^ + hash(self.__unpacked__) + ) return super().__getattribute__("_hash") def __instancecheck__(self, obj: object) -> NoReturn: @@ -153,9 +171,10 @@ def __repr__(self) -> str: """Return ``repr(self)``.""" args = ", ".join(_to_str(i) for i in self.__args__) origin = _to_str(self.__origin__) - return f"{origin}[{args}]" + prefix = "*" if self.__unpacked__ else "" + return f"{prefix}{origin}[{args}]" - def __getitem__(self: _T, key: object | Tuple[object, ...]) -> _T: + def __getitem__(self: _T, key: object | tuple[object, ...]) -> _T: """Return ``self[key]``.""" key_tup = key if isinstance(key, tuple) else (key,) @@ -175,10 +194,18 @@ def __eq__(self, value: object) -> bool: return NotImplemented return ( self.__origin__ == value.__origin__ and - self.__args__ == value.__args__ + self.__args__ == value.__args__ and + self.__unpacked__ == getattr( + value, "__unpacked__", self.__unpacked__ + ) ) - _ATTR_EXCEPTIONS: ClassVar[FrozenSet[str]] = frozenset({ + def __iter__(self: _T) -> Generator[_T, None, None]: + """Return ``iter(self)``.""" + cls = type(self) + yield cls(self.__origin__, self.__args__, True) + + _ATTR_EXCEPTIONS: ClassVar[frozenset[str]] = frozenset({ "__origin__", "__args__", "__parameters__", @@ -187,6 +214,9 @@ def __eq__(self, value: object) -> bool: "__reduce_ex__", "__copy__", "__deepcopy__", + "__unpacked__", + "__typing_unpacked_tuple_args__", + "__class__", }) def __getattribute__(self, name: str) -> Any: diff --git a/numpy/typing/_nbit.py b/numpy/_typing/_nbit.py similarity index 100% rename from numpy/typing/_nbit.py rename to numpy/_typing/_nbit.py diff --git a/numpy/typing/_nested_sequence.py b/numpy/_typing/_nested_sequence.py similarity index 89% rename from numpy/typing/_nested_sequence.py rename to numpy/_typing/_nested_sequence.py index a853303ca95d..789bf3844437 100644 --- a/numpy/typing/_nested_sequence.py +++ b/numpy/_typing/_nested_sequence.py @@ -8,6 +8,7 @@ overload, TypeVar, Protocol, + runtime_checkable, ) __all__ = ["_NestedSequence"] @@ -15,6 +16,7 @@ _T_co = TypeVar("_T_co", covariant=True) +@runtime_checkable class _NestedSequence(Protocol[_T_co]): """A protocol for representing nested sequences. @@ -25,7 +27,7 @@ class _NestedSequence(Protocol[_T_co]): See Also -------- - `collections.abc.Sequence` + collections.abc.Sequence ABCs for read-only and mutable :term:`sequences`. Examples @@ -36,9 +38,9 @@ class _NestedSequence(Protocol[_T_co]): >>> from typing import TYPE_CHECKING >>> import numpy as np - >>> from numpy.typing import _NestedSequnce + >>> from numpy._typing import _NestedSequence - >>> def get_dtype(seq: _NestedSequnce[float]) -> np.dtype[np.float64]: + >>> def get_dtype(seq: _NestedSequence[float]) -> np.dtype[np.float64]: ... return np.asarray(seq).dtype >>> a = get_dtype([1.0]) @@ -49,10 +51,10 @@ class _NestedSequence(Protocol[_T_co]): >>> if TYPE_CHECKING: ... reveal_locals() ... # note: Revealed local types are: - ... # note: a: numpy.dtype[numpy.floating[numpy.typing._64Bit]] - ... # note: b: numpy.dtype[numpy.floating[numpy.typing._64Bit]] - ... # note: c: numpy.dtype[numpy.floating[numpy.typing._64Bit]] - ... # note: d: numpy.dtype[numpy.floating[numpy.typing._64Bit]] + ... # note: a: numpy.dtype[numpy.floating[numpy._typing._64Bit]] + ... # note: b: numpy.dtype[numpy.floating[numpy._typing._64Bit]] + ... # note: c: numpy.dtype[numpy.floating[numpy._typing._64Bit]] + ... # note: d: numpy.dtype[numpy.floating[numpy._typing._64Bit]] """ diff --git a/numpy/typing/_scalars.py b/numpy/_typing/_scalars.py similarity index 100% rename from numpy/typing/_scalars.py rename to numpy/_typing/_scalars.py diff --git a/numpy/typing/_shape.py b/numpy/_typing/_shape.py similarity index 100% rename from numpy/typing/_shape.py rename to numpy/_typing/_shape.py diff --git a/numpy/typing/_ufunc.pyi b/numpy/_typing/_ufunc.pyi similarity index 82% rename from numpy/typing/_ufunc.pyi rename to numpy/_typing/_ufunc.pyi index 1be3500c127e..9f8e0d4edbfb 100644 --- a/numpy/typing/_ufunc.pyi +++ b/numpy/_typing/_ufunc.pyi @@ -10,12 +10,11 @@ four private subclasses, one for each combination of from typing import ( Any, Generic, - List, overload, - Tuple, TypeVar, Literal, SupportsIndex, + Protocol, ) from numpy import ufunc, _CastingKind, _OrderKACF @@ -27,14 +26,25 @@ from ._array_like import ArrayLike, _ArrayLikeBool_co, _ArrayLikeInt_co from ._dtype_like import DTypeLike _T = TypeVar("_T") -_2Tuple = Tuple[_T, _T] -_3Tuple = Tuple[_T, _T, _T] -_4Tuple = Tuple[_T, _T, _T, _T] +_2Tuple = tuple[_T, _T] +_3Tuple = tuple[_T, _T, _T] +_4Tuple = tuple[_T, _T, _T, _T] _NTypes = TypeVar("_NTypes", bound=int) _IDType = TypeVar("_IDType", bound=Any) _NameType = TypeVar("_NameType", bound=str) + +class _SupportsArrayUFunc(Protocol): + def __array_ufunc__( + self, + ufunc: ufunc, + method: Literal["__call__", "reduce", "reduceat", "accumulate", "outer", "inner"], + *inputs: Any, + **kwargs: Any, + ) -> Any: ... + + # NOTE: In reality `extobj` should be a length of list 3 containing an # int, an int, and a callable, but there's no way to properly express # non-homogenous lists. @@ -50,7 +60,7 @@ _NameType = TypeVar("_NameType", bound=str) # NOTE: If 2 output types are returned then `out` must be a # 2-tuple of arrays. Otherwise `None` or a plain array are also acceptable -class _UFunc_Nin1_Nout1(ufunc, Generic[_NameType, _NTypes, _IDType]): +class _UFunc_Nin1_Nout1(ufunc, Generic[_NameType, _NTypes, _IDType]): # type: ignore[misc] @property def __name__(self) -> _NameType: ... @property @@ -86,13 +96,13 @@ class _UFunc_Nin1_Nout1(ufunc, Generic[_NameType, _NTypes, _IDType]): dtype: DTypeLike = ..., subok: bool = ..., signature: str | _2Tuple[None | str] = ..., - extobj: List[Any] = ..., + extobj: list[Any] = ..., ) -> Any: ... @overload def __call__( self, __x1: ArrayLike, - out: None | NDArray[Any] | Tuple[NDArray[Any]] = ..., + out: None | NDArray[Any] | tuple[NDArray[Any]] = ..., *, where: None | _ArrayLikeBool_co = ..., casting: _CastingKind = ..., @@ -100,17 +110,31 @@ class _UFunc_Nin1_Nout1(ufunc, Generic[_NameType, _NTypes, _IDType]): dtype: DTypeLike = ..., subok: bool = ..., signature: str | _2Tuple[None | str] = ..., - extobj: List[Any] = ..., + extobj: list[Any] = ..., ) -> NDArray[Any]: ... + @overload + def __call__( + self, + __x1: _SupportsArrayUFunc, + out: None | NDArray[Any] | tuple[NDArray[Any]] = ..., + *, + where: None | _ArrayLikeBool_co = ..., + casting: _CastingKind = ..., + order: _OrderKACF = ..., + dtype: DTypeLike = ..., + subok: bool = ..., + signature: str | _2Tuple[None | str] = ..., + extobj: list[Any] = ..., + ) -> Any: ... def at( self, - a: NDArray[Any], + a: _SupportsArrayUFunc, indices: _ArrayLikeInt_co, /, ) -> None: ... -class _UFunc_Nin2_Nout1(ufunc, Generic[_NameType, _NTypes, _IDType]): +class _UFunc_Nin2_Nout1(ufunc, Generic[_NameType, _NTypes, _IDType]): # type: ignore[misc] @property def __name__(self) -> _NameType: ... @property @@ -139,14 +163,14 @@ class _UFunc_Nin2_Nout1(ufunc, Generic[_NameType, _NTypes, _IDType]): dtype: DTypeLike = ..., subok: bool = ..., signature: str | _3Tuple[None | str] = ..., - extobj: List[Any] = ..., + extobj: list[Any] = ..., ) -> Any: ... @overload def __call__( self, __x1: ArrayLike, __x2: ArrayLike, - out: None | NDArray[Any] | Tuple[NDArray[Any]] = ..., + out: None | NDArray[Any] | tuple[NDArray[Any]] = ..., *, where: None | _ArrayLikeBool_co = ..., casting: _CastingKind = ..., @@ -154,7 +178,7 @@ class _UFunc_Nin2_Nout1(ufunc, Generic[_NameType, _NTypes, _IDType]): dtype: DTypeLike = ..., subok: bool = ..., signature: str | _3Tuple[None | str] = ..., - extobj: List[Any] = ..., + extobj: list[Any] = ..., ) -> NDArray[Any]: ... def at( @@ -207,7 +231,7 @@ class _UFunc_Nin2_Nout1(ufunc, Generic[_NameType, _NTypes, _IDType]): dtype: DTypeLike = ..., subok: bool = ..., signature: str | _3Tuple[None | str] = ..., - extobj: List[Any] = ..., + extobj: list[Any] = ..., ) -> Any: ... @overload def outer( # type: ignore[misc] @@ -215,17 +239,17 @@ class _UFunc_Nin2_Nout1(ufunc, Generic[_NameType, _NTypes, _IDType]): A: ArrayLike, B: ArrayLike, /, *, - out: None | NDArray[Any] | Tuple[NDArray[Any]] = ..., + out: None | NDArray[Any] | tuple[NDArray[Any]] = ..., where: None | _ArrayLikeBool_co = ..., casting: _CastingKind = ..., order: _OrderKACF = ..., dtype: DTypeLike = ..., subok: bool = ..., signature: str | _3Tuple[None | str] = ..., - extobj: List[Any] = ..., + extobj: list[Any] = ..., ) -> NDArray[Any]: ... -class _UFunc_Nin1_Nout2(ufunc, Generic[_NameType, _NTypes, _IDType]): +class _UFunc_Nin1_Nout2(ufunc, Generic[_NameType, _NTypes, _IDType]): # type: ignore[misc] @property def __name__(self) -> _NameType: ... @property @@ -264,7 +288,7 @@ class _UFunc_Nin1_Nout2(ufunc, Generic[_NameType, _NTypes, _IDType]): dtype: DTypeLike = ..., subok: bool = ..., signature: str | _3Tuple[None | str] = ..., - extobj: List[Any] = ..., + extobj: list[Any] = ..., ) -> _2Tuple[Any]: ... @overload def __call__( @@ -280,10 +304,26 @@ class _UFunc_Nin1_Nout2(ufunc, Generic[_NameType, _NTypes, _IDType]): dtype: DTypeLike = ..., subok: bool = ..., signature: str | _3Tuple[None | str] = ..., - extobj: List[Any] = ..., + extobj: list[Any] = ..., ) -> _2Tuple[NDArray[Any]]: ... + @overload + def __call__( + self, + __x1: _SupportsArrayUFunc, + __out1: None | NDArray[Any] = ..., + __out2: None | NDArray[Any] = ..., + *, + out: _2Tuple[NDArray[Any]] = ..., + where: None | _ArrayLikeBool_co = ..., + casting: _CastingKind = ..., + order: _OrderKACF = ..., + dtype: DTypeLike = ..., + subok: bool = ..., + signature: str | _3Tuple[None | str] = ..., + extobj: list[Any] = ..., + ) -> _2Tuple[Any]: ... -class _UFunc_Nin2_Nout2(ufunc, Generic[_NameType, _NTypes, _IDType]): +class _UFunc_Nin2_Nout2(ufunc, Generic[_NameType, _NTypes, _IDType]): # type: ignore[misc] @property def __name__(self) -> _NameType: ... @property @@ -323,7 +363,7 @@ class _UFunc_Nin2_Nout2(ufunc, Generic[_NameType, _NTypes, _IDType]): dtype: DTypeLike = ..., subok: bool = ..., signature: str | _4Tuple[None | str] = ..., - extobj: List[Any] = ..., + extobj: list[Any] = ..., ) -> _2Tuple[Any]: ... @overload def __call__( @@ -340,10 +380,10 @@ class _UFunc_Nin2_Nout2(ufunc, Generic[_NameType, _NTypes, _IDType]): dtype: DTypeLike = ..., subok: bool = ..., signature: str | _4Tuple[None | str] = ..., - extobj: List[Any] = ..., + extobj: list[Any] = ..., ) -> _2Tuple[NDArray[Any]]: ... -class _GUFunc_Nin2_Nout1(ufunc, Generic[_NameType, _NTypes, _IDType]): +class _GUFunc_Nin2_Nout1(ufunc, Generic[_NameType, _NTypes, _IDType]): # type: ignore[misc] @property def __name__(self) -> _NameType: ... @property @@ -357,7 +397,7 @@ class _GUFunc_Nin2_Nout1(ufunc, Generic[_NameType, _NTypes, _IDType]): @property def nargs(self) -> Literal[3]: ... - # NOTE: In practice the only gufunc in the main name is `matmul`, + # NOTE: In practice the only gufunc in the main namespace is `matmul`, # so we can use its signature here @property def signature(self) -> Literal["(n?,k),(k,m?)->(n?,m?)"]: ... @@ -385,21 +425,21 @@ class _GUFunc_Nin2_Nout1(ufunc, Generic[_NameType, _NTypes, _IDType]): dtype: DTypeLike = ..., subok: bool = ..., signature: str | _3Tuple[None | str] = ..., - extobj: List[Any] = ..., - axes: List[_2Tuple[SupportsIndex]] = ..., + extobj: list[Any] = ..., + axes: list[_2Tuple[SupportsIndex]] = ..., ) -> Any: ... @overload def __call__( self, __x1: ArrayLike, __x2: ArrayLike, - out: NDArray[Any] | Tuple[NDArray[Any]], + out: NDArray[Any] | tuple[NDArray[Any]], *, casting: _CastingKind = ..., order: _OrderKACF = ..., dtype: DTypeLike = ..., subok: bool = ..., signature: str | _3Tuple[None | str] = ..., - extobj: List[Any] = ..., - axes: List[_2Tuple[SupportsIndex]] = ..., + extobj: list[Any] = ..., + axes: list[_2Tuple[SupportsIndex]] = ..., ) -> NDArray[Any]: ... diff --git a/numpy/_typing/setup.py b/numpy/_typing/setup.py new file mode 100644 index 000000000000..24022fdaa327 --- /dev/null +++ b/numpy/_typing/setup.py @@ -0,0 +1,10 @@ +def configuration(parent_package='', top_path=None): + from numpy.distutils.misc_util import Configuration + config = Configuration('_typing', parent_package, top_path) + config.add_data_files('*.pyi') + return config + + +if __name__ == '__main__': + from numpy.distutils.core import setup + setup(configuration=configuration) diff --git a/numpy/_version.py b/numpy/_version.py index 6d2c55669798..565eb317bf17 100644 --- a/numpy/_version.py +++ b/numpy/_version.py @@ -1,11 +1,13 @@ + # This file helps to compute a version number in source trees obtained from # git-archive tarball (such as those provided by githubs download-from-tag # feature). Distribution tarballs (built by setup.py sdist) and build # directories (produced by setup.py build) will contain a much shorter file # that just contains the computed version number. -# This file is released into the public domain. Generated by -# versioneer-0.19 (https://github.com/python-versioneer/python-versioneer) +# This file is released into the public domain. +# Generated by versioneer-0.26 +# https://github.com/python-versioneer/python-versioneer """Git implementation of _version.py.""" @@ -14,6 +16,8 @@ import re import subprocess import sys +from typing import Callable, Dict +import functools def get_keywords(): @@ -51,8 +55,8 @@ class NotThisMethod(Exception): """Exception raised if a method is not valid for the current scenario.""" -LONG_VERSION_PY = {} -HANDLERS = {} +LONG_VERSION_PY: Dict[str, str] = {} +HANDLERS: Dict[str, Dict[str, Callable]] = {} def register_vcs_handler(vcs, method): # decorator @@ -70,17 +74,25 @@ def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, env=None): """Call the given command(s).""" assert isinstance(commands, list) - p = None - for c in commands: + process = None + + popen_kwargs = {} + if sys.platform == "win32": + # This hides the console window if pythonw.exe is used + startupinfo = subprocess.STARTUPINFO() + startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW + popen_kwargs["startupinfo"] = startupinfo + + for command in commands: try: - dispcmd = str([c] + args) + dispcmd = str([command] + args) # remember shell=False, so use git.cmd on windows, not just git - p = subprocess.Popen([c] + args, cwd=cwd, env=env, - stdout=subprocess.PIPE, - stderr=(subprocess.PIPE if hide_stderr - else None)) + process = subprocess.Popen([command] + args, cwd=cwd, env=env, + stdout=subprocess.PIPE, + stderr=(subprocess.PIPE if hide_stderr + else None), **popen_kwargs) break - except EnvironmentError: + except OSError: e = sys.exc_info()[1] if e.errno == errno.ENOENT: continue @@ -92,13 +104,13 @@ def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, if verbose: print("unable to find command, tried %s" % (commands,)) return None, None - stdout = p.communicate()[0].strip().decode() - if p.returncode != 0: + stdout = process.communicate()[0].strip().decode() + if process.returncode != 0: if verbose: print("unable to run %s (error)" % dispcmd) print("stdout was %s" % stdout) - return None, p.returncode - return stdout, p.returncode + return None, process.returncode + return stdout, process.returncode def versions_from_parentdir(parentdir_prefix, root, verbose): @@ -110,15 +122,14 @@ def versions_from_parentdir(parentdir_prefix, root, verbose): """ rootdirs = [] - for i in range(3): + for _ in range(3): dirname = os.path.basename(root) if dirname.startswith(parentdir_prefix): return {"version": dirname[len(parentdir_prefix):], "full-revisionid": None, "dirty": False, "error": None, "date": None} - else: - rootdirs.append(root) - root = os.path.dirname(root) # up a level + rootdirs.append(root) + root = os.path.dirname(root) # up a level if verbose: print("Tried directories %s but none started with prefix %s" % @@ -135,8 +146,8 @@ def git_get_keywords(versionfile_abs): # _version.py. keywords = {} try: - with open(versionfile_abs, "r") as f: - for line in f.readlines(): + with open(versionfile_abs, "r") as fobj: + for line in fobj: if line.strip().startswith("git_refnames ="): mo = re.search(r'=\s*"(.*)"', line) if mo: @@ -149,7 +160,7 @@ def git_get_keywords(versionfile_abs): mo = re.search(r'=\s*"(.*)"', line) if mo: keywords["date"] = mo.group(1) - except EnvironmentError: + except OSError: pass return keywords @@ -157,8 +168,8 @@ def git_get_keywords(versionfile_abs): @register_vcs_handler("git", "keywords") def git_versions_from_keywords(keywords, tag_prefix, verbose): """Get version information from git keywords.""" - if not keywords: - raise NotThisMethod("no keywords at all, weird") + if "refnames" not in keywords: + raise NotThisMethod("Short version file found") date = keywords.get("date") if date is not None: # Use only the last line. Previous lines may contain GPG signature @@ -177,11 +188,11 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose): if verbose: print("keywords are unexpanded, not using") raise NotThisMethod("unexpanded keywords, not a git-archive tarball") - refs = set([r.strip() for r in refnames.strip("()").split(",")]) + refs = {r.strip() for r in refnames.strip("()").split(",")} # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of # just "foo-1.0". If we see a "tag: " prefix, prefer those. TAG = "tag: " - tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)]) + tags = {r[len(TAG):] for r in refs if r.startswith(TAG)} if not tags: # Either we're using git < 1.8.3, or there really are no tags. We use # a heuristic: assume all version tags have a digit. The old git %d @@ -189,8 +200,8 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose): # refs/heads/ and refs/tags/ prefixes that would let us distinguish # between branches and tags. By ignoring refnames without digits, we # filter out many common branch names like "release" and - # "stabilization", as well as "HEAD" and "main". - tags = set([r for r in refs if re.search(r'\d', r)]) + # "stabilization", as well as "HEAD" and "master". + tags = {r for r in refs if re.search(r'\d', r)} if verbose: print("discarding '%s', no digits" % ",".join(refs - tags)) if verbose: @@ -199,6 +210,11 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose): # sorting will prefer e.g. "2.0" over "2.0rc1" if ref.startswith(tag_prefix): r = ref[len(tag_prefix):] + # Filter out refs that exactly match prefix or that don't start + # with a number once the prefix is stripped (mostly a concern + # when prefix is '') + if not re.match(r'\d', r): + continue if verbose: print("picking %s" % r) return {"version": r, @@ -214,7 +230,7 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose): @register_vcs_handler("git", "pieces_from_vcs") -def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): +def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command): """Get version from 'git describe' in the root of the source tree. This only gets called if the git-archive 'subst' keywords were *not* @@ -225,8 +241,15 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): if sys.platform == "win32": GITS = ["git.cmd", "git.exe"] - out, rc = run_command(GITS, ["rev-parse", "--git-dir"], cwd=root, - hide_stderr=True) + # GIT_DIR can interfere with correct operation of Versioneer. + # It may be intended to be passed to the Versioneer-versioned project, + # but that should not change where we get our version from. + env = os.environ.copy() + env.pop("GIT_DIR", None) + runner = functools.partial(runner, env=env) + + _, rc = runner(GITS, ["rev-parse", "--git-dir"], cwd=root, + hide_stderr=not verbose) if rc != 0: if verbose: print("Directory %s not under git control" % root) @@ -234,15 +257,15 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty] # if there isn't one, this yields HEX[-dirty] (no NUM) - describe_out, rc = run_command(GITS, ["describe", "--tags", "--dirty=", - "--always", "--long", - "--match", "%s*" % tag_prefix], - cwd=root) + describe_out, rc = runner(GITS, [ + "describe", "--tags", "--dirty=", "--always", "--long", + "--match", f"{tag_prefix}[[:digit:]]*" + ], cwd=root) # --long was added in git-1.5.5 if describe_out is None: raise NotThisMethod("'git describe' failed") describe_out = describe_out.strip() - full_out, rc = run_command(GITS, ["rev-parse", "HEAD"], cwd=root) + full_out, rc = runner(GITS, ["rev-parse", "HEAD"], cwd=root) if full_out is None: raise NotThisMethod("'git rev-parse' failed") full_out = full_out.strip() @@ -252,6 +275,39 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): pieces["short"] = full_out[:7] # maybe improved later pieces["error"] = None + branch_name, rc = runner(GITS, ["rev-parse", "--abbrev-ref", "HEAD"], + cwd=root) + # --abbrev-ref was added in git-1.6.3 + if rc != 0 or branch_name is None: + raise NotThisMethod("'git rev-parse --abbrev-ref' returned error") + branch_name = branch_name.strip() + + if branch_name == "HEAD": + # If we aren't exactly on a branch, pick a branch which represents + # the current commit. If all else fails, we are on a branchless + # commit. + branches, rc = runner(GITS, ["branch", "--contains"], cwd=root) + # --contains was added in git-1.5.4 + if rc != 0 or branches is None: + raise NotThisMethod("'git branch --contains' returned error") + branches = branches.split("\n") + + # Remove the first line if we're running detached + if "(" in branches[0]: + branches.pop(0) + + # Strip off the leading "* " from the list of branches. + branches = [branch[2:] for branch in branches] + if "master" in branches: + branch_name = "master" + elif not branches: + branch_name = None + else: + # Pick the first branch that is returned. Good or bad. + branch_name = branches[0] + + pieces["branch"] = branch_name + # parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty] # TAG might have hyphens. git_describe = describe_out @@ -268,7 +324,7 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): # TAG-NUM-gHEX mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe) if not mo: - # unparseable. Maybe git-describe is misbehaving? + # unparsable. Maybe git-describe is misbehaving? pieces["error"] = ("unable to parse git-describe output: '%s'" % describe_out) return pieces @@ -293,13 +349,11 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): else: # HEX: no tags pieces["closest-tag"] = None - count_out, rc = run_command(GITS, ["rev-list", "HEAD", "--count"], - cwd=root) - pieces["distance"] = int(count_out) # total number of commits + out, rc = runner(GITS, ["rev-list", "HEAD", "--left-right"], cwd=root) + pieces["distance"] = len(out.split()) # total number of commits # commit date: see ISO-8601 comment in git_versions_from_keywords() - date = run_command(GITS, ["show", "-s", "--format=%ci", "HEAD"], - cwd=root)[0].strip() + date = runner(GITS, ["show", "-s", "--format=%ci", "HEAD"], cwd=root)[0].strip() # Use only the last line. Previous lines may contain GPG signature # information. date = date.splitlines()[-1] @@ -340,16 +394,64 @@ def render_pep440(pieces): return rendered +def render_pep440_branch(pieces): + """TAG[[.dev0]+DISTANCE.gHEX[.dirty]] . + + The ".dev0" means not master branch. Note that .dev0 sorts backwards + (a feature branch will appear "older" than the master branch). + + Exceptions: + 1: no tags. 0[.dev0]+untagged.DISTANCE.gHEX[.dirty] + """ + if pieces["closest-tag"]: + rendered = pieces["closest-tag"] + if pieces["distance"] or pieces["dirty"]: + if pieces["branch"] != "master": + rendered += ".dev0" + rendered += plus_or_dot(pieces) + rendered += "%d.g%s" % (pieces["distance"], pieces["short"]) + if pieces["dirty"]: + rendered += ".dirty" + else: + # exception #1 + rendered = "0" + if pieces["branch"] != "master": + rendered += ".dev0" + rendered += "+untagged.%d.g%s" % (pieces["distance"], + pieces["short"]) + if pieces["dirty"]: + rendered += ".dirty" + return rendered + + +def pep440_split_post(ver): + """Split pep440 version string at the post-release segment. + + Returns the release segments before the post-release and the + post-release version number (or -1 if no post-release segment is present). + """ + vc = str.split(ver, ".post") + return vc[0], int(vc[1] or 0) if len(vc) == 2 else None + + def render_pep440_pre(pieces): - """TAG[.post0.devDISTANCE] -- No -dirty. + """TAG[.postN.devDISTANCE] -- No -dirty. Exceptions: 1: no tags. 0.post0.devDISTANCE """ if pieces["closest-tag"]: - rendered = pieces["closest-tag"] if pieces["distance"]: - rendered += ".post0.dev%d" % pieces["distance"] + # update the post release segment + tag_version, post_version = pep440_split_post(pieces["closest-tag"]) + rendered = tag_version + if post_version is not None: + rendered += ".post%d.dev%d" % (post_version + 1, pieces["distance"]) + else: + rendered += ".post0.dev%d" % (pieces["distance"]) + else: + # no commits, use the tag as the version + rendered = pieces["closest-tag"] else: # exception #1 rendered = "0.post0.dev%d" % pieces["distance"] @@ -383,6 +485,35 @@ def render_pep440_post(pieces): return rendered +def render_pep440_post_branch(pieces): + """TAG[.postDISTANCE[.dev0]+gHEX[.dirty]] . + + The ".dev0" means not master branch. + + Exceptions: + 1: no tags. 0.postDISTANCE[.dev0]+gHEX[.dirty] + """ + if pieces["closest-tag"]: + rendered = pieces["closest-tag"] + if pieces["distance"] or pieces["dirty"]: + rendered += ".post%d" % pieces["distance"] + if pieces["branch"] != "master": + rendered += ".dev0" + rendered += plus_or_dot(pieces) + rendered += "g%s" % pieces["short"] + if pieces["dirty"]: + rendered += ".dirty" + else: + # exception #1 + rendered = "0.post%d" % pieces["distance"] + if pieces["branch"] != "master": + rendered += ".dev0" + rendered += "+g%s" % pieces["short"] + if pieces["dirty"]: + rendered += ".dirty" + return rendered + + def render_pep440_old(pieces): """TAG[.postDISTANCE[.dev0]] . @@ -459,10 +590,14 @@ def render(pieces, style): if style == "pep440": rendered = render_pep440(pieces) + elif style == "pep440-branch": + rendered = render_pep440_branch(pieces) elif style == "pep440-pre": rendered = render_pep440_pre(pieces) elif style == "pep440-post": rendered = render_pep440_post(pieces) + elif style == "pep440-post-branch": + rendered = render_pep440_post_branch(pieces) elif style == "pep440-old": rendered = render_pep440_old(pieces) elif style == "git-describe": @@ -498,7 +633,7 @@ def get_versions(): # versionfile_source is the relative path from the top of the source # tree (where the .git directory might live) to this file. Invert # this to find the root from __file__. - for i in cfg.versionfile_source.split('/'): + for _ in cfg.versionfile_source.split('/'): root = os.path.dirname(root) except NameError: return {"version": "0+unknown", "full-revisionid": None, diff --git a/numpy/array_api/__init__.py b/numpy/array_api/__init__.py index bbe2fdce26e3..5e58ee0a8998 100644 --- a/numpy/array_api/__init__.py +++ b/numpy/array_api/__init__.py @@ -121,7 +121,9 @@ "The numpy.array_api submodule is still experimental. See NEP 47.", stacklevel=2 ) -__all__ = [] +__array_api_version__ = "2021.12" + +__all__ = ["__array_api_version__"] from ._constants import e, inf, nan, pi diff --git a/numpy/array_api/_array_object.py b/numpy/array_api/_array_object.py index 8794c5ea5706..c4746fad96e7 100644 --- a/numpy/array_api/_array_object.py +++ b/numpy/array_api/_array_object.py @@ -29,10 +29,12 @@ _dtype_categories, ) -from typing import TYPE_CHECKING, Optional, Tuple, Union, Any +from typing import TYPE_CHECKING, Optional, Tuple, Union, Any, SupportsIndex +import types if TYPE_CHECKING: from ._typing import Any, PyCapsule, Device, Dtype + import numpy.typing as npt import numpy as np @@ -54,6 +56,7 @@ class Array: functions, such as asarray(). """ + _array: np.ndarray # Use a custom constructor instead of __init__, as manually initializing # this class is not supported API. @@ -108,11 +111,22 @@ def __repr__(self: Array, /) -> str: mid = np.array2string(self._array, separator=', ', prefix=prefix, suffix=suffix) return prefix + mid + suffix + # This function is not required by the spec, but we implement it here for + # convenience so that np.asarray(np.array_api.Array) will work. + def __array__(self, dtype: None | np.dtype[Any] = None) -> npt.NDArray[Any]: + """ + Warning: this method is NOT part of the array API spec. Implementers + of other libraries need not include it, and users should not assume it + will be present in other implementations. + + """ + return np.asarray(self._array, dtype=dtype) + # These are various helper functions to make the array behavior match the # spec in places where it either deviates from or is more strict than # NumPy behavior - def _check_allowed_dtypes(self, other, dtype_category, op): + def _check_allowed_dtypes(self, other: bool | int | float | Array, dtype_category: str, op: str) -> Array: """ Helper function for operators to only allow specific input dtypes @@ -163,6 +177,8 @@ def _promote_scalar(self, scalar): integer that is too large to fit in a NumPy integer dtype, or TypeError when the scalar type is incompatible with the dtype of self. """ + # Note: Only Python scalar types that match the array dtype are + # allowed. if isinstance(scalar, bool): if self.dtype not in _boolean_dtypes: raise TypeError( @@ -181,6 +197,9 @@ def _promote_scalar(self, scalar): else: raise TypeError("'scalar' must be a Python scalar") + # Note: scalars are unconditionally cast to the same dtype as the + # array. + # Note: the spec only specifies integer-dtype/int promotion # behavior for integers within the bounds of the integer dtype. # Outside of those bounds we use the default NumPy behavior (either @@ -188,7 +207,7 @@ def _promote_scalar(self, scalar): return Array._new(np.array(scalar, self.dtype)) @staticmethod - def _normalize_two_args(x1, x2): + def _normalize_two_args(x1, x2) -> Tuple[Array, Array]: """ Normalize inputs to two arg functions to fix type promotion rules @@ -224,8 +243,7 @@ def _normalize_two_args(x1, x2): # Note: A large fraction of allowed indices are disallowed here (see the # docstring below) - @staticmethod - def _validate_index(key, shape): + def _validate_index(self, key): """ Validate an index according to the array API. @@ -238,8 +256,7 @@ def _validate_index(key, shape): https://data-apis.org/array-api/latest/API_specification/indexing.html for the full list of required indexing behavior - This function either raises IndexError if the index ``key`` is - invalid, or a new key to be used in place of ``key`` in indexing. It + This function raises IndexError if the index ``key`` is invalid. It only raises ``IndexError`` on indices that are not already rejected by NumPy, as NumPy will already raise the appropriate error on such indices. ``shape`` may be None, in which case, only cases that are @@ -250,7 +267,7 @@ def _validate_index(key, shape): - Indices to not include an implicit ellipsis at the end. That is, every axis of an array must be explicitly indexed or an ellipsis - included. + included. This behaviour is sometimes referred to as flat indexing. - The start and stop of a slice may not be out of bounds. In particular, for a slice ``i:j:k`` on an axis of size ``n``, only the @@ -273,100 +290,122 @@ def _validate_index(key, shape): ``Array._new`` constructor, not this function. """ - if isinstance(key, slice): - if shape is None: - return key - if shape == (): - return key - if len(shape) > 1: + _key = key if isinstance(key, tuple) else (key,) + for i in _key: + if isinstance(i, bool) or not ( + isinstance(i, SupportsIndex) # i.e. ints + or isinstance(i, slice) + or i == Ellipsis + or i is None + or isinstance(i, Array) + or isinstance(i, np.ndarray) + ): raise IndexError( - "Multidimensional arrays must include an index for every axis or use an ellipsis" + f"Single-axes index {i} has {type(i)=}, but only " + "integers, slices (:), ellipsis (...), newaxis (None), " + "zero-dimensional integer arrays and boolean arrays " + "are specified in the Array API." ) - size = shape[0] - # Ensure invalid slice entries are passed through. - if key.start is not None: - try: - operator.index(key.start) - except TypeError: - return key - if not (-size <= key.start <= size): - raise IndexError( - "Slices with out-of-bounds start are not allowed in the array API namespace" - ) - if key.stop is not None: - try: - operator.index(key.stop) - except TypeError: - return key - step = 1 if key.step is None else key.step - if (step > 0 and not (-size <= key.stop <= size) - or step < 0 and not (-size - 1 <= key.stop <= max(0, size - 1))): - raise IndexError("Slices with out-of-bounds stop are not allowed in the array API namespace") - return key - - elif isinstance(key, tuple): - key = tuple(Array._validate_index(idx, None) for idx in key) - - for idx in key: - if ( - isinstance(idx, np.ndarray) - and idx.dtype in _boolean_dtypes - or isinstance(idx, (bool, np.bool_)) - ): - if len(key) == 1: - return key - raise IndexError( - "Boolean array indices combined with other indices are not allowed in the array API namespace" - ) - if isinstance(idx, tuple): - raise IndexError( - "Nested tuple indices are not allowed in the array API namespace" - ) - - if shape is None: - return key - n_ellipsis = key.count(...) - if n_ellipsis > 1: - return key - ellipsis_i = key.index(...) if n_ellipsis else len(key) - for idx, size in list(zip(key[:ellipsis_i], shape)) + list( - zip(key[:ellipsis_i:-1], shape[:ellipsis_i:-1]) - ): - Array._validate_index(idx, (size,)) - if n_ellipsis == 0 and len(key) < len(shape): + nonexpanding_key = [] + single_axes = [] + n_ellipsis = 0 + key_has_mask = False + for i in _key: + if i is not None: + nonexpanding_key.append(i) + if isinstance(i, Array) or isinstance(i, np.ndarray): + if i.dtype in _boolean_dtypes: + key_has_mask = True + single_axes.append(i) + else: + # i must not be an array here, to avoid elementwise equals + if i == Ellipsis: + n_ellipsis += 1 + else: + single_axes.append(i) + + n_single_axes = len(single_axes) + if n_ellipsis > 1: + return # handled by ndarray + elif n_ellipsis == 0: + # Note boolean masks must be the sole index, which we check for + # later on. + if not key_has_mask and n_single_axes < self.ndim: raise IndexError( - "Multidimensional arrays must include an index for every axis or use an ellipsis" + f"{self.ndim=}, but the multi-axes index only specifies " + f"{n_single_axes} dimensions. If this was intentional, " + "add a trailing ellipsis (...) which expands into as many " + "slices (:) as necessary - this is what np.ndarray arrays " + "implicitly do, but such flat indexing behaviour is not " + "specified in the Array API." ) - return key - elif isinstance(key, bool): - return key - elif isinstance(key, Array): - if key.dtype in _integer_dtypes: - if key.ndim != 0: + + if n_ellipsis == 0: + indexed_shape = self.shape + else: + ellipsis_start = None + for pos, i in enumerate(nonexpanding_key): + if not (isinstance(i, Array) or isinstance(i, np.ndarray)): + if i == Ellipsis: + ellipsis_start = pos + break + assert ellipsis_start is not None # sanity check + ellipsis_end = self.ndim - (n_single_axes - ellipsis_start) + indexed_shape = ( + self.shape[:ellipsis_start] + self.shape[ellipsis_end:] + ) + for i, side in zip(single_axes, indexed_shape): + if isinstance(i, slice): + if side == 0: + f_range = "0 (or None)" + else: + f_range = f"between -{side} and {side - 1} (or None)" + if i.start is not None: + try: + start = operator.index(i.start) + except TypeError: + pass # handled by ndarray + else: + if not (-side <= start <= side): + raise IndexError( + f"Slice {i} contains {start=}, but should be " + f"{f_range} for an axis of size {side} " + "(out-of-bounds starts are not specified in " + "the Array API)" + ) + if i.stop is not None: + try: + stop = operator.index(i.stop) + except TypeError: + pass # handled by ndarray + else: + if not (-side <= stop <= side): + raise IndexError( + f"Slice {i} contains {stop=}, but should be " + f"{f_range} for an axis of size {side} " + "(out-of-bounds stops are not specified in " + "the Array API)" + ) + elif isinstance(i, Array): + if i.dtype in _boolean_dtypes and len(_key) != 1: + assert isinstance(key, tuple) # sanity check raise IndexError( - "Non-zero dimensional integer array indices are not allowed in the array API namespace" + f"Single-axes index {i} is a boolean array and " + f"{len(key)=}, but masking is only specified in the " + "Array API when the array is the sole index." ) - return key._array - elif key is Ellipsis: - return key - elif key is None: - raise IndexError( - "newaxis indices are not allowed in the array API namespace" - ) - try: - key = operator.index(key) - if shape is not None and len(shape) > 1: + elif i.dtype in _integer_dtypes and i.ndim != 0: + raise IndexError( + f"Single-axes index {i} is a non-zero-dimensional " + "integer array, but advanced integer indexing is not " + "specified in the Array API." + ) + elif isinstance(i, tuple): raise IndexError( - "Multidimensional arrays must include an index for every axis or use an ellipsis" + f"Single-axes index {i} is a tuple, but nested tuple " + "indices are not specified in the Array API." ) - return key - except TypeError: - # Note: This also omits boolean arrays that are not already in - # Array() form, like a list of booleans. - raise IndexError( - "Only integers, slices (`:`), ellipsis (`...`), and boolean arrays are valid indices in the array API namespace" - ) # Everything below this line is required by the spec. @@ -403,7 +442,7 @@ def __and__(self: Array, other: Union[int, bool, Array], /) -> Array: def __array_namespace__( self: Array, /, *, api_version: Optional[str] = None - ) -> Any: + ) -> types.ModuleType: if api_version is not None and not api_version.startswith("2021."): raise ValueError(f"Unrecognized array API version: {api_version!r}") return array_api @@ -492,7 +531,10 @@ def __getitem__( """ # Note: Only indices required by the spec are allowed. See the # docstring of _validate_index - key = self._validate_index(key, self.shape) + self._validate_index(key) + if isinstance(key, Array): + # Indexing self._array with array_api arrays can be erroneous + key = key._array res = self._array.__getitem__(key) return self._new(res) @@ -642,15 +684,13 @@ def __pos__(self: Array, /) -> Array: res = self._array.__pos__() return self.__class__._new(res) - # PEP 484 requires int to be a subtype of float, but __pow__ should not - # accept int. - def __pow__(self: Array, other: Union[float, Array], /) -> Array: + def __pow__(self: Array, other: Union[int, float, Array], /) -> Array: """ Performs the operation __pow__. """ from ._elementwise_functions import pow - other = self._check_allowed_dtypes(other, "floating-point", "__pow__") + other = self._check_allowed_dtypes(other, "numeric", "__pow__") if other is NotImplemented: return other # Note: NumPy's __pow__ does not follow type promotion rules for 0-d @@ -681,7 +721,10 @@ def __setitem__( """ # Note: Only indices required by the spec are allowed. See the # docstring of _validate_index - key = self._validate_index(key, self.shape) + self._validate_index(key) + if isinstance(key, Array): + # Indexing self._array with array_api arrays can be erroneous + key = key._array self._array.__setitem__(key, asarray(value)._array) def __sub__(self: Array, other: Union[int, float, Array], /) -> Array: @@ -900,23 +943,23 @@ def __ror__(self: Array, other: Union[int, bool, Array], /) -> Array: res = self._array.__ror__(other._array) return self.__class__._new(res) - def __ipow__(self: Array, other: Union[float, Array], /) -> Array: + def __ipow__(self: Array, other: Union[int, float, Array], /) -> Array: """ Performs the operation __ipow__. """ - other = self._check_allowed_dtypes(other, "floating-point", "__ipow__") + other = self._check_allowed_dtypes(other, "numeric", "__ipow__") if other is NotImplemented: return other self._array.__ipow__(other._array) return self - def __rpow__(self: Array, other: Union[float, Array], /) -> Array: + def __rpow__(self: Array, other: Union[int, float, Array], /) -> Array: """ Performs the operation __rpow__. """ from ._elementwise_functions import pow - other = self._check_allowed_dtypes(other, "floating-point", "__rpow__") + other = self._check_allowed_dtypes(other, "numeric", "__rpow__") if other is NotImplemented: return other # Note: NumPy's __pow__ does not follow the spec type promotion rules @@ -1072,4 +1115,4 @@ def T(self) -> Array: # https://data-apis.org/array-api/latest/API_specification/array_object.html#t if self.ndim != 2: raise ValueError("x.T requires x to have 2 dimensions. Use x.mT to transpose stacks of matrices and permute_dims() to permute dimensions.") - return self._array.T + return self.__class__._new(self._array.T) diff --git a/numpy/array_api/_creation_functions.py b/numpy/array_api/_creation_functions.py index 741498ff610f..3b014d37b2d6 100644 --- a/numpy/array_api/_creation_functions.py +++ b/numpy/array_api/_creation_functions.py @@ -154,7 +154,7 @@ def eye( def from_dlpack(x: object, /) -> Array: from ._array_object import Array - return Array._new(np._from_dlpack(x)) + return Array._new(np.from_dlpack(x)) def full( diff --git a/numpy/array_api/_data_type_functions.py b/numpy/array_api/_data_type_functions.py index e4d6db61bb84..7026bd489563 100644 --- a/numpy/array_api/_data_type_functions.py +++ b/numpy/array_api/_data_type_functions.py @@ -50,11 +50,23 @@ def can_cast(from_: Union[Dtype, Array], to: Dtype, /) -> bool: See its docstring for more information. """ - from ._array_object import Array - if isinstance(from_, Array): - from_ = from_._array - return np.can_cast(from_, to) + from_ = from_.dtype + elif from_ not in _all_dtypes: + raise TypeError(f"{from_=}, but should be an array_api array or dtype") + if to not in _all_dtypes: + raise TypeError(f"{to=}, but should be a dtype") + # Note: We avoid np.can_cast() as it has discrepancies with the array API, + # since NumPy allows cross-kind casting (e.g., NumPy allows bool -> int8). + # See https://github.com/numpy/numpy/issues/20870 + try: + # We promote `from_` and `to` together. We then check if the promoted + # dtype is `to`, which indicates if `from_` can (up)cast to `to`. + dtype = _result_type(from_, to) + return to == dtype + except TypeError: + # _result_type() raises if the dtypes don't promote together + return False # These are internal objects for the return types of finfo and iinfo, since diff --git a/numpy/array_api/_elementwise_functions.py b/numpy/array_api/_elementwise_functions.py index 4408fe833b4c..c758a09447a0 100644 --- a/numpy/array_api/_elementwise_functions.py +++ b/numpy/array_api/_elementwise_functions.py @@ -591,8 +591,8 @@ def pow(x1: Array, x2: Array, /) -> Array: See its docstring for more information. """ - if x1.dtype not in _floating_dtypes or x2.dtype not in _floating_dtypes: - raise TypeError("Only floating-point dtypes are allowed in pow") + if x1.dtype not in _numeric_dtypes or x2.dtype not in _numeric_dtypes: + raise TypeError("Only numeric dtypes are allowed in pow") # Call result type here just to raise on disallowed type combinations _result_type(x1.dtype, x2.dtype) x1, x2 = Array._normalize_two_args(x1, x2) diff --git a/numpy/array_api/_manipulation_functions.py b/numpy/array_api/_manipulation_functions.py index 4f2114ff5cb6..7991f46a2728 100644 --- a/numpy/array_api/_manipulation_functions.py +++ b/numpy/array_api/_manipulation_functions.py @@ -52,6 +52,7 @@ def permute_dims(x: Array, /, axes: Tuple[int, ...]) -> Array: return Array._new(np.transpose(x._array, axes)) +# Note: the optional argument is called 'shape', not 'newshape' def reshape(x: Array, /, shape: Tuple[int, ...]) -> Array: """ Array API compatible wrapper for :py:func:`np.reshape `. diff --git a/numpy/array_api/_set_functions.py b/numpy/array_api/_set_functions.py index 05ee7e555838..0b4132cf87f8 100644 --- a/numpy/array_api/_set_functions.py +++ b/numpy/array_api/_set_functions.py @@ -41,14 +41,22 @@ def unique_all(x: Array, /) -> UniqueAllResult: See its docstring for more information. """ - res = np.unique( + values, indices, inverse_indices, counts = np.unique( x._array, return_counts=True, return_index=True, return_inverse=True, + equal_nan=False, + ) + # np.unique() flattens inverse indices, but they need to share x's shape + # See https://github.com/numpy/numpy/issues/20638 + inverse_indices = inverse_indices.reshape(x.shape) + return UniqueAllResult( + Array._new(values), + Array._new(indices), + Array._new(inverse_indices), + Array._new(counts), ) - - return UniqueAllResult(*[Array._new(i) for i in res]) def unique_counts(x: Array, /) -> UniqueCountsResult: @@ -57,6 +65,7 @@ def unique_counts(x: Array, /) -> UniqueCountsResult: return_counts=True, return_index=False, return_inverse=False, + equal_nan=False, ) return UniqueCountsResult(*[Array._new(i) for i in res]) @@ -68,13 +77,17 @@ def unique_inverse(x: Array, /) -> UniqueInverseResult: See its docstring for more information. """ - res = np.unique( + values, inverse_indices = np.unique( x._array, return_counts=False, return_index=False, return_inverse=True, + equal_nan=False, ) - return UniqueInverseResult(*[Array._new(i) for i in res]) + # np.unique() flattens inverse indices, but they need to share x's shape + # See https://github.com/numpy/numpy/issues/20638 + inverse_indices = inverse_indices.reshape(x.shape) + return UniqueInverseResult(Array._new(values), Array._new(inverse_indices)) def unique_values(x: Array, /) -> Array: @@ -88,5 +101,6 @@ def unique_values(x: Array, /) -> Array: return_counts=False, return_index=False, return_inverse=False, + equal_nan=False, ) return Array._new(res) diff --git a/numpy/array_api/_sorting_functions.py b/numpy/array_api/_sorting_functions.py index 9cd49786cb8d..afbb412f7f5e 100644 --- a/numpy/array_api/_sorting_functions.py +++ b/numpy/array_api/_sorting_functions.py @@ -5,6 +5,7 @@ import numpy as np +# Note: the descending keyword argument is new in this function def argsort( x: Array, /, *, axis: int = -1, descending: bool = False, stable: bool = True ) -> Array: @@ -15,12 +16,23 @@ def argsort( """ # Note: this keyword argument is different, and the default is different. kind = "stable" if stable else "quicksort" - res = np.argsort(x._array, axis=axis, kind=kind) - if descending: - res = np.flip(res, axis=axis) + if not descending: + res = np.argsort(x._array, axis=axis, kind=kind) + else: + # As NumPy has no native descending sort, we imitate it here. Note that + # simply flipping the results of np.argsort(x._array, ...) would not + # respect the relative order like it would in native descending sorts. + res = np.flip( + np.argsort(np.flip(x._array, axis=axis), axis=axis, kind=kind), + axis=axis, + ) + # Rely on flip()/argsort() to validate axis + normalised_axis = axis if axis >= 0 else x.ndim + axis + max_i = x.shape[normalised_axis] - 1 + res = max_i - res return Array._new(res) - +# Note: the descending keyword argument is new in this function def sort( x: Array, /, *, axis: int = -1, descending: bool = False, stable: bool = True ) -> Array: diff --git a/numpy/array_api/_statistical_functions.py b/numpy/array_api/_statistical_functions.py index 7bee3f4db23f..5bc831ac2965 100644 --- a/numpy/array_api/_statistical_functions.py +++ b/numpy/array_api/_statistical_functions.py @@ -65,8 +65,8 @@ def prod( # Note: sum() and prod() always upcast float32 to float64 for dtype=None # We need to do so here before computing the product to avoid overflow if dtype is None and x.dtype == float32: - x = asarray(x, dtype=float64) - return Array._new(np.prod(x._array, axis=axis, keepdims=keepdims)) + dtype = float64 + return Array._new(np.prod(x._array, dtype=dtype, axis=axis, keepdims=keepdims)) def std( diff --git a/numpy/array_api/linalg.py b/numpy/array_api/linalg.py index 8d7ba659ea9d..d214046effd3 100644 --- a/numpy/array_api/linalg.py +++ b/numpy/array_api/linalg.py @@ -1,8 +1,11 @@ from __future__ import annotations from ._dtypes import _floating_dtypes, _numeric_dtypes +from ._manipulation_functions import reshape from ._array_object import Array +from ..core.numeric import normalize_axis_tuple + from typing import TYPE_CHECKING if TYPE_CHECKING: from ._typing import Literal, Optional, Sequence, Tuple, Union @@ -89,7 +92,6 @@ def diagonal(x: Array, /, *, offset: int = 0) -> Array: return Array._new(np.diagonal(x._array, offset=offset, axis1=-2, axis2=-1)) -# Note: the keyword argument name upper is different from np.linalg.eigh def eigh(x: Array, /) -> EighResult: """ Array API compatible wrapper for :py:func:`np.linalg.eigh `. @@ -106,7 +108,6 @@ def eigh(x: Array, /) -> EighResult: return EighResult(*map(Array._new, np.linalg.eigh(x._array))) -# Note: the keyword argument name upper is different from np.linalg.eigvalsh def eigvalsh(x: Array, /) -> Array: """ Array API compatible wrapper for :py:func:`np.linalg.eigvalsh `. @@ -346,6 +347,8 @@ def svd(x: Array, /, *, full_matrices: bool = True) -> SVDResult: # Note: svdvals is not in NumPy (but it is in SciPy). It is equivalent to # np.linalg.svd(compute_uv=False). def svdvals(x: Array, /) -> Union[Array, Tuple[Array, ...]]: + if x.dtype not in _floating_dtypes: + raise TypeError('Only floating-point dtypes are allowed in svdvals') return Array._new(np.linalg.svd(x._array, compute_uv=False)) # Note: tensordot is the numpy top-level namespace but not in np.linalg @@ -366,13 +369,28 @@ def trace(x: Array, /, *, offset: int = 0) -> Array: See its docstring for more information. """ + if x.dtype not in _numeric_dtypes: + raise TypeError('Only numeric dtypes are allowed in trace') # Note: trace always operates on the last two axes, whereas np.trace # operates on the first two axes by default return Array._new(np.asarray(np.trace(x._array, offset=offset, axis1=-2, axis2=-1))) # Note: vecdot is not in NumPy def vecdot(x1: Array, x2: Array, /, *, axis: int = -1) -> Array: - return tensordot(x1, x2, axes=((axis,), (axis,))) + if x1.dtype not in _numeric_dtypes or x2.dtype not in _numeric_dtypes: + raise TypeError('Only numeric dtypes are allowed in vecdot') + ndim = max(x1.ndim, x2.ndim) + x1_shape = (1,)*(ndim - x1.ndim) + tuple(x1.shape) + x2_shape = (1,)*(ndim - x2.ndim) + tuple(x2.shape) + if x1_shape[axis] != x2_shape[axis]: + raise ValueError("x1 and x2 must have the same size along the given axis") + + x1_, x2_ = np.broadcast_arrays(x1._array, x2._array) + x1_ = np.moveaxis(x1_, axis, -1) + x2_ = np.moveaxis(x2_, axis, -1) + + res = x1_[..., None, :] @ x2_[..., None] + return Array._new(res[..., 0, 0]) # Note: the name here is different from norm(). The array API norm is split @@ -380,7 +398,7 @@ def vecdot(x1: Array, x2: Array, /, *, axis: int = -1) -> Array: # The type for ord should be Optional[Union[int, float, Literal[np.inf, # -np.inf]]] but Literal does not support floating-point literals. -def vector_norm(x: Array, /, *, axis: Optional[Union[int, Tuple[int, int]]] = None, keepdims: bool = False, ord: Optional[Union[int, float]] = 2) -> Array: +def vector_norm(x: Array, /, *, axis: Optional[Union[int, Tuple[int, ...]]] = None, keepdims: bool = False, ord: Optional[Union[int, float]] = 2) -> Array: """ Array API compatible wrapper for :py:func:`np.linalg.norm `. @@ -391,18 +409,38 @@ def vector_norm(x: Array, /, *, axis: Optional[Union[int, Tuple[int, int]]] = No if x.dtype not in _floating_dtypes: raise TypeError('Only floating-point dtypes are allowed in norm') + # np.linalg.norm tries to do a matrix norm whenever axis is a 2-tuple or + # when axis=None and the input is 2-D, so to force a vector norm, we make + # it so the input is 1-D (for axis=None), or reshape so that norm is done + # on a single dimension. a = x._array if axis is None: - a = a.flatten() - axis = 0 + # Note: np.linalg.norm() doesn't handle 0-D arrays + a = a.ravel() + _axis = 0 elif isinstance(axis, tuple): - # Note: The axis argument supports any number of axes, whereas norm() - # only supports a single axis for vector norm. - rest = tuple(i for i in range(a.ndim) if i not in axis) + # Note: The axis argument supports any number of axes, whereas + # np.linalg.norm() only supports a single axis for vector norm. + normalized_axis = normalize_axis_tuple(axis, x.ndim) + rest = tuple(i for i in range(a.ndim) if i not in normalized_axis) newshape = axis + rest - a = np.transpose(a, newshape).reshape((np.prod([a.shape[i] for i in axis]), *[a.shape[i] for i in rest])) - axis = 0 - return Array._new(np.linalg.norm(a, axis=axis, keepdims=keepdims, ord=ord)) + a = np.transpose(a, newshape).reshape( + (np.prod([a.shape[i] for i in axis], dtype=int), *[a.shape[i] for i in rest])) + _axis = 0 + else: + _axis = axis + + res = Array._new(np.linalg.norm(a, axis=_axis, ord=ord)) + + if keepdims: + # We can't reuse np.linalg.norm(keepdims) because of the reshape hacks + # above to avoid matrix norm logic. + shape = list(x.shape) + _axis = normalize_axis_tuple(range(x.ndim) if axis is None else axis, x.ndim) + for i in _axis: + shape[i] = 1 + res = reshape(res, tuple(shape)) + return res __all__ = ['cholesky', 'cross', 'det', 'diagonal', 'eigh', 'eigvalsh', 'inv', 'matmul', 'matrix_norm', 'matrix_power', 'matrix_rank', 'matrix_transpose', 'outer', 'pinv', 'qr', 'slogdet', 'solve', 'svd', 'svdvals', 'tensordot', 'trace', 'vecdot', 'vector_norm'] diff --git a/numpy/array_api/tests/test_array_object.py b/numpy/array_api/tests/test_array_object.py index 12479d7655c7..f6efacefaee1 100644 --- a/numpy/array_api/tests/test_array_object.py +++ b/numpy/array_api/tests/test_array_object.py @@ -2,8 +2,10 @@ from numpy.testing import assert_raises import numpy as np +import pytest -from .. import ones, asarray, result_type, all, equal +from .. import ones, asarray, reshape, result_type, all, equal +from .._array_object import Array from .._dtypes import ( _all_dtypes, _boolean_dtypes, @@ -16,6 +18,7 @@ int32, int64, uint64, + bool as bool_, ) @@ -69,11 +72,6 @@ def test_validate_index(): assert_raises(IndexError, lambda: a[[0, 1]]) assert_raises(IndexError, lambda: a[np.array([[0, 1]])]) - # np.newaxis is not allowed - assert_raises(IndexError, lambda: a[None]) - assert_raises(IndexError, lambda: a[None, ...]) - assert_raises(IndexError, lambda: a[..., None]) - # Multiaxis indices must contain exactly as many indices as dimensions assert_raises(IndexError, lambda: a[()]) assert_raises(IndexError, lambda: a[0,]) @@ -97,7 +95,7 @@ def test_operators(): "__mul__": "numeric", "__ne__": "all", "__or__": "integer_or_boolean", - "__pow__": "floating", + "__pow__": "numeric", "__rshift__": "integer", "__sub__": "numeric", "__truediv__": "floating", @@ -301,3 +299,77 @@ def test_device_property(): assert all(equal(asarray(a, device='cpu'), a)) assert_raises(ValueError, lambda: asarray(a, device='gpu')) + +def test_array_properties(): + a = ones((1, 2, 3)) + b = ones((2, 3)) + assert_raises(ValueError, lambda: a.T) + + assert isinstance(b.T, Array) + assert b.T.shape == (3, 2) + + assert isinstance(a.mT, Array) + assert a.mT.shape == (1, 3, 2) + assert isinstance(b.mT, Array) + assert b.mT.shape == (3, 2) + +def test___array__(): + a = ones((2, 3), dtype=int16) + assert np.asarray(a) is a._array + b = np.asarray(a, dtype=np.float64) + assert np.all(np.equal(b, np.ones((2, 3), dtype=np.float64))) + assert b.dtype == np.float64 + +def test_allow_newaxis(): + a = ones(5) + indexed_a = a[None, :] + assert indexed_a.shape == (1, 5) + +def test_disallow_flat_indexing_with_newaxis(): + a = ones((3, 3, 3)) + with pytest.raises(IndexError): + a[None, 0, 0] + +def test_disallow_mask_with_newaxis(): + a = ones((3, 3, 3)) + with pytest.raises(IndexError): + a[None, asarray(True)] + +@pytest.mark.parametrize("shape", [(), (5,), (3, 3, 3)]) +@pytest.mark.parametrize("index", ["string", False, True]) +def test_error_on_invalid_index(shape, index): + a = ones(shape) + with pytest.raises(IndexError): + a[index] + +def test_mask_0d_array_without_errors(): + a = ones(()) + a[asarray(True)] + +@pytest.mark.parametrize( + "i", [slice(5), slice(5, 0), asarray(True), asarray([0, 1])] +) +def test_error_on_invalid_index_with_ellipsis(i): + a = ones((3, 3, 3)) + with pytest.raises(IndexError): + a[..., i] + with pytest.raises(IndexError): + a[i, ...] + +def test_array_keys_use_private_array(): + """ + Indexing operations convert array keys before indexing the internal array + + Fails when array_api array keys are not converted into NumPy-proper arrays + in __getitem__(). This is achieved by passing array_api arrays with 0-sized + dimensions, which NumPy-proper treats erroneously - not sure why! + + TODO: Find and use appropriate __setitem__() case. + """ + a = ones((0, 0), dtype=bool_) + assert a[a].shape == (0,) + + a = ones((0,), dtype=bool_) + key = ones((0, 0), dtype=bool_) + with pytest.raises(IndexError): + a[key] diff --git a/numpy/array_api/tests/test_data_type_functions.py b/numpy/array_api/tests/test_data_type_functions.py new file mode 100644 index 000000000000..efe3d0abd4be --- /dev/null +++ b/numpy/array_api/tests/test_data_type_functions.py @@ -0,0 +1,19 @@ +import pytest + +from numpy import array_api as xp + + +@pytest.mark.parametrize( + "from_, to, expected", + [ + (xp.int8, xp.int16, True), + (xp.int16, xp.int8, False), + (xp.bool, xp.int8, False), + (xp.asarray(0, dtype=xp.uint8), xp.int8, False), + ], +) +def test_can_cast(from_, to, expected): + """ + can_cast() returns correct result + """ + assert xp.can_cast(from_, to) == expected diff --git a/numpy/array_api/tests/test_elementwise_functions.py b/numpy/array_api/tests/test_elementwise_functions.py index a9274aec9278..b2fb44e766f8 100644 --- a/numpy/array_api/tests/test_elementwise_functions.py +++ b/numpy/array_api/tests/test_elementwise_functions.py @@ -66,7 +66,7 @@ def test_function_types(): "negative": "numeric", "not_equal": "all", "positive": "numeric", - "pow": "floating-point", + "pow": "numeric", "remainder": "numeric", "round": "numeric", "sign": "numeric", diff --git a/numpy/array_api/tests/test_set_functions.py b/numpy/array_api/tests/test_set_functions.py new file mode 100644 index 000000000000..b8eb65d430dc --- /dev/null +++ b/numpy/array_api/tests/test_set_functions.py @@ -0,0 +1,19 @@ +import pytest +from hypothesis import given +from hypothesis.extra.array_api import make_strategies_namespace + +from numpy import array_api as xp + +xps = make_strategies_namespace(xp) + + +@pytest.mark.parametrize("func", [xp.unique_all, xp.unique_inverse]) +@given(xps.arrays(dtype=xps.scalar_dtypes(), shape=xps.array_shapes())) +def test_inverse_indices_shape(func, x): + """ + Inverse indices share shape of input array + + See https://github.com/numpy/numpy/issues/20638 + """ + out = func(x) + assert out.inverse_indices.shape == x.shape diff --git a/numpy/array_api/tests/test_sorting_functions.py b/numpy/array_api/tests/test_sorting_functions.py new file mode 100644 index 000000000000..9848bbfeb7bd --- /dev/null +++ b/numpy/array_api/tests/test_sorting_functions.py @@ -0,0 +1,23 @@ +import pytest + +from numpy import array_api as xp + + +@pytest.mark.parametrize( + "obj, axis, expected", + [ + ([0, 0], -1, [0, 1]), + ([0, 1, 0], -1, [1, 0, 2]), + ([[0, 1], [1, 1]], 0, [[1, 0], [0, 1]]), + ([[0, 1], [1, 1]], 1, [[1, 0], [0, 1]]), + ], +) +def test_stable_desc_argsort(obj, axis, expected): + """ + Indices respect relative order of a descending stable-sort + + See https://github.com/numpy/numpy/issues/20778 + """ + x = xp.asarray(obj) + out = xp.argsort(x, axis=axis, stable=True, descending=True) + assert xp.all(out == xp.asarray(expected)) diff --git a/numpy/array_api/tests/test_validation.py b/numpy/array_api/tests/test_validation.py new file mode 100644 index 000000000000..0dd100d15924 --- /dev/null +++ b/numpy/array_api/tests/test_validation.py @@ -0,0 +1,27 @@ +from typing import Callable + +import pytest + +from numpy import array_api as xp + + +def p(func: Callable, *args, **kwargs): + f_sig = ", ".join( + [str(a) for a in args] + [f"{k}={v}" for k, v in kwargs.items()] + ) + id_ = f"{func.__name__}({f_sig})" + return pytest.param(func, args, kwargs, id=id_) + + +@pytest.mark.parametrize( + "func, args, kwargs", + [ + p(xp.can_cast, 42, xp.int8), + p(xp.can_cast, xp.int8, 42), + p(xp.result_type, 42), + ], +) +def test_raises_on_invalid_types(func, args, kwargs): + """Function raises TypeError when passed invalidly-typed inputs""" + with pytest.raises(TypeError): + func(*args, **kwargs) diff --git a/numpy/compat/_pep440.py b/numpy/compat/_pep440.py new file mode 100644 index 000000000000..73d0afb5e95f --- /dev/null +++ b/numpy/compat/_pep440.py @@ -0,0 +1,487 @@ +"""Utility to compare pep440 compatible version strings. + +The LooseVersion and StrictVersion classes that distutils provides don't +work; they don't recognize anything like alpha/beta/rc/dev versions. +""" + +# Copyright (c) Donald Stufft and individual contributors. +# All rights reserved. + +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: + +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. + +# 2. 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. + +# 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 HOLDER 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. + +import collections +import itertools +import re + + +__all__ = [ + "parse", "Version", "LegacyVersion", "InvalidVersion", "VERSION_PATTERN", +] + + +# BEGIN packaging/_structures.py + + +class Infinity: + def __repr__(self): + return "Infinity" + + def __hash__(self): + return hash(repr(self)) + + def __lt__(self, other): + return False + + def __le__(self, other): + return False + + def __eq__(self, other): + return isinstance(other, self.__class__) + + def __ne__(self, other): + return not isinstance(other, self.__class__) + + def __gt__(self, other): + return True + + def __ge__(self, other): + return True + + def __neg__(self): + return NegativeInfinity + + +Infinity = Infinity() + + +class NegativeInfinity: + def __repr__(self): + return "-Infinity" + + def __hash__(self): + return hash(repr(self)) + + def __lt__(self, other): + return True + + def __le__(self, other): + return True + + def __eq__(self, other): + return isinstance(other, self.__class__) + + def __ne__(self, other): + return not isinstance(other, self.__class__) + + def __gt__(self, other): + return False + + def __ge__(self, other): + return False + + def __neg__(self): + return Infinity + + +# BEGIN packaging/version.py + + +NegativeInfinity = NegativeInfinity() + +_Version = collections.namedtuple( + "_Version", + ["epoch", "release", "dev", "pre", "post", "local"], +) + + +def parse(version): + """ + Parse the given version string and return either a :class:`Version` object + or a :class:`LegacyVersion` object depending on if the given version is + a valid PEP 440 version or a legacy version. + """ + try: + return Version(version) + except InvalidVersion: + return LegacyVersion(version) + + +class InvalidVersion(ValueError): + """ + An invalid version was found, users should refer to PEP 440. + """ + + +class _BaseVersion: + + def __hash__(self): + return hash(self._key) + + def __lt__(self, other): + return self._compare(other, lambda s, o: s < o) + + def __le__(self, other): + return self._compare(other, lambda s, o: s <= o) + + def __eq__(self, other): + return self._compare(other, lambda s, o: s == o) + + def __ge__(self, other): + return self._compare(other, lambda s, o: s >= o) + + def __gt__(self, other): + return self._compare(other, lambda s, o: s > o) + + def __ne__(self, other): + return self._compare(other, lambda s, o: s != o) + + def _compare(self, other, method): + if not isinstance(other, _BaseVersion): + return NotImplemented + + return method(self._key, other._key) + + +class LegacyVersion(_BaseVersion): + + def __init__(self, version): + self._version = str(version) + self._key = _legacy_cmpkey(self._version) + + def __str__(self): + return self._version + + def __repr__(self): + return "".format(repr(str(self))) + + @property + def public(self): + return self._version + + @property + def base_version(self): + return self._version + + @property + def local(self): + return None + + @property + def is_prerelease(self): + return False + + @property + def is_postrelease(self): + return False + + +_legacy_version_component_re = re.compile( + r"(\d+ | [a-z]+ | \.| -)", re.VERBOSE, +) + +_legacy_version_replacement_map = { + "pre": "c", "preview": "c", "-": "final-", "rc": "c", "dev": "@", +} + + +def _parse_version_parts(s): + for part in _legacy_version_component_re.split(s): + part = _legacy_version_replacement_map.get(part, part) + + if not part or part == ".": + continue + + if part[:1] in "0123456789": + # pad for numeric comparison + yield part.zfill(8) + else: + yield "*" + part + + # ensure that alpha/beta/candidate are before final + yield "*final" + + +def _legacy_cmpkey(version): + # We hardcode an epoch of -1 here. A PEP 440 version can only have an epoch + # greater than or equal to 0. This will effectively put the LegacyVersion, + # which uses the defacto standard originally implemented by setuptools, + # as before all PEP 440 versions. + epoch = -1 + + # This scheme is taken from pkg_resources.parse_version setuptools prior to + # its adoption of the packaging library. + parts = [] + for part in _parse_version_parts(version.lower()): + if part.startswith("*"): + # remove "-" before a prerelease tag + if part < "*final": + while parts and parts[-1] == "*final-": + parts.pop() + + # remove trailing zeros from each series of numeric parts + while parts and parts[-1] == "00000000": + parts.pop() + + parts.append(part) + parts = tuple(parts) + + return epoch, parts + + +# Deliberately not anchored to the start and end of the string, to make it +# easier for 3rd party code to reuse +VERSION_PATTERN = r""" + v? + (?: + (?:(?P[0-9]+)!)? # epoch + (?P[0-9]+(?:\.[0-9]+)*) # release segment + (?P
                                          # pre-release
+            [-_\.]?
+            (?P(a|b|c|rc|alpha|beta|pre|preview))
+            [-_\.]?
+            (?P[0-9]+)?
+        )?
+        (?P                                         # post release
+            (?:-(?P[0-9]+))
+            |
+            (?:
+                [-_\.]?
+                (?Ppost|rev|r)
+                [-_\.]?
+                (?P[0-9]+)?
+            )
+        )?
+        (?P                                          # dev release
+            [-_\.]?
+            (?Pdev)
+            [-_\.]?
+            (?P[0-9]+)?
+        )?
+    )
+    (?:\+(?P[a-z0-9]+(?:[-_\.][a-z0-9]+)*))?       # local version
+"""
+
+
+class Version(_BaseVersion):
+
+    _regex = re.compile(
+        r"^\s*" + VERSION_PATTERN + r"\s*$",
+        re.VERBOSE | re.IGNORECASE,
+    )
+
+    def __init__(self, version):
+        # Validate the version and parse it into pieces
+        match = self._regex.search(version)
+        if not match:
+            raise InvalidVersion("Invalid version: '{0}'".format(version))
+
+        # Store the parsed out pieces of the version
+        self._version = _Version(
+            epoch=int(match.group("epoch")) if match.group("epoch") else 0,
+            release=tuple(int(i) for i in match.group("release").split(".")),
+            pre=_parse_letter_version(
+                match.group("pre_l"),
+                match.group("pre_n"),
+            ),
+            post=_parse_letter_version(
+                match.group("post_l"),
+                match.group("post_n1") or match.group("post_n2"),
+            ),
+            dev=_parse_letter_version(
+                match.group("dev_l"),
+                match.group("dev_n"),
+            ),
+            local=_parse_local_version(match.group("local")),
+        )
+
+        # Generate a key which will be used for sorting
+        self._key = _cmpkey(
+            self._version.epoch,
+            self._version.release,
+            self._version.pre,
+            self._version.post,
+            self._version.dev,
+            self._version.local,
+        )
+
+    def __repr__(self):
+        return "".format(repr(str(self)))
+
+    def __str__(self):
+        parts = []
+
+        # Epoch
+        if self._version.epoch != 0:
+            parts.append("{0}!".format(self._version.epoch))
+
+        # Release segment
+        parts.append(".".join(str(x) for x in self._version.release))
+
+        # Pre-release
+        if self._version.pre is not None:
+            parts.append("".join(str(x) for x in self._version.pre))
+
+        # Post-release
+        if self._version.post is not None:
+            parts.append(".post{0}".format(self._version.post[1]))
+
+        # Development release
+        if self._version.dev is not None:
+            parts.append(".dev{0}".format(self._version.dev[1]))
+
+        # Local version segment
+        if self._version.local is not None:
+            parts.append(
+                "+{0}".format(".".join(str(x) for x in self._version.local))
+            )
+
+        return "".join(parts)
+
+    @property
+    def public(self):
+        return str(self).split("+", 1)[0]
+
+    @property
+    def base_version(self):
+        parts = []
+
+        # Epoch
+        if self._version.epoch != 0:
+            parts.append("{0}!".format(self._version.epoch))
+
+        # Release segment
+        parts.append(".".join(str(x) for x in self._version.release))
+
+        return "".join(parts)
+
+    @property
+    def local(self):
+        version_string = str(self)
+        if "+" in version_string:
+            return version_string.split("+", 1)[1]
+
+    @property
+    def is_prerelease(self):
+        return bool(self._version.dev or self._version.pre)
+
+    @property
+    def is_postrelease(self):
+        return bool(self._version.post)
+
+
+def _parse_letter_version(letter, number):
+    if letter:
+        # We assume there is an implicit 0 in a pre-release if there is
+        # no numeral associated with it.
+        if number is None:
+            number = 0
+
+        # We normalize any letters to their lower-case form
+        letter = letter.lower()
+
+        # We consider some words to be alternate spellings of other words and
+        # in those cases we want to normalize the spellings to our preferred
+        # spelling.
+        if letter == "alpha":
+            letter = "a"
+        elif letter == "beta":
+            letter = "b"
+        elif letter in ["c", "pre", "preview"]:
+            letter = "rc"
+        elif letter in ["rev", "r"]:
+            letter = "post"
+
+        return letter, int(number)
+    if not letter and number:
+        # We assume that if we are given a number but not given a letter,
+        # then this is using the implicit post release syntax (e.g., 1.0-1)
+        letter = "post"
+
+        return letter, int(number)
+
+
+_local_version_seperators = re.compile(r"[\._-]")
+
+
+def _parse_local_version(local):
+    """
+    Takes a string like abc.1.twelve and turns it into ("abc", 1, "twelve").
+    """
+    if local is not None:
+        return tuple(
+            part.lower() if not part.isdigit() else int(part)
+            for part in _local_version_seperators.split(local)
+        )
+
+
+def _cmpkey(epoch, release, pre, post, dev, local):
+    # When we compare a release version, we want to compare it with all of the
+    # trailing zeros removed. So we'll use a reverse the list, drop all the now
+    # leading zeros until we come to something non-zero, then take the rest,
+    # re-reverse it back into the correct order, and make it a tuple and use
+    # that for our sorting key.
+    release = tuple(
+        reversed(list(
+            itertools.dropwhile(
+                lambda x: x == 0,
+                reversed(release),
+            )
+        ))
+    )
+
+    # We need to "trick" the sorting algorithm to put 1.0.dev0 before 1.0a0.
+    # We'll do this by abusing the pre-segment, but we _only_ want to do this
+    # if there is no pre- or a post-segment. If we have one of those, then
+    # the normal sorting rules will handle this case correctly.
+    if pre is None and post is None and dev is not None:
+        pre = -Infinity
+    # Versions without a pre-release (except as noted above) should sort after
+    # those with one.
+    elif pre is None:
+        pre = Infinity
+
+    # Versions without a post-segment should sort before those with one.
+    if post is None:
+        post = -Infinity
+
+    # Versions without a development segment should sort after those with one.
+    if dev is None:
+        dev = Infinity
+
+    if local is None:
+        # Versions without a local segment should sort before those with one.
+        local = -Infinity
+    else:
+        # Versions with a local segment need that segment parsed to implement
+        # the sorting rules in PEP440.
+        # - Alphanumeric segments sort before numeric segments
+        # - Alphanumeric segments sort lexicographically
+        # - Numeric segments sort numerically
+        # - Shorter versions sort before longer versions when the prefixes
+        #   match exactly
+        local = tuple(
+            (i, "") if isinstance(i, int) else (-Infinity, i)
+            for i in local
+        )
+
+    return epoch, release, pre, post, dev, local
diff --git a/numpy/compat/py3k.py b/numpy/compat/py3k.py
index 1fa17621a287..3d10bb988c2f 100644
--- a/numpy/compat/py3k.py
+++ b/numpy/compat/py3k.py
@@ -107,7 +107,9 @@ def __exit__(self, *excinfo):
 
 def npy_load_module(name, fn, info=None):
     """
-    Load a module.
+    Load a module. Uses ``load_module`` which will be deprecated in python
+    3.12. An alternative that uses ``exec_module`` is in
+    numpy.distutils.misc_util.exec_mod_from_location
 
     .. versionadded:: 1.11.2
 
diff --git a/numpy/conftest.py b/numpy/conftest.py
index fd5fdd77d224..3d110c874884 100644
--- a/numpy/conftest.py
+++ b/numpy/conftest.py
@@ -30,7 +30,7 @@
 hypothesis.settings.register_profile(
     name="np.test() profile",
     deadline=None, print_blob=True, database=None, derandomize=True,
-    suppress_health_check=hypothesis.HealthCheck.all(),
+    suppress_health_check=list(hypothesis.HealthCheck),
 )
 # Note that the default profile is chosen based on the presence 
 # of pytest.ini, but can be overridden by passing the 
@@ -117,3 +117,20 @@ def add_np(doctest_namespace):
 @pytest.fixture(autouse=True)
 def env_setup(monkeypatch):
     monkeypatch.setenv('PYTHONHASHSEED', '0')
+
+
+@pytest.fixture(params=[True, False])
+def weak_promotion(request):
+    """
+    Fixture to ensure "legacy" promotion state or change it to use the new
+    weak promotion (plus warning).  `old_promotion` should be used as a
+    parameter in the function.
+    """
+    state = numpy._get_promotion_state()
+    if request.param:
+        numpy._set_promotion_state("weak_and_warn")
+    else:
+        numpy._set_promotion_state("legacy")
+
+    yield request.param
+    numpy._set_promotion_state(state)
diff --git a/numpy/core/__init__.py b/numpy/core/__init__.py
index b89e27f0f765..748705e3321d 100644
--- a/numpy/core/__init__.py
+++ b/numpy/core/__init__.py
@@ -75,8 +75,10 @@
 from . import fromnumeric
 from .fromnumeric import *
 from . import defchararray as char
+from . import records
 from . import records as rec
 from .records import record, recarray, format_parser
+# Note: module name memmap is overwritten by a class with same name
 from .memmap import *
 from .defchararray import chararray
 from . import function_base
diff --git a/numpy/core/_add_newdocs.py b/numpy/core/_add_newdocs.py
index 078c5897678c..d75f9ec64ef5 100644
--- a/numpy/core/_add_newdocs.py
+++ b/numpy/core/_add_newdocs.py
@@ -384,7 +384,7 @@
     >>> luf(lambda i,j:i*i + j/2, a, b)
     array([  0.5,   1.5,   4.5,   9.5,  16.5])
 
-    If operand flags `"writeonly"` or `"readwrite"` are used the
+    If operand flags ``"writeonly"`` or ``"readwrite"`` are used the
     operands may be views into the original data with the
     `WRITEBACKIFCOPY` flag. In this case `nditer` must be used as a
     context manager or the `nditer.close` method must be called before
@@ -833,7 +833,7 @@
         the returned array will be forced to be a base-class array (default).
     ndmin : int, optional
         Specifies the minimum number of dimensions that the resulting
-        array should have.  Ones will be pre-pended to the shape as
+        array should have.  Ones will be prepended to the shape as
         needed to meet this requirement.
     ${ARRAY_FUNCTION_LIKE}
 
@@ -1084,13 +1084,32 @@
 
     Examples
     --------
-    >>> x = np.arange(6).reshape(2,3)
-    >>> np.ascontiguousarray(x, dtype=np.float32)
-    array([[0., 1., 2.],
-           [3., 4., 5.]], dtype=float32)
+    Starting with a Fortran-contiguous array:
+
+    >>> x = np.ones((2, 3), order='F')
+    >>> x.flags['F_CONTIGUOUS']
+    True
+
+    Calling ``ascontiguousarray`` makes a C-contiguous copy:
+
+    >>> y = np.ascontiguousarray(x)
+    >>> y.flags['C_CONTIGUOUS']
+    True
+    >>> np.may_share_memory(x, y)
+    False
+
+    Now, starting with a C-contiguous array:
+
+    >>> x = np.ones((2, 3), order='C')
     >>> x.flags['C_CONTIGUOUS']
     True
 
+    Then, calling ``ascontiguousarray`` returns the same object:
+
+    >>> y = np.ascontiguousarray(x)
+    >>> x is y
+    True
+
     Note: This function returns an array with at least one-dimension (1-d)
     so it will not preserve 0-d arrays.
 
@@ -1130,12 +1149,31 @@
 
     Examples
     --------
-    >>> x = np.arange(6).reshape(2,3)
+    Starting with a C-contiguous array:
+
+    >>> x = np.ones((2, 3), order='C')
+    >>> x.flags['C_CONTIGUOUS']
+    True
+
+    Calling ``asfortranarray`` makes a Fortran-contiguous copy:
+
     >>> y = np.asfortranarray(x)
-    >>> x.flags['F_CONTIGUOUS']
-    False
     >>> y.flags['F_CONTIGUOUS']
     True
+    >>> np.may_share_memory(x, y)
+    False
+
+    Now, starting with a Fortran-contiguous array:
+
+    >>> x = np.ones((2, 3), order='F')
+    >>> x.flags['F_CONTIGUOUS']
+    True
+
+    Then, calling ``asfortranarray`` returns the same object:
+
+    >>> y = np.asfortranarray(x)
+    >>> x is y
+    True
 
     Note: This function returns an array with at least one-dimension (1-d)
     so it will not preserve 0-d arrays.
@@ -1316,8 +1354,8 @@
             decimal numbers, an operation which is better spelt
             ``frombuffer(string, dtype, count)``. If `string` contains unicode
             text, the binary mode of `fromstring` will first encode it into
-            bytes using either utf-8 (python 3) or the default encoding
-            (python 2), neither of which produce sane results.
+            bytes using utf-8, which will not produce sane results.
+
     ${ARRAY_FUNCTION_LIKE}
 
         .. versionadded:: 1.20.0
@@ -1398,6 +1436,11 @@
         An iterable object providing data for the array.
     dtype : data-type
         The data-type of the returned array.
+
+        .. versionchanged:: 1.23
+            Object and subarray dtypes are now supported (note that the final
+            result is not 1-D for a subarray dtype).
+
     count : int, optional
         The number of items to read from *iterable*.  The default is -1,
         which means all data is read.
@@ -1421,6 +1464,18 @@
     >>> np.fromiter(iterable, float)
     array([  0.,   1.,   4.,   9.,  16.])
 
+    A carefully constructed subarray dtype will lead to higher dimensional
+    results:
+
+    >>> iterable = ((x+1, x+2) for x in range(5))
+    >>> np.fromiter(iterable, dtype=np.dtype((int, 2)))
+    array([[1, 2],
+           [2, 3],
+           [3, 4],
+           [4, 5],
+           [5, 6]])
+
+
     """.replace(
         "${ARRAY_FUNCTION_LIKE}",
         array_function_like_doc,
@@ -1545,6 +1600,12 @@
     -------
     out : ndarray
 
+    See also
+    --------
+    ndarray.tobytes
+        Inverse of this operation, construct Python bytes from the raw data
+        bytes in the array.
+
     Notes
     -----
     If the buffer has data that is not in machine byte-order, this should
@@ -1557,6 +1618,10 @@
     The data of the resulting array will not be byteswapped, but will be
     interpreted correctly.
 
+    This function creates a view into the original object.  This should be safe
+    in general, but it may make sense to copy the result when the original
+    object is mutable or untrusted.
+
     Examples
     --------
     >>> s = b'hello world'
@@ -1573,21 +1638,49 @@
         array_function_like_doc,
     ))
 
-add_newdoc('numpy.core.multiarray', '_from_dlpack',
+add_newdoc('numpy.core.multiarray', 'from_dlpack',
     """
-    _from_dlpack(x, /)
+    from_dlpack(x, /)
 
     Create a NumPy array from an object implementing the ``__dlpack__``
-    protocol.
+    protocol. Generally, the returned NumPy array is a read-only view
+    of the input object. See [1]_ and [2]_ for more details.
 
-    See Also
+    Parameters
+    ----------
+    x : object
+        A Python object that implements the ``__dlpack__`` and
+        ``__dlpack_device__`` methods.
+
+    Returns
+    -------
+    out : ndarray
+
+    References
+    ----------
+    .. [1] Array API documentation,
+       https://data-apis.org/array-api/latest/design_topics/data_interchange.html#syntax-for-data-interchange-with-dlpack
+
+    .. [2] Python specification for DLPack,
+       https://dmlc.github.io/dlpack/latest/python_spec.html
+
+    Examples
     --------
-    `Array API documentation
-    `_
+    >>> import torch
+    >>> x = torch.arange(10)
+    >>> # create a view of the torch tensor "x" in NumPy
+    >>> y = np.from_dlpack(x)
     """)
 
 add_newdoc('numpy.core', 'fastCopyAndTranspose',
-    """_fastCopyAndTranspose(a)""")
+    """
+    fastCopyAndTranspose(a)
+
+    .. deprecated:: 1.24
+
+       fastCopyAndTranspose is deprecated and will be removed. Use the copy and
+       transpose methods instead, e.g. ``arr.T.copy()``
+    """)
 
 add_newdoc('numpy.core.multiarray', 'correlate',
     """cross_correlate(a,v, mode=0)""")
@@ -1598,13 +1691,25 @@
 
     Return evenly spaced values within a given interval.
 
-    Values are generated within the half-open interval ``[start, stop)``
-    (in other words, the interval including `start` but excluding `stop`).
-    For integer arguments the function is equivalent to the Python built-in
-    `range` function, but returns an ndarray rather than a list.
+    ``arange`` can be called with a varying number of positional arguments:
+
+    * ``arange(stop)``: Values are generated within the half-open interval
+      ``[0, stop)`` (in other words, the interval including `start` but
+      excluding `stop`).
+    * ``arange(start, stop)``: Values are generated within the half-open
+      interval ``[start, stop)``.
+    * ``arange(start, stop, step)`` Values are generated within the half-open
+      interval ``[start, stop)``, with spacing between values given by
+      ``step``.
+
+    For integer arguments the function is roughly equivalent to the Python
+    built-in :py:class:`range`, but returns an ndarray rather than a ``range``
+    instance.
 
     When using a non-integer step, such as 0.1, it is often better to use
-    `numpy.linspace`. See the warnings section below for more information.
+    `numpy.linspace`.
+
+    See the Warning sections below for more information.
 
     Parameters
     ----------
@@ -1620,7 +1725,7 @@
         between two adjacent values, ``out[i+1] - out[i]``.  The default
         step size is 1.  If `step` is specified as a position argument,
         `start` must also be given.
-    dtype : dtype
+    dtype : dtype, optional
         The type of the output array.  If `dtype` is not given, infer the data
         type from the other input arguments.
     ${ARRAY_FUNCTION_LIKE}
@@ -1656,11 +1761,26 @@
 
     In such cases, the use of `numpy.linspace` should be preferred.
 
+    The built-in :py:class:`range` generates :std:doc:`Python built-in integers
+    that have arbitrary size `, while `numpy.arange`
+    produces `numpy.int32` or `numpy.int64` numbers. This may result in
+    incorrect results for large integer values::
+
+      >>> power = 40
+      >>> modulo = 10000
+      >>> x1 = [(n ** power) % modulo for n in range(8)]
+      >>> x2 = [(n ** power) % modulo for n in np.arange(8)]
+      >>> print(x1)
+      [0, 1, 7776, 8801, 6176, 625, 6576, 4001]  # correct
+      >>> print(x2)
+      [0, 1, 7776, 7185, 0, 5969, 4816, 3361]  # incorrect
+
     See Also
     --------
     numpy.linspace : Evenly spaced numbers with careful handling of endpoints.
     numpy.ogrid: Arrays of evenly spaced numbers in N-dimensions.
     numpy.mgrid: Grid-shaped arrays of evenly spaced numbers in N-dimensions.
+    :ref:`how-to-partition`
 
     Examples
     --------
@@ -1727,7 +1847,7 @@
 
     Notes
     -----
-    .. WARNING::
+    .. warning::
        Use with care!  Incorrect usage may lead to memory errors.
 
     A function replacing an operator cannot make use of that operator.
@@ -1757,7 +1877,8 @@
 
     Returns the data type with the smallest size and smallest scalar
     kind to which both ``type1`` and ``type2`` may be safely cast.
-    The returned data type is always in native byte order.
+    The returned data type is always considered "canonical", this mainly
+    means that the promoted dtype will always be in native byte order.
 
     This function is symmetric, but rarely associative.
 
@@ -1775,6 +1896,8 @@
 
     Notes
     -----
+    Please see `numpy.result_type` for additional information about promotion.
+
     .. versionadded:: 1.6.0
 
     Starting in NumPy 1.9, promote_types function now returns a valid string
@@ -1783,6 +1906,12 @@
     dtype, even if it wasn't long enough to store the max integer/float value
     converted to a string.
 
+    .. versionchanged:: 1.23.0
+
+    NumPy now supports promotion for more structured dtypes.  It will now
+    remove unnecessary padding from a structure dtype and promote included
+    fields individually.
+
     See Also
     --------
     result_type, dtype, can_cast
@@ -2265,10 +2394,6 @@
     """Array protocol: Python side."""))
 
 
-add_newdoc('numpy.core.multiarray', 'ndarray', ('__array_finalize__',
-    """None."""))
-
-
 add_newdoc('numpy.core.multiarray', 'ndarray', ('__array_priority__',
     """Array priority."""))
 
@@ -2278,12 +2403,12 @@
 
 add_newdoc('numpy.core.multiarray', 'ndarray', ('__dlpack__',
     """a.__dlpack__(*, stream=None)
-    
+
     DLPack Protocol: Part of the Array API."""))
 
 add_newdoc('numpy.core.multiarray', 'ndarray', ('__dlpack_device__',
     """a.__dlpack_device__()
-    
+
     DLPack Protocol: Part of the Array API."""))
 
 add_newdoc('numpy.core.multiarray', 'ndarray', ('base',
@@ -2392,6 +2517,12 @@
     """
     Data-type of the array's elements.
 
+    .. warning::
+
+        Setting ``arr.dtype`` is discouraged and may be deprecated in the
+        future.  Setting will replace the ``dtype`` without modifying the
+        memory (see also `ndarray.view` and `ndarray.astype`).
+
     Parameters
     ----------
     None
@@ -2402,6 +2533,8 @@
 
     See Also
     --------
+    ndarray.astype : Cast the values contained in the array to a new data-type.
+    ndarray.view : Create a view of the same data but a different data-type.
     numpy.dtype
 
     Examples
@@ -2477,11 +2610,6 @@
         This array is a copy of some other array. The C-API function
         PyArray_ResolveWritebackIfCopy must be called before deallocating
         to the base array will be updated with the contents of this array.
-    UPDATEIFCOPY (U)
-        (Deprecated, use WRITEBACKIFCOPY) This array is a copy of some other array.
-        When this array is
-        deallocated, the base array will be updated with the contents of
-        this array.
     FNC
         F_CONTIGUOUS and not C_CONTIGUOUS.
     FORC
@@ -2499,13 +2627,12 @@
     or by using lowercased attribute names (as in ``a.flags.writeable``). Short flag
     names are only supported in dictionary access.
 
-    Only the WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED flags can be
+    Only the WRITEBACKIFCOPY, WRITEABLE, and ALIGNED flags can be
     changed by the user, via direct assignment to the attribute or dictionary
     entry, or by calling `ndarray.setflags`.
 
     The array flags cannot be set arbitrarily:
 
-    - UPDATEIFCOPY can only be set ``False``.
     - WRITEBACKIFCOPY can only be set ``False``.
     - ALIGNED can only be set ``True`` if the data is truly aligned.
     - WRITEABLE can only be set ``True`` if the array owns its own memory
@@ -2633,6 +2760,11 @@
     the array and the remaining dimensions. Reshaping an array in-place will
     fail if a copy is required.
 
+    .. warning::
+
+        Setting ``arr.shape`` is discouraged and may be deprecated in the
+        future.  Using `ndarray.reshape` is the preferred approach.
+
     Examples
     --------
     >>> x = np.array([1, 2, 3, 4])
@@ -2658,8 +2790,9 @@
 
     See Also
     --------
-    numpy.reshape : similar function
-    ndarray.reshape : similar method
+    numpy.shape : Equivalent getter function.
+    numpy.reshape : Function similar to setting ``shape``.
+    ndarray.reshape : Method similar to setting ``shape``.
 
     """))
 
@@ -2702,6 +2835,12 @@
     A more detailed explanation of strides can be found in the
     "ndarray.rst" file in the NumPy reference guide.
 
+    .. warning::
+
+        Setting ``arr.strides`` is discouraged and may be deprecated in the
+        future.  `numpy.lib.stride_tricks.as_strided` should be preferred
+        to create a new view of the same data in a safer way.
+
     Notes
     -----
     Imagine an array of 32-bit integers (each 4 bytes)::
@@ -2754,24 +2893,25 @@
 
 add_newdoc('numpy.core.multiarray', 'ndarray', ('T',
     """
-    The transposed array.
+    View of the transposed array.
 
     Same as ``self.transpose()``.
 
     Examples
     --------
-    >>> x = np.array([[1.,2.],[3.,4.]])
-    >>> x
-    array([[ 1.,  2.],
-           [ 3.,  4.]])
-    >>> x.T
-    array([[ 1.,  3.],
-           [ 2.,  4.]])
-    >>> x = np.array([1.,2.,3.,4.])
-    >>> x
-    array([ 1.,  2.,  3.,  4.])
-    >>> x.T
-    array([ 1.,  2.,  3.,  4.])
+    >>> a = np.array([[1, 2], [3, 4]])
+    >>> a
+    array([[1, 2],
+           [3, 4]])
+    >>> a.T
+    array([[1, 3],
+           [2, 4]])
+
+    >>> a = np.array([1, 2, 3, 4])
+    >>> a
+    array([1, 2, 3, 4])
+    >>> a.T
+    array([1, 2, 3, 4])
 
     See Also
     --------
@@ -2797,6 +2937,14 @@
     """))
 
 
+add_newdoc('numpy.core.multiarray', 'ndarray', ('__array_finalize__',
+    """a.__array_finalize__(obj, /)
+
+    Present so subclasses can call super. Does nothing.
+
+    """))
+
+
 add_newdoc('numpy.core.multiarray', 'ndarray', ('__array_prepare__',
     """a.__array_prepare__(array[, context], /)
 
@@ -2925,7 +3073,7 @@
 
 add_newdoc('numpy.core.multiarray', 'ndarray', ('argmax',
     """
-    a.argmax(axis=None, out=None)
+    a.argmax(axis=None, out=None, *, keepdims=False)
 
     Return indices of the maximum values along the given axis.
 
@@ -2940,7 +3088,7 @@
 
 add_newdoc('numpy.core.multiarray', 'ndarray', ('argmin',
     """
-    a.argmin(axis=None, out=None)
+    a.argmin(axis=None, out=None, *, keepdims=False)
 
     Return indices of the minimum values along the given axis.
 
@@ -3341,6 +3489,24 @@
     >>> a
     array([1.,  1.])
 
+    Fill expects a scalar value and always behaves the same as assigning
+    to a single array element.  The following is a rare example where this
+    distinction is important:
+
+    >>> a = np.array([None, None], dtype=object)
+    >>> a[0] = np.array(3)
+    >>> a
+    array([array(3), None], dtype=object)
+    >>> a.fill(np.array(3))
+    >>> a
+    array([array(3), array(3)], dtype=object)
+
+    Where other forms of assignments will unpack the array being assigned:
+
+    >>> a[...] = np.array(3)
+    >>> a
+    array([3, 3], dtype=object)
+
     """))
 
 
@@ -3906,13 +4072,13 @@
     """
     a.setflags(write=None, align=None, uic=None)
 
-    Set array flags WRITEABLE, ALIGNED, (WRITEBACKIFCOPY and UPDATEIFCOPY),
+    Set array flags WRITEABLE, ALIGNED, WRITEBACKIFCOPY,
     respectively.
 
     These Boolean-valued flags affect how numpy interprets the memory
     area used by `a` (see Notes below). The ALIGNED flag can only
     be set to True if the data is actually aligned according to the type.
-    The WRITEBACKIFCOPY and (deprecated) UPDATEIFCOPY flags can never be set
+    The WRITEBACKIFCOPY and flag can never be set
     to True. The flag WRITEABLE can only be set to True if the array owns its
     own memory, or the ultimate owner of the memory exposes a writeable buffer
     interface, or is a string. (The exception for string is made so that
@@ -3932,15 +4098,13 @@
     Array flags provide information about how the memory area used
     for the array is to be interpreted. There are 7 Boolean flags
     in use, only four of which can be changed by the user:
-    WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED.
+    WRITEBACKIFCOPY, WRITEABLE, and ALIGNED.
 
     WRITEABLE (W) the data area can be written to;
 
     ALIGNED (A) the data and strides are aligned appropriately for the hardware
     (as determined by the compiler);
 
-    UPDATEIFCOPY (U) (deprecated), replaced by WRITEBACKIFCOPY;
-
     WRITEBACKIFCOPY (X) this array is a copy of some other array (referenced
     by .base). When the C-API function PyArray_ResolveWritebackIfCopy is
     called, the base array will be updated with the contents of this array.
@@ -3964,7 +4128,6 @@
       WRITEABLE : True
       ALIGNED : True
       WRITEBACKIFCOPY : False
-      UPDATEIFCOPY : False
     >>> y.setflags(write=0, align=0)
     >>> y.flags
       C_CONTIGUOUS : True
@@ -3973,7 +4136,6 @@
       WRITEABLE : False
       ALIGNED : False
       WRITEBACKIFCOPY : False
-      UPDATEIFCOPY : False
     >>> y.setflags(uic=1)
     Traceback (most recent call last):
       File "", line 1, in 
@@ -4083,7 +4245,7 @@
 
     See Also
     --------
-    numpy.partition : Return a parititioned copy of an array.
+    numpy.partition : Return a partitioned copy of an array.
     argpartition : Indirect partition.
     sort : Full sort.
 
@@ -4310,6 +4472,12 @@
     s : bytes
         Python bytes exhibiting a copy of `a`'s raw data.
 
+    See also
+    --------
+    frombuffer
+        Inverse of this operation, construct a 1-dimensional array from Python
+        bytes.
+
     Examples
     --------
     >>> x = np.array([[0, 1], [2, 3]], dtype='>> a = np.array([1, 2, 3, 4])
+    >>> a
+    array([1, 2, 3, 4])
+    >>> a.transpose()
+    array([1, 2, 3, 4])
+
     """))
 
 
@@ -4459,14 +4625,13 @@
     memory.
 
     For ``a.view(some_dtype)``, if ``some_dtype`` has a different number of
-    bytes per entry than the previous dtype (for example, converting a
-    regular array to a structured array), then the behavior of the view
-    cannot be predicted just from the superficial appearance of ``a`` (shown
-    by ``print(a)``). It also depends on exactly how ``a`` is stored in
-    memory. Therefore if ``a`` is C-ordered versus fortran-ordered, versus
-    defined as a slice or transpose, etc., the view may give different
-    results.
+    bytes per entry than the previous dtype (for example, converting a regular
+    array to a structured array), then the last axis of ``a`` must be
+    contiguous. This axis will be resized in the result.
 
+    .. versionchanged:: 1.23.0
+       Only the last axis needs to be contiguous. Previously, the entire array
+       had to be C-contiguous.
 
     Examples
     --------
@@ -4511,19 +4676,34 @@
     Views that change the dtype size (bytes per entry) should normally be
     avoided on arrays defined by slices, transposes, fortran-ordering, etc.:
 
-    >>> x = np.array([[1,2,3],[4,5,6]], dtype=np.int16)
-    >>> y = x[:, 0:2]
+    >>> x = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.int16)
+    >>> y = x[:, ::2]
     >>> y
-    array([[1, 2],
-           [4, 5]], dtype=int16)
+    array([[1, 3],
+           [4, 6]], dtype=int16)
     >>> y.view(dtype=[('width', np.int16), ('length', np.int16)])
     Traceback (most recent call last):
         ...
-    ValueError: To change to a dtype of a different size, the array must be C-contiguous
+    ValueError: To change to a dtype of a different size, the last axis must be contiguous
     >>> z = y.copy()
     >>> z.view(dtype=[('width', np.int16), ('length', np.int16)])
-    array([[(1, 2)],
-           [(4, 5)]], dtype=[('width', '>> x = np.arange(2 * 3 * 4, dtype=np.int8).reshape(2, 3, 4)
+    >>> x.transpose(1, 0, 2).view(np.int16)
+    array([[[ 256,  770],
+            [3340, 3854]],
+    
+           [[1284, 1798],
+            [4368, 4882]],
+    
+           [[2312, 2826],
+            [5396, 5910]]], dtype=int16)
+
     """))
 
 
@@ -4769,6 +4949,15 @@
     its memory, in which case you can traverse ``a.base`` for a memory handler.
     """)
 
+add_newdoc('numpy.core.multiarray', '_get_madvise_hugepage',
+    """
+    _get_madvise_hugepage() -> bool
+
+    Get use of ``madvise (2)`` MADV_HUGEPAGE support when
+    allocating the array data. Returns the currently set value.
+    See `global_state` for more information.
+    """)
+
 add_newdoc('numpy.core.multiarray', '_set_madvise_hugepage',
     """
     _set_madvise_hugepage(enabled: bool) -> bool
@@ -5225,7 +5414,7 @@
     dtype : data-type code, optional
         The data-type used to represent the intermediate results. Defaults
         to the data-type of the output array if such is provided, or the
-        the data-type of the input array if no output array is provided.
+        data-type of the input array if no output array is provided.
     out : ndarray, None, or tuple of ndarray and None, optional
         A location into which the result is stored. If not provided or None,
         a freshly-allocated array is returned. For consistency with
@@ -5505,6 +5694,165 @@
 
     """))
 
+add_newdoc('numpy.core', 'ufunc', ('resolve_dtypes',
+    """
+    resolve_dtypes(dtypes, *, signature=None, casting=None, reduction=False)
+
+    Find the dtypes NumPy will use for the operation.  Both input and
+    output dtypes are returned and may differ from those provided.
+
+    .. note::
+
+        This function always applies NEP 50 rules since it is not provided
+        any actual values.  The Python types ``int``, ``float``, and
+        ``complex`` thus behave weak and should be passed for "untyped"
+        Python input.
+
+    Parameters
+    ----------
+    dtypes : tuple of dtypes, None, or literal int, float, complex
+        The input dtypes for each operand.  Output operands can be
+        None, indicating that the dtype must be found.
+    signature : tuple of DTypes or None, optional
+        If given, enforces exact DType (classes) of the specific operand.
+        The ufunc ``dtype`` argument is equivalent to passing a tuple with
+        only output dtypes set.
+    casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
+        The casting mode when casting is necessary.  This is identical to
+        the ufunc call casting modes.
+    reduction : boolean
+        If given, the resolution assumes a reduce operation is happening
+        which slightly changes the promotion and type resolution rules.
+        `dtypes` is usually something like ``(None, np.dtype("i2"), None)``
+        for reductions (first input is also the output).
+
+        .. note::
+
+            The default casting mode is "same_kind", however, as of
+            NumPy 1.24, NumPy uses "unsafe" for reductions.
+
+    Returns
+    -------
+    dtypes : tuple of dtypes
+        The dtypes which NumPy would use for the calculation.  Note that
+        dtypes may not match the passed in ones (casting is necessary).
+
+    See Also
+    --------
+    numpy.ufunc._resolve_dtypes_and_context :
+        Similar function to this, but returns additional information which
+        give access to the core C functionality of NumPy.
+
+    Examples
+    --------
+    This API requires passing dtypes, define them for convenience:
+
+    >>> int32 = np.dtype("int32")
+    >>> float32 = np.dtype("float32")
+
+    The typical ufunc call does not pass an output dtype.  `np.add` has two
+    inputs and one output, so leave the output as ``None`` (not provided):
+
+    >>> np.add.resolve_dtypes((int32, float32, None))
+    (dtype('float64'), dtype('float64'), dtype('float64'))
+
+    The loop found uses "float64" for all operands (including the output), the
+    first input would be cast.
+
+    ``resolve_dtypes`` supports "weak" handling for Python scalars by passing
+    ``int``, ``float``, or ``complex``:
+
+    >>> np.add.resolve_dtypes((float32, float, None))
+    (dtype('float32'), dtype('float32'), dtype('float32'))
+
+    Where the Python ``float`` behaves samilar to a Python value ``0.0``
+    in a ufunc call.  (See :ref:`NEP 50 ` for details.)
+
+    """))
+
+add_newdoc('numpy.core', 'ufunc', ('_resolve_dtypes_and_context',
+    """
+    _resolve_dtypes_and_context(dtypes, *, signature=None, casting=None, reduction=False)
+
+    See `numpy.ufunc.resolve_dtypes` for parameter information.  This
+    function is considered *unstable*.  You may use it, but the returned
+    information is NumPy version specific and expected to change.
+    Large API/ABI changes are not expected, but a new NumPy version is
+    expected to require updating code using this functionality.
+
+    This function is designed to be used in conjunction with
+    `numpy.ufunc._get_strided_loop`.  The calls are split to mirror the C API
+    and allow future improvements.
+
+    Returns
+    -------
+    dtypes : tuple of dtypes
+    call_info :
+        PyCapsule with all necessary information to get access to low level
+        C calls.  See `numpy.ufunc._get_strided_loop` for more information.
+
+    """))
+
+add_newdoc('numpy.core', 'ufunc', ('_get_strided_loop',
+    """
+    _get_strided_loop(call_info, /, *, fixed_strides=None)
+
+    This function fills in the ``call_info`` capsule to include all
+    information necessary to call the low-level strided loop from NumPy.
+
+    See notes for more information.
+
+    Parameters
+    ----------
+    call_info : PyCapsule
+        The PyCapsule returned by `numpy.ufunc._resolve_dtypes_and_context`.
+    fixed_strides : tuple of int or None, optional
+        A tuple with fixed byte strides of all input arrays.  NumPy may use
+        this information to find specialized loops, so any call must follow
+        the given stride.  Use ``None`` to indicate that the stride is not
+        known (or not fixed) for all calls.
+
+    Notes
+    -----
+    Together with `numpy.ufunc._resolve_dtypes_and_context` this function
+    gives low-level access to the NumPy ufunc loops.
+    The first function does general preparation and returns the required
+    information. It returns this as a C capsule with the version specific
+    name ``numpy_1.24_ufunc_call_info``.
+    The NumPy 1.24 ufunc call info capsule has the following layout::
+
+        typedef struct {
+            PyArrayMethod_StridedLoop *strided_loop;
+            PyArrayMethod_Context *context;
+            NpyAuxData *auxdata;
+
+            /* Flag information (expected to change) */
+            npy_bool requires_pyapi;  /* GIL is required by loop */
+
+            /* Loop doesn't set FPE flags; if not set check FPE flags */
+            npy_bool no_floatingpoint_errors;
+        } ufunc_call_info;
+
+    Note that the first call only fills in the ``context``.  The call to
+    ``_get_strided_loop`` fills in all other data.
+    Please see the ``numpy/experimental_dtype_api.h`` header for exact
+    call information; the main thing to note is that the new-style loops
+    return 0 on success, -1 on failure.  They are passed context as new
+    first input and ``auxdata`` as (replaced) last.
+
+    Only the ``strided_loop``signature is considered guaranteed stable
+    for NumPy bug-fix releases.  All other API is tied to the experimental
+    API versioning.
+
+    The reason for the split call is that cast information is required to
+    decide what the fixed-strides will be.
+
+    NumPy ties the lifetime of the ``auxdata`` information to the capsule.
+
+    """))
+
+
+
 ##############################################################################
 #
 # Documentation for dtype attributes and methods
diff --git a/numpy/core/_add_newdocs_scalars.py b/numpy/core/_add_newdocs_scalars.py
index 94859a9d556d..15d37522ad68 100644
--- a/numpy/core/_add_newdocs_scalars.py
+++ b/numpy/core/_add_newdocs_scalars.py
@@ -3,10 +3,11 @@
 our sphinx ``conf.py`` during doc builds, where we want to avoid showing
 platform-dependent information.
 """
+import sys
+import os
 from numpy.core import dtype
 from numpy.core import numerictypes as _numerictypes
 from numpy.core.function_base import add_newdoc
-import platform
 
 ##############################################################################
 #
@@ -50,6 +51,21 @@ def type_aliases_gen():
     ])
 
 
+def _get_platform_and_machine():
+    try:
+        system, _, _, _, machine = os.uname()
+    except AttributeError:
+        system = sys.platform
+        if system == 'win32':
+            machine = os.environ.get('PROCESSOR_ARCHITEW6432', '') \
+                    or os.environ.get('PROCESSOR_ARCHITECTURE', '')
+        else:
+            machine = 'unknown'
+    return system, machine
+
+
+_system, _machine = _get_platform_and_machine()
+_doc_alias_string = f":Alias on this platform ({_system} {_machine}):"
 
 
 def add_newdoc_for_scalar_type(obj, fixed_aliases, doc):
@@ -57,17 +73,22 @@ def add_newdoc_for_scalar_type(obj, fixed_aliases, doc):
     o = getattr(_numerictypes, obj)
 
     character_code = dtype(o).char
-    canonical_name_doc = "" if obj == o.__name__ else ":Canonical name: `numpy.{}`\n    ".format(obj)
-    alias_doc = ''.join(":Alias: `numpy.{}`\n    ".format(alias) for alias in fixed_aliases)
-    alias_doc += ''.join(":Alias on this platform ({} {}): `numpy.{}`: {}.\n    ".format(platform.system(), platform.machine(), alias, doc)
+    canonical_name_doc = "" if obj == o.__name__ else \
+                        f":Canonical name: `numpy.{obj}`\n    "
+    if fixed_aliases:
+        alias_doc = ''.join(f":Alias: `numpy.{alias}`\n    "
+                            for alias in fixed_aliases)
+    else:
+        alias_doc = ''
+    alias_doc += ''.join(f"{_doc_alias_string} `numpy.{alias}`: {doc}.\n    "
                          for (alias_type, alias, doc) in possible_aliases if alias_type is o)
-    docstring = """
-    {doc}
+
+    docstring = f"""
+    {doc.strip()}
 
     :Character code: ``'{character_code}'``
     {canonical_name_doc}{alias_doc}
-    """.format(doc=doc.strip(), character_code=character_code,
-               canonical_name_doc=canonical_name_doc, alias_doc=alias_doc)
+    """
 
     add_newdoc('numpy.core.numerictypes', obj, docstring)
 
@@ -204,16 +225,52 @@ def add_newdoc_for_scalar_type(obj, fixed_aliases, doc):
 
 add_newdoc_for_scalar_type('void', [],
     r"""
-    Either an opaque sequence of bytes, or a structure.
+    np.void(length_or_data, /, dtype=None)
+
+    Create a new structured or unstructured void scalar.
+
+    Parameters
+    ----------
+    length_or_data : int, array-like, bytes-like, object
+       One of multiple meanings (see notes).  The length or
+       bytes data of an unstructured void.  Or alternatively,
+       the data to be stored in the new scalar when `dtype`
+       is provided.
+       This can be an array-like, in which case an array may
+       be returned.
+    dtype : dtype, optional
+        If provided the dtype of the new scalar.  This dtype must
+        be "void" dtype (i.e. a structured or unstructured void,
+        see also :ref:`defining-structured-types`).
+
+       ..versionadded:: 1.24
+
+    Notes
+    -----
+    For historical reasons and because void scalars can represent both
+    arbitrary byte data and structured dtypes, the void constructor
+    has three calling conventions:
+
+    1. ``np.void(5)`` creates a ``dtype="V5"`` scalar filled with five
+       ``\0`` bytes.  The 5 can be a Python or NumPy integer.
+    2. ``np.void(b"bytes-like")`` creates a void scalar from the byte string.
+       The dtype itemsize will match the byte string length, here ``"V10"``.
+    3. When a ``dtype=`` is passed the call is rougly the same as an
+       array creation.  However, a void scalar rather than array is returned.
+
+    Please see the examples which show all three different conventions.
 
+    Examples
+    --------
+    >>> np.void(5)
+    void(b'\x00\x00\x00\x00\x00')
     >>> np.void(b'abcd')
     void(b'\x61\x62\x63\x64')
+    >>> np.void((5, 3.2, "eggs"), dtype="i,d,S5")
+    (5, 3.2, b'eggs')  # looks like a tuple, but is `np.void`
+    >>> np.void(3, dtype=[('x', np.int8), ('y', np.int8)])
+    (3, 3)  # looks like a tuple, but is `np.void`
 
-    Structured `void` scalars can only be constructed via extraction from :ref:`structured_arrays`:
-
-    >>> arr = np.array((1, 2), dtype=[('x', np.int8), ('y', np.int8)])
-    >>> arr[()]
-    (1, 2)  # looks like a tuple, but is `np.void`
     """)
 
 add_newdoc_for_scalar_type('datetime64', [],
diff --git a/numpy/core/_asarray.py b/numpy/core/_asarray.py
index ecb4e7c39d0c..28f1fe6fa72b 100644
--- a/numpy/core/_asarray.py
+++ b/numpy/core/_asarray.py
@@ -14,6 +14,15 @@
 __all__ = ["require"]
 
 
+POSSIBLE_FLAGS = {
+    'C': 'C', 'C_CONTIGUOUS': 'C', 'CONTIGUOUS': 'C',
+    'F': 'F', 'F_CONTIGUOUS': 'F', 'FORTRAN': 'F',
+    'A': 'A', 'ALIGNED': 'A',
+    'W': 'W', 'WRITEABLE': 'W',
+    'O': 'O', 'OWNDATA': 'O',
+    'E': 'E', 'ENSUREARRAY': 'E'
+}
+
 
 def _require_dispatcher(a, dtype=None, requirements=None, *, like=None):
     return (like,)
@@ -36,7 +45,7 @@ def require(a, dtype=None, requirements=None, *, like=None):
        The required data-type. If None preserve the current dtype. If your
        application requires the data to be in native byteorder, include
        a byteorder specification as a part of the dtype specification.
-    requirements : str or list of str
+    requirements : str or sequence of str
        The requirements list can be any of the following
 
        * 'F_CONTIGUOUS' ('F') - ensure a Fortran-contiguous array
@@ -78,7 +87,6 @@ def require(a, dtype=None, requirements=None, *, like=None):
       WRITEABLE : True
       ALIGNED : True
       WRITEBACKIFCOPY : False
-      UPDATEIFCOPY : False
 
     >>> y = np.require(x, dtype=np.float32, requirements=['A', 'O', 'W', 'F'])
     >>> y.flags
@@ -88,7 +96,6 @@ def require(a, dtype=None, requirements=None, *, like=None):
       WRITEABLE : True
       ALIGNED : True
       WRITEBACKIFCOPY : False
-      UPDATEIFCOPY : False
 
     """
     if like is not None:
@@ -99,16 +106,10 @@ def require(a, dtype=None, requirements=None, *, like=None):
             like=like,
         )
 
-    possible_flags = {'C': 'C', 'C_CONTIGUOUS': 'C', 'CONTIGUOUS': 'C',
-                      'F': 'F', 'F_CONTIGUOUS': 'F', 'FORTRAN': 'F',
-                      'A': 'A', 'ALIGNED': 'A',
-                      'W': 'W', 'WRITEABLE': 'W',
-                      'O': 'O', 'OWNDATA': 'O',
-                      'E': 'E', 'ENSUREARRAY': 'E'}
     if not requirements:
         return asanyarray(a, dtype=dtype)
-    else:
-        requirements = {possible_flags[x.upper()] for x in requirements}
+
+    requirements = {POSSIBLE_FLAGS[x.upper()] for x in requirements}
 
     if 'E' in requirements:
         requirements.remove('E')
@@ -130,11 +131,10 @@ def require(a, dtype=None, requirements=None, *, like=None):
 
     for prop in requirements:
         if not arr.flags[prop]:
-            arr = arr.copy(order)
-            break
+            return arr.copy(order)
     return arr
 
 
 _require_with_like = array_function_dispatch(
-    _require_dispatcher
+    _require_dispatcher, use_like=True
 )(require)
diff --git a/numpy/core/_asarray.pyi b/numpy/core/_asarray.pyi
index fee9b7b6e0e0..473bc037cefc 100644
--- a/numpy/core/_asarray.pyi
+++ b/numpy/core/_asarray.pyi
@@ -1,7 +1,8 @@
-from typing import TypeVar, Union, Iterable, overload, Literal
+from collections.abc import Iterable
+from typing import TypeVar, Union, overload, Literal
 
 from numpy import ndarray
-from numpy.typing import ArrayLike, DTypeLike
+from numpy._typing import DTypeLike, _SupportsArrayFunc
 
 _ArrayType = TypeVar("_ArrayType", bound=ndarray)
 
@@ -19,23 +20,23 @@ _RequirementsWithE = Union[_Requirements, _E]
 def require(
     a: _ArrayType,
     dtype: None = ...,
-    requirements: Union[None, _Requirements, Iterable[_Requirements]] = ...,
+    requirements: None | _Requirements | Iterable[_Requirements] = ...,
     *,
-    like: ArrayLike = ...
+    like: _SupportsArrayFunc = ...
 ) -> _ArrayType: ...
 @overload
 def require(
     a: object,
     dtype: DTypeLike = ...,
-    requirements: Union[_E, Iterable[_RequirementsWithE]] = ...,
+    requirements: _E | Iterable[_RequirementsWithE] = ...,
     *,
-    like: ArrayLike = ...
+    like: _SupportsArrayFunc = ...
 ) -> ndarray: ...
 @overload
 def require(
     a: object,
     dtype: DTypeLike = ...,
-    requirements: Union[None, _Requirements, Iterable[_Requirements]] = ...,
+    requirements: None | _Requirements | Iterable[_Requirements] = ...,
     *,
-    like: ArrayLike = ...
+    like: _SupportsArrayFunc = ...
 ) -> ndarray: ...
diff --git a/numpy/core/_dtype.py b/numpy/core/_dtype.py
index c3a22b1c6bb0..3db80c17eebe 100644
--- a/numpy/core/_dtype.py
+++ b/numpy/core/_dtype.py
@@ -237,6 +237,11 @@ def _struct_dict_str(dtype, includealignedflag):
     return ret
 
 
+def _aligned_offset(offset, alignment):
+    # round up offset:
+    return - (-offset // alignment) * alignment
+
+
 def _is_packed(dtype):
     """
     Checks whether the structured data type in 'dtype'
@@ -249,12 +254,23 @@ def _is_packed(dtype):
 
     Duplicates the C `is_dtype_struct_simple_unaligned_layout` function.
     """
+    align = dtype.isalignedstruct
+    max_alignment = 1
     total_offset = 0
     for name in dtype.names:
         fld_dtype, fld_offset, title = _unpack_field(*dtype.fields[name])
+
+        if align:
+            total_offset = _aligned_offset(total_offset, fld_dtype.alignment)
+            max_alignment = max(max_alignment, fld_dtype.alignment)
+
         if fld_offset != total_offset:
             return False
         total_offset += fld_dtype.itemsize
+
+    if align:
+        total_offset = _aligned_offset(total_offset, max_alignment)
+
     if total_offset != dtype.itemsize:
         return False
     return True
diff --git a/numpy/core/_exceptions.py b/numpy/core/_exceptions.py
index 3cd8042ce180..be3aa8beeae6 100644
--- a/numpy/core/_exceptions.py
+++ b/numpy/core/_exceptions.py
@@ -117,6 +117,15 @@ def __str__(self):
 # Exception used in shares_memory()
 @set_module('numpy')
 class TooHardError(RuntimeError):
+    """max_work was exceeded.
+
+    This is raised whenever the maximum number of candidate solutions 
+    to consider specified by the ``max_work`` parameter is exceeded.
+    Assigning a finite number to max_work may have caused the operation 
+    to fail.
+
+    """
+    
     pass
 
 
diff --git a/numpy/core/_internal.py b/numpy/core/_internal.py
index 8942955f60c6..85076f3e1e71 100644
--- a/numpy/core/_internal.py
+++ b/numpy/core/_internal.py
@@ -7,16 +7,15 @@
 import ast
 import re
 import sys
-import platform
 import warnings
 
-from .multiarray import dtype, array, ndarray
+from .multiarray import dtype, array, ndarray, promote_types
 try:
     import ctypes
 except ImportError:
     ctypes = None
 
-IS_PYPY = platform.python_implementation() == 'PyPy'
+IS_PYPY = sys.implementation.name == 'pypy'
 
 if sys.byteorder == 'little':
     _nbo = '<'
@@ -433,6 +432,61 @@ def _copy_fields(ary):
                   'formats': [dt.fields[name][0] for name in dt.names]}
     return array(ary, dtype=copy_dtype, copy=True)
 
+def _promote_fields(dt1, dt2):
+    """ Perform type promotion for two structured dtypes.
+
+    Parameters
+    ----------
+    dt1 : structured dtype
+        First dtype.
+    dt2 : structured dtype
+        Second dtype.
+
+    Returns
+    -------
+    out : dtype
+        The promoted dtype
+
+    Notes
+    -----
+    If one of the inputs is aligned, the result will be.  The titles of
+    both descriptors must match (point to the same field).
+    """
+    # Both must be structured and have the same names in the same order
+    if (dt1.names is None or dt2.names is None) or dt1.names != dt2.names:
+        raise TypeError("invalid type promotion")
+
+    # if both are identical, we can (maybe!) just return the same dtype.
+    identical = dt1 is dt2
+    new_fields = []
+    for name in dt1.names:
+        field1 = dt1.fields[name]
+        field2 = dt2.fields[name]
+        new_descr = promote_types(field1[0], field2[0])
+        identical = identical and new_descr is field1[0]
+
+        # Check that the titles match (if given):
+        if field1[2:] != field2[2:]:
+            raise TypeError("invalid type promotion")
+        if len(field1) == 2:
+            new_fields.append((name, new_descr))
+        else:
+            new_fields.append(((field1[2], name), new_descr))
+
+    res = dtype(new_fields, align=dt1.isalignedstruct or dt2.isalignedstruct)
+
+    # Might as well preserve identity (and metadata) if the dtype is identical
+    # and the itemsize, offsets are also unmodified.  This could probably be
+    # sped up, but also probably just be removed entirely.
+    if identical and res.itemsize == dt1.itemsize:
+        for name in dt1.names:
+            if dt1.fields[name][1] != res.fields[name][1]:
+                return res  # the dtype changed.
+        return dt1
+
+    return res
+
+
 def _getfield_is_safe(oldtype, newtype, offset):
     """ Checks safety of getfield for object arrays.
 
diff --git a/numpy/core/_internal.pyi b/numpy/core/_internal.pyi
index f4bfd770f0f2..8a25ef2cba41 100644
--- a/numpy/core/_internal.pyi
+++ b/numpy/core/_internal.pyi
@@ -1,4 +1,4 @@
-from typing import Any, TypeVar, Type, overload, Optional, Generic
+from typing import Any, TypeVar, overload, Generic
 import ctypes as ct
 
 from numpy import ndarray
@@ -6,7 +6,7 @@ from numpy.ctypeslib import c_intp
 
 _CastT = TypeVar("_CastT", bound=ct._CanCastTo)  # Copied from `ctypes.cast`
 _CT = TypeVar("_CT", bound=ct._CData)
-_PT = TypeVar("_PT", bound=Optional[int])
+_PT = TypeVar("_PT", bound=None | int)
 
 # TODO: Let the likes of `shape_as` and `strides_as` return `None`
 # for 0D arrays once we've got shape-support
@@ -25,6 +25,6 @@ class _ctypes(Generic[_PT]):
     @property
     def _as_parameter_(self) -> ct.c_void_p: ...
 
-    def data_as(self, obj: Type[_CastT]) -> _CastT: ...
-    def shape_as(self, obj: Type[_CT]) -> ct.Array[_CT]: ...
-    def strides_as(self, obj: Type[_CT]) -> ct.Array[_CT]: ...
+    def data_as(self, obj: type[_CastT]) -> _CastT: ...
+    def shape_as(self, obj: type[_CT]) -> ct.Array[_CT]: ...
+    def strides_as(self, obj: type[_CT]) -> ct.Array[_CT]: ...
diff --git a/numpy/core/_machar.py b/numpy/core/_machar.py
index ace19a429f79..3cc7db2784de 100644
--- a/numpy/core/_machar.py
+++ b/numpy/core/_machar.py
@@ -326,7 +326,9 @@ def _do_init(self, float_conv, int_conv, float_to_float, float_to_str, title):
         self.tiny = self.xmin
         self.huge = self.xmax
         self.smallest_normal = self.xmin
+        self._str_smallest_normal = float_to_str(self.xmin)
         self.smallest_subnormal = float_to_float(smallest_subnormal)
+        self._str_smallest_subnormal = float_to_str(smallest_subnormal)
 
         import math
         self.precision = int(-math.log10(float_to_float(self.eps)))
diff --git a/numpy/core/_methods.py b/numpy/core/_methods.py
index a239e2c87eb7..040f02a9d84f 100644
--- a/numpy/core/_methods.py
+++ b/numpy/core/_methods.py
@@ -11,6 +11,7 @@
 from numpy.core.multiarray import asanyarray
 from numpy.core import numerictypes as nt
 from numpy.core import _exceptions
+from numpy.core._ufunc_config import _no_nep50_warning
 from numpy._globals import _NoValue
 from numpy.compat import pickle, os_fspath
 
@@ -71,9 +72,10 @@ def _count_reduce_items(arr, axis, keepdims=False, where=True):
             axis = tuple(range(arr.ndim))
         elif not isinstance(axis, tuple):
             axis = (axis,)
-        items = nt.intp(1)
+        items = 1
         for ax in axis:
             items *= arr.shape[mu.normalize_axis_index(ax, arr.ndim)]
+        items = nt.intp(items)
     else:
         # TODO: Optimize case when `where` is broadcast along a non-reduction
         # axis and full sum is more excessive than needed.
@@ -178,8 +180,9 @@ def _mean(a, axis=None, dtype=None, out=None, keepdims=False, *, where=True):
 
     ret = umr_sum(arr, axis, dtype, out, keepdims, where=where)
     if isinstance(ret, mu.ndarray):
-        ret = um.true_divide(
-                ret, rcount, out=ret, casting='unsafe', subok=False)
+        with _no_nep50_warning():
+            ret = um.true_divide(
+                    ret, rcount, out=ret, casting='unsafe', subok=False)
         if is_float16_result and out is None:
             ret = arr.dtype.type(ret)
     elif hasattr(ret, 'dtype'):
@@ -219,8 +222,9 @@ def _var(a, axis=None, dtype=None, out=None, ddof=0, keepdims=False, *,
         # matching rcount to arrmean when where is specified as array
         div = rcount.reshape(arrmean.shape)
     if isinstance(arrmean, mu.ndarray):
-        arrmean = um.true_divide(arrmean, div, out=arrmean, casting='unsafe',
-                                 subok=False)
+        with _no_nep50_warning():
+            arrmean = um.true_divide(arrmean, div, out=arrmean,
+                                     casting='unsafe', subok=False)
     elif hasattr(arrmean, "dtype"):
         arrmean = arrmean.dtype.type(arrmean / rcount)
     else:
@@ -250,8 +254,9 @@ def _var(a, axis=None, dtype=None, out=None, ddof=0, keepdims=False, *,
 
     # divide by degrees of freedom
     if isinstance(ret, mu.ndarray):
-        ret = um.true_divide(
-                ret, rcount, out=ret, casting='unsafe', subok=False)
+        with _no_nep50_warning():
+            ret = um.true_divide(
+                    ret, rcount, out=ret, casting='unsafe', subok=False)
     elif hasattr(ret, 'dtype'):
         ret = ret.dtype.type(ret / rcount)
     else:
diff --git a/numpy/core/_type_aliases.py b/numpy/core/_type_aliases.py
index 3765a0d34e18..38f1a099e9e2 100644
--- a/numpy/core/_type_aliases.py
+++ b/numpy/core/_type_aliases.py
@@ -107,14 +107,16 @@ def _add_aliases():
         if name in ('longdouble', 'clongdouble') and myname in allTypes:
             continue
 
-        allTypes[myname] = info.type
-
-        # add mapping for both the bit name and the numarray name
-        sctypeDict[myname] = info.type
+        # Add to the main namespace if desired:
+        if bit != 0 and base != "bool":
+            allTypes[myname] = info.type
 
         # add forward, reverse, and string mapping to numarray
         sctypeDict[char] = info.type
 
+        # add mapping for both the bit name
+        sctypeDict[myname] = info.type
+
 
 _add_aliases()
 
@@ -148,8 +150,6 @@ def _add_integer_aliases():
 #
 def _set_up_aliases():
     type_pairs = [('complex_', 'cdouble'),
-                  ('int0', 'intp'),
-                  ('uint0', 'uintp'),
                   ('single', 'float'),
                   ('csingle', 'cfloat'),
                   ('singlecomplex', 'cfloat'),
@@ -172,7 +172,7 @@ def _set_up_aliases():
         allTypes[alias] = allTypes[t]
         sctypeDict[alias] = sctypeDict[t]
     # Remove aliases overriding python types and modules
-    to_remove = ['ulong', 'object', 'int', 'float',
+    to_remove = ['object', 'int', 'float',
                  'complex', 'bool', 'string', 'datetime', 'timedelta',
                  'bytes', 'str']
 
@@ -182,6 +182,15 @@ def _set_up_aliases():
             del sctypeDict[t]
         except KeyError:
             pass
+
+    # Additional aliases in sctypeDict that should not be exposed as attributes
+    attrs_to_remove = ['ulong']
+
+    for t in attrs_to_remove:
+        try:
+            del allTypes[t]
+        except KeyError:
+            pass
 _set_up_aliases()
 
 
@@ -224,7 +233,8 @@ def _set_array_types():
 
 # Add additional strings to the sctypeDict
 _toadd = ['int', 'float', 'complex', 'bool', 'object',
-          'str', 'bytes', ('a', 'bytes_')]
+          'str', 'bytes', ('a', 'bytes_'),
+          ('int0', 'intp'), ('uint0', 'uintp')]
 
 for name in _toadd:
     if isinstance(name, tuple):
diff --git a/numpy/core/_type_aliases.pyi b/numpy/core/_type_aliases.pyi
index c10d072f9f0b..bbead0cb5b93 100644
--- a/numpy/core/_type_aliases.pyi
+++ b/numpy/core/_type_aliases.pyi
@@ -1,13 +1,13 @@
-from typing import Dict, Union, Type, List, TypedDict
+from typing import TypedDict
 
 from numpy import generic, signedinteger, unsignedinteger, floating, complexfloating
 
 class _SCTypes(TypedDict):
-    int: List[Type[signedinteger]]
-    uint: List[Type[unsignedinteger]]
-    float: List[Type[floating]]
-    complex: List[Type[complexfloating]]
-    others: List[type]
+    int: list[type[signedinteger]]
+    uint: list[type[unsignedinteger]]
+    float: list[type[floating]]
+    complex: list[type[complexfloating]]
+    others: list[type]
 
-sctypeDict: Dict[Union[int, str], Type[generic]]
+sctypeDict: dict[int | str, type[generic]]
 sctypes: _SCTypes
diff --git a/numpy/core/_ufunc_config.py b/numpy/core/_ufunc_config.py
index b40e7445ec5b..5aac7ab091ec 100644
--- a/numpy/core/_ufunc_config.py
+++ b/numpy/core/_ufunc_config.py
@@ -5,6 +5,7 @@
 """
 import collections.abc
 import contextlib
+import contextvars
 
 from .overrides import set_module
 from .umath import (
@@ -16,7 +17,7 @@
 
 __all__ = [
     "seterr", "geterr", "setbufsize", "getbufsize", "seterrcall", "geterrcall",
-    "errstate",
+    "errstate", '_no_nep50_warning'
 ]
 
 _errdict = {"ignore": ERR_IGNORE,
@@ -96,7 +97,7 @@ def seterr(all=None, divide=None, over=None, under=None, invalid=None):
     >>> np.int16(32000) * np.int16(3)
     Traceback (most recent call last):
       File "", line 1, in 
-    FloatingPointError: overflow encountered in short_scalars
+    FloatingPointError: overflow encountered in scalar multiply
 
     >>> old_settings = np.seterr(all='print')
     >>> np.geterr()
@@ -290,7 +291,7 @@ def seterrcall(func):
     >>> save_err = np.seterr(all='log')
 
     >>> np.array([1, 2, 3]) / 0.0
-    LOG: Warning: divide by zero encountered in true_divide
+    LOG: Warning: divide by zero encountered in divide
     array([inf, inf, inf])
 
     >>> np.seterrcall(saved_handler)
@@ -444,3 +445,22 @@ def _setdef():
 
 # set the default values
 _setdef()
+
+
+NO_NEP50_WARNING = contextvars.ContextVar("_no_nep50_warning", default=False)
+
+@set_module('numpy')
+@contextlib.contextmanager
+def _no_nep50_warning():
+    """
+    Context manager to disable NEP 50 warnings.  This context manager is
+    only relevant if the NEP 50 warnings are enabled globally (which is not
+    thread/context safe).
+
+    This warning context manager itself is fully safe, however.
+    """
+    token = NO_NEP50_WARNING.set(True)
+    try:
+        yield
+    finally:
+        NO_NEP50_WARNING.reset(token)
diff --git a/numpy/core/_ufunc_config.pyi b/numpy/core/_ufunc_config.pyi
index cd7129bcb140..f56504507ac0 100644
--- a/numpy/core/_ufunc_config.pyi
+++ b/numpy/core/_ufunc_config.pyi
@@ -1,4 +1,5 @@
-from typing import Optional, Union, Callable, Any, Literal, TypedDict
+from collections.abc import Callable
+from typing import Any, Literal, TypedDict
 
 from numpy import _SupportsWrite
 
@@ -12,25 +13,25 @@ class _ErrDict(TypedDict):
     invalid: _ErrKind
 
 class _ErrDictOptional(TypedDict, total=False):
-    all: Optional[_ErrKind]
-    divide: Optional[_ErrKind]
-    over: Optional[_ErrKind]
-    under: Optional[_ErrKind]
-    invalid: Optional[_ErrKind]
+    all: None | _ErrKind
+    divide: None | _ErrKind
+    over: None | _ErrKind
+    under: None | _ErrKind
+    invalid: None | _ErrKind
 
 def seterr(
-    all: Optional[_ErrKind] = ...,
-    divide: Optional[_ErrKind] = ...,
-    over: Optional[_ErrKind] = ...,
-    under: Optional[_ErrKind] = ...,
-    invalid: Optional[_ErrKind] = ...,
+    all: None | _ErrKind = ...,
+    divide: None | _ErrKind = ...,
+    over: None | _ErrKind = ...,
+    under: None | _ErrKind = ...,
+    invalid: None | _ErrKind = ...,
 ) -> _ErrDict: ...
 def geterr() -> _ErrDict: ...
 def setbufsize(size: int) -> int: ...
 def getbufsize() -> int: ...
 def seterrcall(
-    func: Union[None, _ErrFunc, _SupportsWrite[str]]
-) -> Union[None, _ErrFunc, _SupportsWrite[str]]: ...
-def geterrcall() -> Union[None, _ErrFunc, _SupportsWrite[str]]: ...
+    func: None | _ErrFunc | _SupportsWrite[str]
+) -> None | _ErrFunc | _SupportsWrite[str]: ...
+def geterrcall() -> None | _ErrFunc | _SupportsWrite[str]: ...
 
-# See `numpy/__init__.pyi` for the `errstate` class
+# See `numpy/__init__.pyi` for the `errstate` class and `no_nep5_warnings`
diff --git a/numpy/core/arrayprint.py b/numpy/core/arrayprint.py
index d7e9bf79534c..957cecf1cae4 100644
--- a/numpy/core/arrayprint.py
+++ b/numpy/core/arrayprint.py
@@ -1394,10 +1394,6 @@ def _void_scalar_repr(x):
 
 
 _typelessdata = [int_, float_, complex_, bool_]
-if issubclass(intc, int):
-    _typelessdata.append(intc)
-if issubclass(longlong, int):
-    _typelessdata.append(longlong)
 
 
 def dtype_is_implied(dtype):
diff --git a/numpy/core/arrayprint.pyi b/numpy/core/arrayprint.pyi
index 0d338206f604..d8255387a3a5 100644
--- a/numpy/core/arrayprint.pyi
+++ b/numpy/core/arrayprint.pyi
@@ -1,5 +1,6 @@
 from types import TracebackType
-from typing import Any, Optional, Callable, Union, Type, Literal, TypedDict, SupportsIndex
+from collections.abc import Callable
+from typing import Any, Literal, TypedDict, SupportsIndex
 
 # Using a private class is by no means ideal, but it is simply a consequence
 # of a `contextlib.context` returning an instance of aforementioned class
@@ -20,7 +21,7 @@ from numpy import (
     longdouble,
     clongdouble,
 )
-from numpy.typing import ArrayLike, _CharLike_co, _FloatLike_co
+from numpy._typing import ArrayLike, _CharLike_co, _FloatLike_co
 
 _FloatMode = Literal["fixed", "unique", "maxprec", "maxprec_equal"]
 
@@ -50,92 +51,92 @@ class _FormatOptions(TypedDict):
     suppress: bool
     nanstr: str
     infstr: str
-    formatter: Optional[_FormatDict]
+    formatter: None | _FormatDict
     sign: Literal["-", "+", " "]
     floatmode: _FloatMode
     legacy: Literal[False, "1.13", "1.21"]
 
 def set_printoptions(
-    precision: Optional[SupportsIndex] = ...,
-    threshold: Optional[int] = ...,
-    edgeitems: Optional[int] = ...,
-    linewidth: Optional[int] = ...,
-    suppress: Optional[bool] = ...,
-    nanstr: Optional[str] = ...,
-    infstr: Optional[str] = ...,
-    formatter: Optional[_FormatDict] = ...,
-    sign: Optional[Literal["-", "+", " "]] = ...,
-    floatmode: Optional[_FloatMode] = ...,
+    precision: None | SupportsIndex = ...,
+    threshold: None | int = ...,
+    edgeitems: None | int = ...,
+    linewidth: None | int = ...,
+    suppress: None | bool = ...,
+    nanstr: None | str = ...,
+    infstr: None | str = ...,
+    formatter: None | _FormatDict = ...,
+    sign: Literal[None, "-", "+", " "] = ...,
+    floatmode: None | _FloatMode = ...,
     *,
-    legacy: Optional[Literal[False, "1.13", "1.21"]] = ...
+    legacy: Literal[None, False, "1.13", "1.21"] = ...
 ) -> None: ...
 def get_printoptions() -> _FormatOptions: ...
 def array2string(
     a: ndarray[Any, Any],
-    max_line_width: Optional[int] = ...,
-    precision: Optional[SupportsIndex] = ...,
-    suppress_small: Optional[bool] = ...,
+    max_line_width: None | int = ...,
+    precision: None | SupportsIndex = ...,
+    suppress_small: None | bool = ...,
     separator: str = ...,
     prefix: str = ...,
     # NOTE: With the `style` argument being deprecated,
     # all arguments between `formatter` and `suffix` are de facto
     # keyworld-only arguments
     *,
-    formatter: Optional[_FormatDict] = ...,
-    threshold: Optional[int] = ...,
-    edgeitems: Optional[int] = ...,
-    sign: Optional[Literal["-", "+", " "]] = ...,
-    floatmode: Optional[_FloatMode] = ...,
+    formatter: None | _FormatDict = ...,
+    threshold: None | int = ...,
+    edgeitems: None | int = ...,
+    sign: Literal[None, "-", "+", " "] = ...,
+    floatmode: None | _FloatMode = ...,
     suffix: str = ...,
-    legacy: Optional[Literal[False, "1.13", "1.21"]] = ...,
+    legacy: Literal[None, False, "1.13", "1.21"] = ...,
 ) -> str: ...
 def format_float_scientific(
     x: _FloatLike_co,
-    precision: Optional[int] = ...,
+    precision: None | int = ...,
     unique: bool = ...,
     trim: Literal["k", ".", "0", "-"] = ...,
     sign: bool = ...,
-    pad_left: Optional[int] = ...,
-    exp_digits: Optional[int] = ...,
-    min_digits: Optional[int] = ...,
+    pad_left: None | int = ...,
+    exp_digits: None | int = ...,
+    min_digits: None | int = ...,
 ) -> str: ...
 def format_float_positional(
     x: _FloatLike_co,
-    precision: Optional[int] = ...,
+    precision: None | int = ...,
     unique: bool = ...,
     fractional: bool = ...,
     trim: Literal["k", ".", "0", "-"] = ...,
     sign: bool = ...,
-    pad_left: Optional[int] = ...,
-    pad_right: Optional[int] = ...,
-    min_digits: Optional[int] = ...,
+    pad_left: None | int = ...,
+    pad_right: None | int = ...,
+    min_digits: None | int = ...,
 ) -> str: ...
 def array_repr(
     arr: ndarray[Any, Any],
-    max_line_width: Optional[int] = ...,
-    precision: Optional[SupportsIndex] = ...,
-    suppress_small: Optional[bool] = ...,
+    max_line_width: None | int = ...,
+    precision: None | SupportsIndex = ...,
+    suppress_small: None | bool = ...,
 ) -> str: ...
 def array_str(
     a: ndarray[Any, Any],
-    max_line_width: Optional[int] = ...,
-    precision: Optional[SupportsIndex] = ...,
-    suppress_small: Optional[bool] = ...,
+    max_line_width: None | int = ...,
+    precision: None | SupportsIndex = ...,
+    suppress_small: None | bool = ...,
 ) -> str: ...
 def set_string_function(
-    f: Optional[Callable[[ndarray[Any, Any]], str]], repr: bool = ...
+    f: None | Callable[[ndarray[Any, Any]], str], repr: bool = ...
 ) -> None: ...
 def printoptions(
-    precision: Optional[SupportsIndex] = ...,
-    threshold: Optional[int] = ...,
-    edgeitems: Optional[int] = ...,
-    linewidth: Optional[int] = ...,
-    suppress: Optional[bool] = ...,
-    nanstr: Optional[str] = ...,
-    infstr: Optional[str] = ...,
-    formatter: Optional[_FormatDict] = ...,
-    sign: Optional[Literal["-", "+", " "]] = ...,
-    floatmode: Optional[_FloatMode] = ...,
+    precision: None | SupportsIndex = ...,
+    threshold: None | int = ...,
+    edgeitems: None | int = ...,
+    linewidth: None | int = ...,
+    suppress: None | bool = ...,
+    nanstr: None | str = ...,
+    infstr: None | str = ...,
+    formatter: None | _FormatDict = ...,
+    sign: Literal[None, "-", "+", " "] = ...,
+    floatmode: None | _FloatMode = ...,
     *,
-    legacy: Optional[Literal[False, "1.13", "1.21"]] = ...
+    legacy: Literal[None, False, "1.13", "1.21"] = ...
 ) -> _GeneratorContextManager[_FormatOptions]: ...
diff --git a/numpy/core/code_generators/cversions.txt b/numpy/core/code_generators/cversions.txt
index e7b3ef697edc..dddcc148c001 100644
--- a/numpy/core/code_generators/cversions.txt
+++ b/numpy/core/code_generators/cversions.txt
@@ -60,5 +60,11 @@
 # Version 14 (NumPy 1.21) No change.
 0x0000000e = 17a0f366e55ec05e5c5c149123478452
 
-# Version 15 (NumPy 1.22) Configurable memory allocations
+# Version 15 (NumPy 1.22)
+# Configurable memory allocations
 0x0000000f = b8783365b873681cd204be50cdfb448d
+
+# Version 16 (NumPy 1.23)
+# NonNull attributes removed from numpy_api.py
+# Version 16 (NumPy 1.24) No change.
+0x00000010 = 04a7bf1e65350926a0e528798da263c0
diff --git a/numpy/core/code_generators/genapi.py b/numpy/core/code_generators/genapi.py
index b401ee6a581e..68ae30d5bef8 100644
--- a/numpy/core/code_generators/genapi.py
+++ b/numpy/core/code_generators/genapi.py
@@ -92,17 +92,6 @@ def __str__(self):
             return 'NPY_STEALS_REF_TO_ARG(%d)' % self.arg
 
 
-class NonNull:
-    def __init__(self, arg):
-        self.arg = arg # counting from 1
-
-    def __str__(self):
-        try:
-            return ' '.join('NPY_GCC_NONNULL(%d)' % x for x in self.arg)
-        except TypeError:
-            return 'NPY_GCC_NONNULL(%d)' % self.arg
-
-
 class Function:
     def __init__(self, name, return_type, args, doc=''):
         self.name = name
diff --git a/numpy/core/code_generators/generate_numpy_api.py b/numpy/core/code_generators/generate_numpy_api.py
index 37975966f625..a57a36a7821e 100644
--- a/numpy/core/code_generators/generate_numpy_api.py
+++ b/numpy/core/code_generators/generate_numpy_api.py
@@ -78,7 +78,12 @@
   }
   if (NPY_FEATURE_VERSION > PyArray_GetNDArrayCFeatureVersion()) {
       PyErr_Format(PyExc_RuntimeError, "module compiled against "\
-             "API version 0x%%x but this version of numpy is 0x%%x", \
+             "API version 0x%%x but this version of numpy is 0x%%x . "\
+             "Check the section C-API incompatibility at the "\
+             "Troubleshooting ImportError section at "\
+             "https://numpy.org/devdocs/user/troubleshooting-importerror.html"\
+             "#c-api-incompatibility "\
+              "for indications on how to solve this problem .", \
              (int) NPY_FEATURE_VERSION, (int) PyArray_GetNDArrayCFeatureVersion());
       return -1;
   }
@@ -89,19 +94,22 @@
    */
   st = PyArray_GetEndianness();
   if (st == NPY_CPU_UNKNOWN_ENDIAN) {
-      PyErr_Format(PyExc_RuntimeError, "FATAL: module compiled as unknown endian");
+      PyErr_SetString(PyExc_RuntimeError,
+                      "FATAL: module compiled as unknown endian");
       return -1;
   }
 #if NPY_BYTE_ORDER == NPY_BIG_ENDIAN
   if (st != NPY_CPU_BIG) {
-      PyErr_Format(PyExc_RuntimeError, "FATAL: module compiled as "\
-             "big endian, but detected different endianness at runtime");
+      PyErr_SetString(PyExc_RuntimeError,
+                      "FATAL: module compiled as big endian, but "
+                      "detected different endianness at runtime");
       return -1;
   }
 #elif NPY_BYTE_ORDER == NPY_LITTLE_ENDIAN
   if (st != NPY_CPU_LITTLE) {
-      PyErr_Format(PyExc_RuntimeError, "FATAL: module compiled as "\
-             "little endian, but detected different endianness at runtime");
+      PyErr_SetString(PyExc_RuntimeError,
+                      "FATAL: module compiled as little endian, but "
+                      "detected different endianness at runtime");
       return -1;
   }
 #endif
diff --git a/numpy/core/code_generators/generate_umath.py b/numpy/core/code_generators/generate_umath.py
index 292d9e0d37e2..378ab3b7b966 100644
--- a/numpy/core/code_generators/generate_umath.py
+++ b/numpy/core/code_generators/generate_umath.py
@@ -4,10 +4,6 @@
 import sys
 import textwrap
 
-sys.path.insert(0, os.path.dirname(__file__))
-import ufunc_docstrings as docstrings
-sys.path.pop(0)
-
 Zero = "PyLong_FromLong(0)"
 One = "PyLong_FromLong(1)"
 True_ = "(Py_INCREF(Py_True), Py_True)"
@@ -17,6 +13,16 @@
 MinusInfinity = 'PyFloat_FromDouble(-NPY_INFINITY)'
 ReorderableNone = "(Py_INCREF(Py_None), Py_None)"
 
+class docstrings:
+    @staticmethod
+    def get(place):
+        """
+        Returns the C #definition name of docstring according
+        to ufunc place. C #definitions are generated by generate_umath_doc.py
+        in a separate C header.
+        """
+        return 'DOC_' + place.upper().replace('.', '_')
+
 # Sentinel value to specify using the full type description in the
 # function name
 class FullTypeDescr:
@@ -48,10 +54,10 @@ class TypeDescription:
     cfunc_alias : str or none, optional
         Appended to inner loop C function name, e.g., FLOAT_{cfunc_alias}. See make_arrays.
         NOTE: it doesn't support 'astype'
-    simd: list
+    simd : list
         Available SIMD ufunc loops, dispatched at runtime in specified order
         Currently only supported for simples types (see make_arrays)
-    dispatch: str or None, optional
+    dispatch : str or None, optional
         Dispatch-able source name without its extension '.dispatch.c' that
         contains the definition of ufunc, dispatched at runtime depending on the
         specified targets of the dispatch-able source.
@@ -83,6 +89,41 @@ def finish_signature(self, nin, nout):
         assert len(self.out) == nout
         self.astype = self.astype_dict.get(self.type, None)
 
+
+def _check_order(types1, types2):
+    dtype_order = allP + "O"
+    for t1, t2 in zip(types1, types2):
+        # We have no opinion on object or time ordering for now:
+        if t1 in "OP" or t2 in "OP":
+            return True
+        if t1 in "mM" or t2 in "mM":
+            return True
+
+        t1i = dtype_order.index(t1)
+        t2i = dtype_order.index(t2)
+        if t1i < t2i:
+            return
+        if t2i > t1i:
+            break
+
+    raise TypeError(
+            f"Input dtypes are unsorted or duplicate: {types1} and {types2}")
+
+
+def check_td_order(tds):
+    # A quick check for whether the signatures make sense, it happened too
+    # often that SIMD additions added loops that do not even make some sense.
+    # TODO: This should likely be a test and it would be nice if it rejected
+    #       duplicate entries as well (but we have many as of writing this).
+    signatures = [t.in_+t.out for t in tds]
+
+    for prev_i, sign in enumerate(signatures[1:]):
+        if sign in signatures[:prev_i+1]:
+            continue  # allow duplicates...
+        
+        _check_order(signatures[prev_i], sign)
+
+
 _fdata_map = dict(
     e='npy_%sf',
     f='npy_%sf',
@@ -166,6 +207,9 @@ def __init__(self, nin, nout, identity, docstring, typereso,
         for td in self.type_descriptions:
             td.finish_signature(self.nin, self.nout)
 
+        check_td_order(self.type_descriptions)
+
+
 # String-handling utilities to avoid locale-dependence.
 
 import string
@@ -322,7 +366,7 @@ def english_upper(s):
           ],
           TD(O, f='PyNumber_Multiply'),
           ),
-#'divide' : aliased to true_divide in umathmodule.c:initumath
+#'true_divide' : aliased to divide in umathmodule.c:initumath
 'floor_divide':
     Ufunc(2, 1, None, # One is only a unit to the right, not the left
           docstrings.get('numpy.core.umath.floor_divide'),
@@ -336,9 +380,9 @@ def english_upper(s):
           ],
           TD(O, f='PyNumber_FloorDivide'),
           ),
-'true_divide':
+'divide':
     Ufunc(2, 1, None, # One is only a unit to the right, not the left
-          docstrings.get('numpy.core.umath.true_divide'),
+          docstrings.get('numpy.core.umath.divide'),
           'PyUFunc_TrueDivisionTypeResolver',
           TD(flts+cmplx, cfunc_alias='divide', dispatch=[('loops_arithm_fp', 'fd')]),
           [TypeDescription('m', FullTypeDescr, 'mq', 'm', cfunc_alias='divide'),
@@ -358,7 +402,7 @@ def english_upper(s):
     Ufunc(2, 1, None,
           docstrings.get('numpy.core.umath.fmod'),
           None,
-          TD(ints),
+          TD(ints, dispatch=[('loops_modulo', ints)]),
           TD(flts, f='fmod', astype={'e': 'f'}),
           TD(P, f='fmod'),
           ),
@@ -390,6 +434,8 @@ def english_upper(s):
           docstrings.get('numpy.core.umath.power'),
           None,
           TD(ints),
+          TD('e', f='pow', astype={'e': 'f'}),
+          TD('fd', dispatch=[('loops_umath_fp', 'fd')]),
           TD(inexact, f='pow', astype={'e': 'f'}),
           TD(O, f='npy_ObjectPower'),
           ),
@@ -439,7 +485,7 @@ def english_upper(s):
     Ufunc(2, 1, None,
           docstrings.get('numpy.core.umath.greater'),
           'PyUFunc_SimpleBinaryComparisonTypeResolver',
-          TD(all, out='?', simd=[('avx2', ints)]),
+          TD(all, out='?', dispatch=[('loops_comparison', bints+'fd')]),
           [TypeDescription('O', FullTypeDescr, 'OO', 'O')],
           TD('O', out='?'),
           ),
@@ -447,7 +493,7 @@ def english_upper(s):
     Ufunc(2, 1, None,
           docstrings.get('numpy.core.umath.greater_equal'),
           'PyUFunc_SimpleBinaryComparisonTypeResolver',
-          TD(all, out='?', simd=[('avx2', ints)]),
+          TD(all, out='?', dispatch=[('loops_comparison', bints+'fd')]),
           [TypeDescription('O', FullTypeDescr, 'OO', 'O')],
           TD('O', out='?'),
           ),
@@ -455,7 +501,7 @@ def english_upper(s):
     Ufunc(2, 1, None,
           docstrings.get('numpy.core.umath.less'),
           'PyUFunc_SimpleBinaryComparisonTypeResolver',
-          TD(all, out='?', simd=[('avx2', ints)]),
+          TD(all, out='?', dispatch=[('loops_comparison', bints+'fd')]),
           [TypeDescription('O', FullTypeDescr, 'OO', 'O')],
           TD('O', out='?'),
           ),
@@ -463,7 +509,7 @@ def english_upper(s):
     Ufunc(2, 1, None,
           docstrings.get('numpy.core.umath.less_equal'),
           'PyUFunc_SimpleBinaryComparisonTypeResolver',
-          TD(all, out='?', simd=[('avx2', ints)]),
+          TD(all, out='?', dispatch=[('loops_comparison', bints+'fd')]),
           [TypeDescription('O', FullTypeDescr, 'OO', 'O')],
           TD('O', out='?'),
           ),
@@ -471,7 +517,7 @@ def english_upper(s):
     Ufunc(2, 1, None,
           docstrings.get('numpy.core.umath.equal'),
           'PyUFunc_SimpleBinaryComparisonTypeResolver',
-          TD(all, out='?', simd=[('avx2', ints)]),
+          TD(all, out='?', dispatch=[('loops_comparison', bints+'fd')]),
           [TypeDescription('O', FullTypeDescr, 'OO', 'O')],
           TD('O', out='?'),
           ),
@@ -479,7 +525,7 @@ def english_upper(s):
     Ufunc(2, 1, None,
           docstrings.get('numpy.core.umath.not_equal'),
           'PyUFunc_SimpleBinaryComparisonTypeResolver',
-          TD(all, out='?', simd=[('avx2', ints)]),
+          TD(all, out='?', dispatch=[('loops_comparison', bints+'fd')]),
           [TypeDescription('O', FullTypeDescr, 'OO', 'O')],
           TD('O', out='?'),
           ),
@@ -516,14 +562,14 @@ def english_upper(s):
     Ufunc(2, 1, ReorderableNone,
           docstrings.get('numpy.core.umath.maximum'),
           'PyUFunc_SimpleUniformOperationTypeResolver',
-          TD(noobj, simd=[('avx512f', 'fd')]),
+          TD(noobj, dispatch=[('loops_minmax', ints+'fdg')]),
           TD(O, f='npy_ObjectMax')
           ),
 'minimum':
     Ufunc(2, 1, ReorderableNone,
           docstrings.get('numpy.core.umath.minimum'),
           'PyUFunc_SimpleUniformOperationTypeResolver',
-          TD(noobj, simd=[('avx512f', 'fd')]),
+          TD(noobj, dispatch=[('loops_minmax', ints+'fdg')]),
           TD(O, f='npy_ObjectMin')
           ),
 'clip':
@@ -537,14 +583,14 @@ def english_upper(s):
     Ufunc(2, 1, ReorderableNone,
           docstrings.get('numpy.core.umath.fmax'),
           'PyUFunc_SimpleUniformOperationTypeResolver',
-          TD(noobj),
+          TD(noobj, dispatch=[('loops_minmax', 'fdg')]),
           TD(O, f='npy_ObjectMax')
           ),
 'fmin':
     Ufunc(2, 1, ReorderableNone,
           docstrings.get('numpy.core.umath.fmin'),
           'PyUFunc_SimpleUniformOperationTypeResolver',
-          TD(noobj),
+          TD(noobj, dispatch=[('loops_minmax', 'fdg')]),
           TD(O, f='npy_ObjectMin')
           ),
 'logaddexp':
@@ -635,8 +681,7 @@ def english_upper(s):
     Ufunc(1, 1, None,
           docstrings.get('numpy.core.umath.arccos'),
           None,
-          TD('e', f='acos', astype={'e': 'f'}),
-          TD('fd', dispatch=[('loops_umath_fp', 'fd')]),
+          TD('efd', dispatch=[('loops_umath_fp', 'efd')]),
           TD(inexact, f='acos', astype={'e': 'f'}),
           TD(P, f='arccos'),
           ),
@@ -644,8 +689,7 @@ def english_upper(s):
     Ufunc(1, 1, None,
           docstrings.get('numpy.core.umath.arccosh'),
           None,
-          TD('e', f='acosh', astype={'e': 'f'}),
-          TD('fd', dispatch=[('loops_umath_fp', 'fd')]),
+          TD('efd', dispatch=[('loops_umath_fp', 'efd')]),
           TD(inexact, f='acosh', astype={'e': 'f'}),
           TD(P, f='arccosh'),
           ),
@@ -653,8 +697,7 @@ def english_upper(s):
     Ufunc(1, 1, None,
           docstrings.get('numpy.core.umath.arcsin'),
           None,
-          TD('e', f='asin', astype={'e': 'f'}),
-          TD('fd', dispatch=[('loops_umath_fp', 'fd')]),
+          TD('efd', dispatch=[('loops_umath_fp', 'efd')]),
           TD(inexact, f='asin', astype={'e': 'f'}),
           TD(P, f='arcsin'),
           ),
@@ -662,8 +705,7 @@ def english_upper(s):
     Ufunc(1, 1, None,
           docstrings.get('numpy.core.umath.arcsinh'),
           None,
-          TD('e', f='asinh', astype={'e': 'f'}),
-          TD('fd', dispatch=[('loops_umath_fp', 'fd')]),
+          TD('efd', dispatch=[('loops_umath_fp', 'efd')]),
           TD(inexact, f='asinh', astype={'e': 'f'}),
           TD(P, f='arcsinh'),
           ),
@@ -671,8 +713,7 @@ def english_upper(s):
     Ufunc(1, 1, None,
           docstrings.get('numpy.core.umath.arctan'),
           None,
-          TD('e', f='atan', astype={'e': 'f'}),
-          TD('fd', dispatch=[('loops_umath_fp', 'fd')]),
+          TD('efd', dispatch=[('loops_umath_fp', 'efd')]),
           TD(inexact, f='atan', astype={'e': 'f'}),
           TD(P, f='arctan'),
           ),
@@ -680,8 +721,7 @@ def english_upper(s):
     Ufunc(1, 1, None,
           docstrings.get('numpy.core.umath.arctanh'),
           None,
-          TD('e', f='atanh', astype={'e': 'f'}),
-          TD('fd', dispatch=[('loops_umath_fp', 'fd')]),
+          TD('efd', dispatch=[('loops_umath_fp', 'efd')]),
           TD(inexact, f='atanh', astype={'e': 'f'}),
           TD(P, f='arctanh'),
           ),
@@ -689,28 +729,27 @@ def english_upper(s):
     Ufunc(1, 1, None,
           docstrings.get('numpy.core.umath.cos'),
           None,
-          TD('e', f='cos', astype={'e': 'f'}),
+          TD('e', dispatch=[('loops_umath_fp', 'e')]),
           TD('f', dispatch=[('loops_trigonometric', 'f')]),
           TD('d', dispatch=[('loops_umath_fp', 'd')]),
-          TD('fdg' + cmplx, f='cos'),
+          TD('g' + cmplx, f='cos'),
           TD(P, f='cos'),
           ),
 'sin':
     Ufunc(1, 1, None,
           docstrings.get('numpy.core.umath.sin'),
           None,
-          TD('e', f='sin', astype={'e': 'f'}),
+          TD('e', dispatch=[('loops_umath_fp', 'e')]),
           TD('f', dispatch=[('loops_trigonometric', 'f')]),
           TD('d', dispatch=[('loops_umath_fp', 'd')]),
-          TD('fdg' + cmplx, f='sin'),
+          TD('g' + cmplx, f='sin'),
           TD(P, f='sin'),
           ),
 'tan':
     Ufunc(1, 1, None,
           docstrings.get('numpy.core.umath.tan'),
           None,
-          TD('e', f='tan', astype={'e': 'f'}),
-          TD('fd', dispatch=[('loops_umath_fp', 'fd')]),
+          TD('efd', dispatch=[('loops_umath_fp', 'efd')]),
           TD(inexact, f='tan', astype={'e': 'f'}),
           TD(P, f='tan'),
           ),
@@ -718,8 +757,7 @@ def english_upper(s):
     Ufunc(1, 1, None,
           docstrings.get('numpy.core.umath.cosh'),
           None,
-          TD('e', f='cosh', astype={'e': 'f'}),
-          TD('fd', dispatch=[('loops_umath_fp', 'fd')]),
+          TD('efd', dispatch=[('loops_umath_fp', 'efd')]),
           TD(inexact, f='cosh', astype={'e': 'f'}),
           TD(P, f='cosh'),
           ),
@@ -727,8 +765,7 @@ def english_upper(s):
     Ufunc(1, 1, None,
           docstrings.get('numpy.core.umath.sinh'),
           None,
-          TD('e', f='sinh', astype={'e': 'f'}),
-          TD('fd', dispatch=[('loops_umath_fp', 'fd')]),
+          TD('efd', dispatch=[('loops_umath_fp', 'efd')]),
           TD(inexact, f='sinh', astype={'e': 'f'}),
           TD(P, f='sinh'),
           ),
@@ -736,8 +773,8 @@ def english_upper(s):
     Ufunc(1, 1, None,
           docstrings.get('numpy.core.umath.tanh'),
           None,
-          TD('e', f='tanh', astype={'e': 'f'}),
-          TD('fd', dispatch=[('loops_umath_fp', 'fd')]),
+          TD('e', dispatch=[('loops_umath_fp', 'e')]),
+          TD('fd', dispatch=[('loops_hyperbolic', 'fd')]),
           TD(inexact, f='tanh', astype={'e': 'f'}),
           TD(P, f='tanh'),
           ),
@@ -745,7 +782,7 @@ def english_upper(s):
     Ufunc(1, 1, None,
           docstrings.get('numpy.core.umath.exp'),
           None,
-          TD('e', f='exp', astype={'e': 'f'}),
+          TD('e', dispatch=[('loops_umath_fp', 'e')]),
           TD('fd', dispatch=[('loops_exponent_log', 'fd')]),
           TD('fdg' + cmplx, f='exp'),
           TD(P, f='exp'),
@@ -754,8 +791,7 @@ def english_upper(s):
     Ufunc(1, 1, None,
           docstrings.get('numpy.core.umath.exp2'),
           None,
-          TD('e', f='exp2', astype={'e': 'f'}),
-          TD('fd', dispatch=[('loops_umath_fp', 'fd')]),
+          TD('efd', dispatch=[('loops_umath_fp', 'efd')]),
           TD(inexact, f='exp2', astype={'e': 'f'}),
           TD(P, f='exp2'),
           ),
@@ -763,8 +799,7 @@ def english_upper(s):
     Ufunc(1, 1, None,
           docstrings.get('numpy.core.umath.expm1'),
           None,
-          TD('e', f='expm1', astype={'e': 'f'}),
-          TD('fd', dispatch=[('loops_umath_fp', 'fd')]),
+          TD('efd', dispatch=[('loops_umath_fp', 'efd')]),
           TD(inexact, f='expm1', astype={'e': 'f'}),
           TD(P, f='expm1'),
           ),
@@ -772,7 +807,7 @@ def english_upper(s):
     Ufunc(1, 1, None,
           docstrings.get('numpy.core.umath.log'),
           None,
-          TD('e', f='log', astype={'e': 'f'}),
+          TD('e', dispatch=[('loops_umath_fp', 'e')]),
           TD('fd', dispatch=[('loops_exponent_log', 'fd')]),
           TD('fdg' + cmplx, f='log'),
           TD(P, f='log'),
@@ -781,8 +816,7 @@ def english_upper(s):
     Ufunc(1, 1, None,
           docstrings.get('numpy.core.umath.log2'),
           None,
-          TD('e', f='log2', astype={'e': 'f'}),
-          TD('fd', dispatch=[('loops_umath_fp', 'fd')]),
+          TD('efd', dispatch=[('loops_umath_fp', 'efd')]),
           TD(inexact, f='log2', astype={'e': 'f'}),
           TD(P, f='log2'),
           ),
@@ -790,8 +824,7 @@ def english_upper(s):
     Ufunc(1, 1, None,
           docstrings.get('numpy.core.umath.log10'),
           None,
-          TD('e', f='log10', astype={'e': 'f'}),
-          TD('fd', dispatch=[('loops_umath_fp', 'fd')]),
+          TD('efd', dispatch=[('loops_umath_fp', 'efd')]),
           TD(inexact, f='log10', astype={'e': 'f'}),
           TD(P, f='log10'),
           ),
@@ -799,8 +832,7 @@ def english_upper(s):
     Ufunc(1, 1, None,
           docstrings.get('numpy.core.umath.log1p'),
           None,
-          TD('e', f='log1p', astype={'e': 'f'}),
-          TD('fd', dispatch=[('loops_umath_fp', 'fd')]),
+          TD('efd', dispatch=[('loops_umath_fp', 'efd')]),
           TD(inexact, f='log1p', astype={'e': 'f'}),
           TD(P, f='log1p'),
           ),
@@ -817,8 +849,7 @@ def english_upper(s):
     Ufunc(1, 1, None,
           docstrings.get('numpy.core.umath.cbrt'),
           None,
-          TD('e', f='cbrt', astype={'e': 'f'}),
-          TD('fd', dispatch=[('loops_umath_fp', 'fd')]),
+          TD('efd', dispatch=[('loops_umath_fp', 'efd')]),
           TD(flts, f='cbrt', astype={'e': 'f'}),
           TD(P, f='cbrt'),
           ),
@@ -836,7 +867,7 @@ def english_upper(s):
           docstrings.get('numpy.core.umath.trunc'),
           None,
           TD('e', f='trunc', astype={'e': 'f'}),
-          TD(inexactvec, simd=[('fma', 'fd'), ('avx512f', 'fd')]),
+          TD(inexactvec, dispatch=[('loops_unary_fp', 'fd')]),
           TD('fdg', f='trunc'),
           TD(O, f='npy_ObjectTrunc'),
           ),
@@ -852,7 +883,7 @@ def english_upper(s):
           docstrings.get('numpy.core.umath.floor'),
           None,
           TD('e', f='floor', astype={'e': 'f'}),
-          TD(inexactvec, simd=[('fma', 'fd'), ('avx512f', 'fd')]),
+          TD(inexactvec, dispatch=[('loops_unary_fp', 'fd')]),
           TD('fdg', f='floor'),
           TD(O, f='npy_ObjectFloor'),
           ),
@@ -861,7 +892,7 @@ def english_upper(s):
           docstrings.get('numpy.core.umath.rint'),
           None,
           TD('e', f='rint', astype={'e': 'f'}),
-          TD(inexactvec, simd=[('fma', 'fd'), ('avx512f', 'fd')]),
+          TD(inexactvec, dispatch=[('loops_unary_fp', 'fd')]),
           TD('fdg' + cmplx, f='rint'),
           TD(P, f='rint'),
           ),
@@ -869,14 +900,17 @@ def english_upper(s):
     Ufunc(2, 1, None,
           docstrings.get('numpy.core.umath.arctan2'),
           None,
-          TD(flts, f='atan2', astype={'e': 'f'}),
+          TD('e', f='atan2', astype={'e': 'f'}),
+          TD('fd', dispatch=[('loops_umath_fp', 'fd')]),
+          TD('g', f='atan2', astype={'e': 'f'}),
           TD(P, f='arctan2'),
           ),
 'remainder':
     Ufunc(2, 1, None,
           docstrings.get('numpy.core.umath.remainder'),
           'PyUFunc_RemainderTypeResolver',
-          TD(intflt),
+          TD(ints, dispatch=[('loops_modulo', ints)]),
+          TD(flts),
           [TypeDescription('m', FullTypeDescr, 'mm', 'm')],
           TD(O, f='PyNumber_Remainder'),
           ),
@@ -884,7 +918,8 @@ def english_upper(s):
     Ufunc(2, 2, None,
           docstrings.get('numpy.core.umath.divmod'),
           'PyUFunc_DivmodTypeResolver',
-          TD(intflt),
+          TD(ints, dispatch=[('loops_modulo', ints)]),
+          TD(flts),
           [TypeDescription('m', FullTypeDescr, 'mm', 'qm')],
           # TD(O, f='PyNumber_Divmod'),  # gh-9730
           ),
@@ -1151,14 +1186,6 @@ def make_ufuncs(funcdict):
     for name in names:
         uf = funcdict[name]
         mlist = []
-        docstring = textwrap.dedent(uf.docstring).strip()
-        docstring = docstring.encode('unicode-escape').decode('ascii')
-        docstring = docstring.replace(r'"', r'\"')
-        docstring = docstring.replace(r"'", r"\'")
-        # Split the docstring because some compilers (like MS) do not like big
-        # string literal in C code. We split at endlines because textwrap.wrap
-        # do not play well with \n
-        docstring = '\\n\"\"'.join(docstring.split(r"\n"))
         if uf.signature is None:
             sig = "NULL"
         else:
@@ -1171,7 +1198,7 @@ def make_ufuncs(funcdict):
             f = PyUFunc_FromFuncAndDataAndSignatureAndIdentity(
                 {name}_functions, {name}_data, {name}_signatures, {nloops},
                 {nin}, {nout}, {identity}, "{name}",
-                "{doc}", 0, {sig}, identity
+                {doc}, 0, {sig}, identity
             );
             if ({has_identity}) {{
                 Py_DECREF(identity);
@@ -1186,7 +1213,7 @@ def make_ufuncs(funcdict):
             has_identity='0' if uf.identity is None_ else '1',
             identity='PyUFunc_IdentityValue',
             identity_expr=uf.identity,
-            doc=docstring,
+            doc=uf.docstring,
             sig=sig,
         )
 
@@ -1222,6 +1249,7 @@ def make_code(funcdict, filename):
     #include "loops.h"
     #include "matmul.h"
     #include "clip.h"
+    #include "_umath_doc_generated.h"
     %s
 
     static int
@@ -1233,7 +1261,7 @@ def make_code(funcdict, filename):
 
         return 0;
     }
-    """) % (filename, code1, code2, code3)
+    """) % (os.path.basename(filename), code1, code2, code3)
     return code
 
 
diff --git a/numpy/core/code_generators/generate_umath_doc.py b/numpy/core/code_generators/generate_umath_doc.py
new file mode 100644
index 000000000000..9888730fd038
--- /dev/null
+++ b/numpy/core/code_generators/generate_umath_doc.py
@@ -0,0 +1,30 @@
+import sys
+import os
+import textwrap
+
+sys.path.insert(0, os.path.dirname(__file__))
+import ufunc_docstrings as docstrings
+sys.path.pop(0)
+
+def normalize_doc(docstring):
+    docstring = textwrap.dedent(docstring).strip()
+    docstring = docstring.encode('unicode-escape').decode('ascii')
+    docstring = docstring.replace(r'"', r'\"')
+    docstring = docstring.replace(r"'", r"\'")
+    # Split the docstring because some compilers (like MS) do not like big
+    # string literal in C code. We split at endlines because textwrap.wrap
+    # do not play well with \n
+    docstring = '\\n\"\"'.join(docstring.split(r"\n"))
+    return docstring
+
+def write_code(target):
+    with open(target, 'w') as fid:
+        fid.write(
+            "#ifndef NUMPY_CORE_INCLUDE__UMATH_DOC_GENERATED_H_\n"
+            "#define NUMPY_CORE_INCLUDE__UMATH_DOC_GENERATED_H_\n"
+        )
+        for place, string in docstrings.docdict.items():
+            cdef_name = f"DOC_{place.upper().replace('.', '_')}"
+            cdef_str = normalize_doc(string)
+            fid.write(f"#define {cdef_name} \"{cdef_str}\"\n")
+        fid.write("#endif //NUMPY_CORE_INCLUDE__UMATH_DOC_GENERATED_H\n")
diff --git a/numpy/core/code_generators/numpy_api.py b/numpy/core/code_generators/numpy_api.py
index d12d62d8fe9a..fa28f92b7ca6 100644
--- a/numpy/core/code_generators/numpy_api.py
+++ b/numpy/core/code_generators/numpy_api.py
@@ -13,7 +13,7 @@
 exception, so it should hopefully not get unnoticed).
 
 """
-from code_generators.genapi import StealRef, NonNull
+from code_generators.genapi import StealRef
 
 # index, type
 multiarray_global_vars = {
@@ -92,7 +92,7 @@
     'PyArray_TypeObjectFromType':           (46,),
     'PyArray_Zero':                         (47,),
     'PyArray_One':                          (48,),
-    'PyArray_CastToType':                   (49, StealRef(2), NonNull(2)),
+    'PyArray_CastToType':                   (49, StealRef(2)),
     'PyArray_CastTo':                       (50,),
     'PyArray_CastAnyTo':                    (51,),
     'PyArray_CanCastSafely':                (52,),
@@ -120,15 +120,15 @@
     'PyArray_FromBuffer':                   (74,),
     'PyArray_FromIter':                     (75, StealRef(2)),
     'PyArray_Return':                       (76, StealRef(1)),
-    'PyArray_GetField':                     (77, StealRef(2), NonNull(2)),
-    'PyArray_SetField':                     (78, StealRef(2), NonNull(2)),
+    'PyArray_GetField':                     (77, StealRef(2)),
+    'PyArray_SetField':                     (78, StealRef(2)),
     'PyArray_Byteswap':                     (79,),
     'PyArray_Resize':                       (80,),
     'PyArray_MoveInto':                     (81,),
     'PyArray_CopyInto':                     (82,),
     'PyArray_CopyAnyInto':                  (83,),
     'PyArray_CopyObject':                   (84,),
-    'PyArray_NewCopy':                      (85, NonNull(1)),
+    'PyArray_NewCopy':                      (85,),
     'PyArray_ToList':                       (86,),
     'PyArray_ToString':                     (87,),
     'PyArray_ToFile':                       (88,),
@@ -136,8 +136,8 @@
     'PyArray_Dumps':                        (90,),
     'PyArray_ValidType':                    (91,),
     'PyArray_UpdateFlags':                  (92,),
-    'PyArray_New':                          (93, NonNull(1)),
-    'PyArray_NewFromDescr':                 (94, StealRef(2), NonNull([1, 2])),
+    'PyArray_New':                          (93,),
+    'PyArray_NewFromDescr':                 (94, StealRef(2)),
     'PyArray_DescrNew':                     (95,),
     'PyArray_DescrNewFromType':             (96,),
     'PyArray_GetPriority':                  (97,),
@@ -318,7 +318,7 @@
     'PyArray_CanCastArrayTo':               (274,),
     'PyArray_CanCastTypeTo':                (275,),
     'PyArray_EinsteinSum':                  (276,),
-    'PyArray_NewLikeArray':                 (277, StealRef(3), NonNull(1)),
+    'PyArray_NewLikeArray':                 (277, StealRef(3)),
     'PyArray_GetArrayParamsFromObject':     (278,),
     'PyArray_ConvertClipmodeSequence':      (279,),
     'PyArray_MatrixProduct2':               (280,),
@@ -344,7 +344,7 @@
     'PyDataMem_NEW_ZEROED':                 (299,),
     # End 1.8 API
     # End 1.9 API
-    'PyArray_CheckAnyScalarExact':          (300, NonNull(1)),
+    'PyArray_CheckAnyScalarExact':          (300,),
     # End 1.10 API
     'PyArray_MapIterArrayCopyIfOverlap':    (301,),
     # End 1.13 API
@@ -353,7 +353,7 @@
     # End 1.14 API
     'PyDataMem_SetHandler':                 (304,),
     'PyDataMem_GetHandler':                 (305,),
-    # End 1.21 API
+    # End 1.22 API
 }
 
 ufunc_types_api = {
diff --git a/numpy/core/code_generators/ufunc_docstrings.py b/numpy/core/code_generators/ufunc_docstrings.py
index c9be945693dc..efc43b01c796 100644
--- a/numpy/core/code_generators/ufunc_docstrings.py
+++ b/numpy/core/code_generators/ufunc_docstrings.py
@@ -4,18 +4,15 @@
 The syntax is designed to look like the function add_newdoc is being
 called from numpy.lib, but in this file  add_newdoc puts the docstrings
 in a dictionary. This dictionary is used in
-numpy/core/code_generators/generate_umath.py to generate the docstrings
-for the ufuncs in numpy.core at the C level when the ufuncs are created
-at compile time.
+numpy/core/code_generators/generate_umath_doc.py to generate the docstrings
+as a C #definitions for the ufuncs in numpy.core at the C level when the
+ufuncs are created at compile time.
 
 """
 import textwrap
 
 docdict = {}
 
-def get(name):
-    return docdict.get(name)
-
 # common parameter text to all ufuncs
 subst = {
     'PARAMS': textwrap.dedent("""
@@ -515,7 +512,7 @@ def add_newdoc(place, name, doc):
     >>> np.arctan2([1., -1.], [0., 0.])
     array([ 1.57079633, -1.57079633])
     >>> np.arctan2([0., 0., np.inf], [+0., -0., np.inf])
-    array([ 0.        ,  3.14159265,  0.78539816])
+    array([0.        , 3.14159265, 0.78539816])
 
     """)
 
@@ -1089,9 +1086,8 @@ def add_newdoc(place, name, doc):
     -----
     Equivalent to ``x1`` / ``x2`` in terms of array-broadcasting.
 
-    Behavior on division by zero can be changed using ``seterr``.
-
-    Behaves like ``true_divide``.
+    The ``true_divide(x1, x2)`` function is an alias for
+    ``divide(x1, x2)``.
 
     Examples
     --------
@@ -1100,13 +1096,9 @@ def add_newdoc(place, name, doc):
     >>> x1 = np.arange(9.0).reshape((3, 3))
     >>> x2 = np.arange(3.0)
     >>> np.divide(x1, x2)
-    array([[ NaN,  1. ,  1. ],
-           [ Inf,  4. ,  2.5],
-           [ Inf,  7. ,  4. ]])
-
-    >>> ignored_states = np.seterr(**old_err_state)
-    >>> np.divide(1, 0)
-    0
+    array([[nan, 1. , 1. ],
+           [inf, 4. , 2.5],
+           [inf, 7. , 4. ]])
 
     The ``/`` operator can be used as a shorthand for ``np.divide`` on
     ndarrays.
@@ -2019,7 +2011,7 @@ def add_newdoc(place, name, doc):
     -----
     Logarithm is a multivalued function: for each `x` there is an infinite
     number of `z` such that `exp(z) = x`. The convention is to return the
-    `z` whose imaginary part lies in `[-pi, pi]`.
+    `z` whose imaginary part lies in `(-pi, pi]`.
 
     For real-valued input data types, `log` always returns real output. For
     each value that cannot be expressed as a real number or infinity, it
@@ -2029,6 +2021,10 @@ def add_newdoc(place, name, doc):
     has a branch cut `[-inf, 0]` and is continuous from above on it. `log`
     handles the floating-point negative zero as an infinitesimal negative
     number, conforming to the C99 standard.
+    
+    In the cases where the input has a negative real part and a very small
+    negative complex part (approaching 0), the result is so close to `-pi`
+    that it evaluates to exactly `-pi`.
 
     References
     ----------
@@ -2069,7 +2065,7 @@ def add_newdoc(place, name, doc):
     -----
     Logarithm is a multivalued function: for each `x` there is an infinite
     number of `z` such that `10**z = x`. The convention is to return the
-    `z` whose imaginary part lies in `[-pi, pi]`.
+    `z` whose imaginary part lies in `(-pi, pi]`.
 
     For real-valued input data types, `log10` always returns real output.
     For each value that cannot be expressed as a real number or infinity,
@@ -2080,6 +2076,10 @@ def add_newdoc(place, name, doc):
     `log10` handles the floating-point negative zero as an infinitesimal
     negative number, conforming to the C99 standard.
 
+    In the cases where the input has a negative real part and a very small
+    negative complex part (approaching 0), the result is so close to `-pi`
+    that it evaluates to exactly `-pi`.
+
     References
     ----------
     .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions",
@@ -2120,7 +2120,7 @@ def add_newdoc(place, name, doc):
 
     Logarithm is a multivalued function: for each `x` there is an infinite
     number of `z` such that `2**z = x`. The convention is to return the `z`
-    whose imaginary part lies in `[-pi, pi]`.
+    whose imaginary part lies in `(-pi, pi]`.
 
     For real-valued input data types, `log2` always returns real output.
     For each value that cannot be expressed as a real number or infinity,
@@ -2131,6 +2131,10 @@ def add_newdoc(place, name, doc):
     handles the floating-point negative zero as an infinitesimal negative
     number, conforming to the C99 standard.
 
+    In the cases where the input has a negative real part and a very small
+    negative complex part (approaching 0), the result is so close to `-pi`
+    that it evaluates to exactly `-pi`.
+
     Examples
     --------
     >>> x = np.array([0, 1, 2, 2**4])
@@ -2793,8 +2797,10 @@ def add_newdoc(place, name, doc):
       (9, 5, 7, 3)
       >>> # n is 7, k is 4, m is 3
 
-    The matmul function implements the semantics of the ``@`` operator introduced
-    in Python 3.5 following :pep:`465`.
+    The matmul function implements the semantics of the ``@`` operator
+    introduced in Python 3.5 following :pep:`465`.
+
+    It uses an optimized BLAS library when possible (see `numpy.linalg`).
 
     Examples
     --------
@@ -3825,8 +3831,9 @@ def add_newdoc(place, name, doc):
 
     See Also
     --------
-    lib.scimath.sqrt
+    emath.sqrt
         A version which returns complex numbers when given negative reals.
+        Note: 0.0 and -0.0 are handled differently for complex inputs.
 
     Notes
     -----
@@ -4051,59 +4058,11 @@ def add_newdoc(place, name, doc):
 
     """)
 
-add_newdoc('numpy.core.umath', 'true_divide',
-    """
-    Returns a true division of the inputs, element-wise.
-
-    Unlike 'floor division', true division adjusts the output type
-    to present the best answer, regardless of input types.
-
-    Parameters
-    ----------
-    x1 : array_like
-        Dividend array.
-    x2 : array_like
-        Divisor array.
-        $BROADCASTABLE_2
-    $PARAMS
-
-    Returns
-    -------
-    out : ndarray or scalar
-        $OUT_SCALAR_2
-
-    Notes
-    -----
-    In Python, ``//`` is the floor division operator and ``/`` the
-    true division operator.  The ``true_divide(x1, x2)`` function is
-    equivalent to true division in Python.
-
-    Examples
-    --------
-    >>> x = np.arange(5)
-    >>> np.true_divide(x, 4)
-    array([ 0.  ,  0.25,  0.5 ,  0.75,  1.  ])
-
-    >>> x/4
-    array([ 0.  ,  0.25,  0.5 ,  0.75,  1.  ])
-
-    >>> x//4
-    array([0, 0, 0, 0, 1])
-
-    The ``/`` operator can be used as a shorthand for ``np.true_divide`` on
-    ndarrays.
-
-    >>> x = np.arange(5)
-    >>> x / 4
-    array([0.  , 0.25, 0.5 , 0.75, 1.  ])
-
-    """)
-
 add_newdoc('numpy.core.umath', 'frexp',
     """
     Decompose the elements of x into mantissa and twos exponent.
 
-    Returns (`mantissa`, `exponent`), where `x = mantissa * 2**exponent``.
+    Returns (`mantissa`, `exponent`), where ``x = mantissa * 2**exponent``.
     The mantissa lies in the open interval(-1, 1), while the twos
     exponent is a signed integer.
 
diff --git a/numpy/core/defchararray.py b/numpy/core/defchararray.py
index 3521e778e1bd..6750e497a866 100644
--- a/numpy/core/defchararray.py
+++ b/numpy/core/defchararray.py
@@ -275,6 +275,18 @@ def str_len(a):
     See Also
     --------
     builtins.len
+
+    Examples
+    --------
+    >>> a = np.array(['Grace Hopper Conference', 'Open Source Day'])
+    >>> np.char.str_len(a)
+    array([23, 15])
+    >>> a = np.array([u'\u0420', u'\u043e'])
+    >>> np.char.str_len(a)
+    array([1, 1])
+    >>> a = np.array([['hello', 'world'], [u'\u0420', u'\u043e']])
+    >>> np.char.str_len(a)
+    array([[5, 5], [1, 1]])
     """
     # Note: __len__, etc. currently return ints, which are not C-integers.
     # Generally intp would be expected for lengths, although int is sufficient
@@ -333,7 +345,24 @@ def multiply(a, i):
     -------
     out : ndarray
         Output array of str or unicode, depending on input types
-
+    
+    Examples
+    --------
+    >>> a = np.array(["a", "b", "c"])
+    >>> np.char.multiply(x, 3)
+    array(['aaa', 'bbb', 'ccc'], dtype='>> i = np.array([1, 2, 3])
+    >>> np.char.multiply(a, i)
+    array(['a', 'bb', 'ccc'], dtype='>> np.char.multiply(np.array(['a']), i)
+    array(['a', 'aa', 'aaa'], dtype='>> a = np.array(['a', 'b', 'c', 'd', 'e', 'f']).reshape((2, 3))
+    >>> np.char.multiply(a, 3)
+    array([['aaa', 'bbb', 'ccc'],
+           ['ddd', 'eee', 'fff']], dtype='>> np.char.multiply(a, i)
+    array([['a', 'bb', 'ccc'],
+           ['d', 'ee', 'fff']], dtype='>> c = np.array(['a1b2','1b2a','b2a1','2a1b']); c
+    array(['a1b2', '1b2a', 'b2a1', '2a1b'], dtype='>> np.char.center(c, width=9)
+    array(['   a1b2  ', '   1b2a  ', '   b2a1  ', '   2a1b  '], dtype='>> np.char.center(c, width=9, fillchar='*')
+    array(['***a1b2**', '***1b2a**', '***b2a1**', '***2a1b**'], dtype='>> np.char.center(c, width=1)
+    array(['a', '1', 'b', '2'], dtype='>> c = np.array(['aAaAaA', '  aA  ', 'abBABba'])
+    >>> c = np.array([b'\x81\xc1\x81\xc1\x81\xc1', b'@@\x81\xc1@@',
+    ...               b'\x81\x82\xc2\xc1\xc2\x82\x81'])
     >>> c
+    array([b'\x81\xc1\x81\xc1\x81\xc1', b'@@\x81\xc1@@',
+    ...    b'\x81\x82\xc2\xc1\xc2\x82\x81'], dtype='|S7')
+    >>> np.char.decode(c, encoding='cp037')
     array(['aAaAaA', '  aA  ', 'abBABba'], dtype='>> np.char.encode(c, encoding='cp037')
-    array(['\\x81\\xc1\\x81\\xc1\\x81\\xc1', '@@\\x81\\xc1@@',
-        '\\x81\\x82\\xc2\\xc1\\xc2\\x82\\x81'],
-        dtype='|S7')
 
     """
     return _to_string_or_unicode_array(
@@ -711,6 +756,12 @@ def find(a, sub, start=0, end=None):
     --------
     str.find
 
+    Examples
+    --------
+    >>> a = np.array(["NumPy is a Python library"])
+    >>> np.char.find(a, "Python", start=0, end=None)
+    array([11])
+
     """
     return _vec_string(
         a, int_, 'find', [sub, start] + _clean_args(end))
@@ -740,6 +791,12 @@ def index(a, sub, start=0, end=None):
     --------
     find, str.find
 
+    Examples
+    --------
+    >>> a = np.array(["Computer Science"])
+    >>> np.char.index(a, "Science", start=0, end=None)
+    array([9])
+
     """
     return _vec_string(
         a, int_, 'index', [sub, start] + _clean_args(end))
@@ -819,6 +876,15 @@ def isdigit(a):
     See Also
     --------
     str.isdigit
+
+    Examples
+    --------
+    >>> a = np.array(['a', 'b', '0'])
+    >>> np.char.isdigit(a)
+    array([False, False,  True])
+    >>> a = np.array([['a', 'b', '0'], ['c', '1', '2']])
+    >>> np.char.isdigit(a)
+    array([[False, False,  True], [False,  True,  True]])
     """
     return _vec_string(a, bool_, 'isdigit')
 
@@ -906,7 +972,7 @@ def istitle(a):
 @array_function_dispatch(_unary_op_dispatcher)
 def isupper(a):
     """
-    Returns true for each element if all cased characters in the
+    Return true for each element if all cased characters in the
     string are uppercase and there is at least one character, false
     otherwise.
 
@@ -926,6 +992,16 @@ def isupper(a):
     See Also
     --------
     str.isupper
+
+    Examples
+    --------
+    >>> str = "GHC"
+    >>> np.char.isupper(str)
+    array(True)     
+    >>> a = np.array(["hello", "HELLO", "Hello"])
+    >>> np.char.isupper(a)
+    array([False,  True, False]) 
+
     """
     return _vec_string(a, bool_, 'isupper')
 
@@ -955,6 +1031,15 @@ def join(sep, seq):
     See Also
     --------
     str.join
+
+    Examples
+    --------
+    >>> np.char.join('-', 'osd')
+    array('o-s-d', dtype='>> np.char.join(['-', '.'], ['ghc', 'osd'])
+    array(['g-h-c', 'o.s.d'], dtype='>> a = np.array(["That is a mango", "Monkeys eat mangos"])
+    >>> np.char.replace(a, 'mango', 'banana')
+    array(['That is a banana', 'Monkeys eat bananas'], dtype='>> a = np.array(["The dish is fresh", "This is it"])
+    >>> np.char.replace(a, 'is', 'was')
+    array(['The dwash was fresh', 'Thwas was it'], dtype='>> np.char.isnumeric(['123', '123abc', '9.0', '1/4', 'VIII'])
+    array([ True, False, False, False, False])
+
     """
     if _use_unicode(a) != unicode_:
         raise TypeError("isnumeric is only available for Unicode strings and arrays")
@@ -1795,7 +1894,12 @@ def isdecimal(a):
     --------
     unicode.isdecimal
 
-    """
+    Examples
+    --------
+    >>> np.char.isdecimal(['12345', '4.99', '123ABC', ''])
+    array([ True, False, False, False])
+
+    """ 
     if _use_unicode(a) != unicode_:
         raise TypeError("isnumeric is only available for Unicode strings and arrays")
     return _vec_string(a, bool_, 'isdecimal')
@@ -2176,7 +2280,7 @@ def count(self, sub, start=0, end=None):
 
     def decode(self, encoding=None, errors=None):
         """
-        Calls `str.decode` element-wise.
+        Calls ``bytes.decode`` element-wise.
 
         See Also
         --------
diff --git a/numpy/core/defchararray.pyi b/numpy/core/defchararray.pyi
index 28d247b056e4..73d90bb2fc53 100644
--- a/numpy/core/defchararray.pyi
+++ b/numpy/core/defchararray.pyi
@@ -3,7 +3,6 @@ from typing import (
     overload,
     TypeVar,
     Any,
-    List,
 )
 
 from numpy import (
@@ -17,7 +16,7 @@ from numpy import (
     _OrderKACF,
 )
 
-from numpy.typing import (
+from numpy._typing import (
     NDArray,
     _ArrayLikeStr_co as U_co,
     _ArrayLikeBytes_co as S_co,
@@ -30,7 +29,7 @@ from numpy.core.multiarray import compare_chararrays as compare_chararrays
 _SCT = TypeVar("_SCT", str_, bytes_)
 _CharArray = chararray[Any, dtype[_SCT]]
 
-__all__: List[str]
+__all__: list[str]
 
 # Comparison
 @overload
diff --git a/numpy/core/einsumfunc.py b/numpy/core/einsumfunc.py
index c78d3db23abc..d6c5885b810a 100644
--- a/numpy/core/einsumfunc.py
+++ b/numpy/core/einsumfunc.py
@@ -821,6 +821,7 @@ def einsum_path(*operands, optimize='greedy', einsum_call=False):
     if path_type is None:
         path_type = False
 
+    explicit_einsum_path = False
     memory_limit = None
 
     # No optimization or a named path algorithm
@@ -829,7 +830,7 @@ def einsum_path(*operands, optimize='greedy', einsum_call=False):
 
     # Given an explicit path
     elif len(path_type) and (path_type[0] == 'einsum_path'):
-        pass
+        explicit_einsum_path = True
 
     # Path tuple with memory limit
     elif ((len(path_type) == 2) and isinstance(path_type[0], str) and
@@ -898,15 +899,19 @@ def einsum_path(*operands, optimize='greedy', einsum_call=False):
     naive_cost = _flop_count(indices, inner_product, len(input_list), dimension_dict)
 
     # Compute the path
-    if (path_type is False) or (len(input_list) in [1, 2]) or (indices == output_set):
+    if explicit_einsum_path:
+        path = path_type[1:]
+    elif (
+        (path_type is False)
+        or (len(input_list) in [1, 2])
+        or (indices == output_set)
+    ):
         # Nothing to be optimized, leave it to einsum
         path = [tuple(range(len(input_list)))]
     elif path_type == "greedy":
         path = _greedy_path(input_sets, output_set, dimension_dict, memory_arg)
     elif path_type == "optimal":
         path = _optimal_path(input_sets, output_set, dimension_dict, memory_arg)
-    elif path_type[0] == 'einsum_path':
-        path = path_type[1:]
     else:
         raise KeyError("Path name %s not found", path_type)
 
@@ -955,6 +960,13 @@ def einsum_path(*operands, optimize='greedy', einsum_call=False):
 
     opt_cost = sum(cost_list) + 1
 
+    if len(input_list) != 1:
+        # Explicit "einsum_path" is usually trusted, but we detect this kind of
+        # mistake in order to prevent from returning an intermediate value.
+        raise RuntimeError(
+            "Invalid einsum_path is specified: {} more operands has to be "
+            "contracted.".format(len(input_list) - 1))
+
     if einsum_call_arg:
         return (operands, contraction_list)
 
diff --git a/numpy/core/einsumfunc.pyi b/numpy/core/einsumfunc.pyi
index aabb04c478b9..c811a57838d5 100644
--- a/numpy/core/einsumfunc.pyi
+++ b/numpy/core/einsumfunc.pyi
@@ -1,4 +1,5 @@
-from typing import List, TypeVar, Optional, Any, overload, Union, Tuple, Sequence, Literal
+from collections.abc import Sequence
+from typing import TypeVar, Any, overload, Union, Literal
 
 from numpy import (
     ndarray,
@@ -11,7 +12,7 @@ from numpy import (
     number,
     _OrderKACF,
 )
-from numpy.typing import (
+from numpy._typing import (
     _ArrayLikeBool_co,
     _ArrayLikeUInt_co,
     _ArrayLikeInt_co,
@@ -30,13 +31,11 @@ _ArrayType = TypeVar(
     bound=ndarray[Any, dtype[Union[bool_, number[Any]]]],
 )
 
-_OptimizeKind = Union[
-    None, bool, Literal["greedy", "optimal"], Sequence[Any]
-]
+_OptimizeKind = None | bool | Literal["greedy", "optimal"] | Sequence[Any]
 _CastingSafe = Literal["no", "equiv", "safe", "same_kind"]
 _CastingUnsafe = Literal["unsafe"]
 
-__all__: List[str]
+__all__: list[str]
 
 # TODO: Properly handle the `casting`-based combinatorics
 # TODO: We need to evaluate the content `__subscripts` in order
@@ -46,89 +45,89 @@ __all__: List[str]
 # Something like `is_scalar = bool(__subscripts.partition("->")[-1])`
 @overload
 def einsum(
-    subscripts: str,
+    subscripts: str | _ArrayLikeInt_co,
     /,
     *operands: _ArrayLikeBool_co,
     out: None = ...,
-    dtype: Optional[_DTypeLikeBool] = ...,
+    dtype: None | _DTypeLikeBool = ...,
     order: _OrderKACF = ...,
     casting: _CastingSafe = ...,
     optimize: _OptimizeKind = ...,
 ) -> Any: ...
 @overload
 def einsum(
-    subscripts: str,
+    subscripts: str | _ArrayLikeInt_co,
     /,
     *operands: _ArrayLikeUInt_co,
     out: None = ...,
-    dtype: Optional[_DTypeLikeUInt] = ...,
+    dtype: None | _DTypeLikeUInt = ...,
     order: _OrderKACF = ...,
     casting: _CastingSafe = ...,
     optimize: _OptimizeKind = ...,
 ) -> Any: ...
 @overload
 def einsum(
-    subscripts: str,
+    subscripts: str | _ArrayLikeInt_co,
     /,
     *operands: _ArrayLikeInt_co,
     out: None = ...,
-    dtype: Optional[_DTypeLikeInt] = ...,
+    dtype: None | _DTypeLikeInt = ...,
     order: _OrderKACF = ...,
     casting: _CastingSafe = ...,
     optimize: _OptimizeKind = ...,
 ) -> Any: ...
 @overload
 def einsum(
-    subscripts: str,
+    subscripts: str | _ArrayLikeInt_co,
     /,
     *operands: _ArrayLikeFloat_co,
     out: None = ...,
-    dtype: Optional[_DTypeLikeFloat] = ...,
+    dtype: None | _DTypeLikeFloat = ...,
     order: _OrderKACF = ...,
     casting: _CastingSafe = ...,
     optimize: _OptimizeKind = ...,
 ) -> Any: ...
 @overload
 def einsum(
-    subscripts: str,
+    subscripts: str | _ArrayLikeInt_co,
     /,
     *operands: _ArrayLikeComplex_co,
     out: None = ...,
-    dtype: Optional[_DTypeLikeComplex] = ...,
+    dtype: None | _DTypeLikeComplex = ...,
     order: _OrderKACF = ...,
     casting: _CastingSafe = ...,
     optimize: _OptimizeKind = ...,
 ) -> Any: ...
 @overload
 def einsum(
-    subscripts: str,
+    subscripts: str | _ArrayLikeInt_co,
     /,
     *operands: Any,
     casting: _CastingUnsafe,
-    dtype: Optional[_DTypeLikeComplex_co] = ...,
+    dtype: None | _DTypeLikeComplex_co = ...,
     out: None = ...,
     order: _OrderKACF = ...,
     optimize: _OptimizeKind = ...,
 ) -> Any: ...
 @overload
 def einsum(
-    subscripts: str,
+    subscripts: str | _ArrayLikeInt_co,
     /,
     *operands: _ArrayLikeComplex_co,
     out: _ArrayType,
-    dtype: Optional[_DTypeLikeComplex_co] = ...,
+    dtype: None | _DTypeLikeComplex_co = ...,
     order: _OrderKACF = ...,
     casting: _CastingSafe = ...,
     optimize: _OptimizeKind = ...,
 ) -> _ArrayType: ...
 @overload
 def einsum(
-    subscripts: str,
+    subscripts: str | _ArrayLikeInt_co,
     /,
     *operands: Any,
     out: _ArrayType,
     casting: _CastingUnsafe,
-    dtype: Optional[_DTypeLikeComplex_co] = ...,
+    dtype: None | _DTypeLikeComplex_co = ...,
     order: _OrderKACF = ...,
     optimize: _OptimizeKind = ...,
 ) -> _ArrayType: ...
@@ -138,8 +137,8 @@ def einsum(
 # NOTE: In practice the list consists of a `str` (first element)
 # and a variable number of integer tuples.
 def einsum_path(
-    subscripts: str,
+    subscripts: str | _ArrayLikeInt_co,
     /,
     *operands: _ArrayLikeComplex_co,
     optimize: _OptimizeKind = ...,
-) -> Tuple[List[Any], str]: ...
+) -> tuple[list[Any], str]: ...
diff --git a/numpy/core/feature_detection_cmath.h b/numpy/core/feature_detection_cmath.h
new file mode 100644
index 000000000000..1dd71c643980
--- /dev/null
+++ b/numpy/core/feature_detection_cmath.h
@@ -0,0 +1,53 @@
+#include 
+
+#if defined(_MSC_VER) && !defined(__INTEL_COMPILER)
+#define cfloat _Fcomplex
+#define cdouble _Dcomplex
+#define cldouble _Lcomplex
+#else
+#define cfloat complex float
+#define cdouble complex double
+#define cldouble complex long double
+#endif
+
+// musl libc defines the following macros which breaks the declarations.
+// See https://git.musl-libc.org/cgit/musl/tree/include/complex.h#n108
+#undef crealf
+#undef cimagf
+#undef conjf
+#undef creal
+#undef cimag
+#undef conj
+#undef creall
+#undef cimagl
+#undef cconjl
+
+cfloat csinf(cfloat);
+cfloat ccosf(cfloat);
+cfloat ctanf(cfloat);
+cfloat csinhf(cfloat);
+cfloat ccoshf(cfloat);
+cfloat ctanhf(cfloat);
+float crealf(cfloat);
+float cimagf(cfloat);
+cfloat conjf(cfloat);
+
+cdouble csin(cdouble);
+cdouble ccos(cdouble);
+cdouble ctan(cdouble);
+cdouble csinh(cdouble);
+cdouble ccosh(cdouble);
+cdouble ctanh(cdouble);
+double creal(cdouble);
+double cimag(cdouble);
+cdouble conj(cdouble);
+
+cldouble csinl(cldouble);
+cldouble ccosl(cldouble);
+cldouble ctanl(cldouble);
+cldouble csinhl(cldouble);
+cldouble ccoshl(cldouble);
+cldouble ctanhl(cldouble);
+long double creall(cldouble);
+long double cimagl(cldouble);
+cldouble conjl(cldouble);
diff --git a/numpy/core/feature_detection_locale.h b/numpy/core/feature_detection_locale.h
new file mode 100644
index 000000000000..59e78936d8d8
--- /dev/null
+++ b/numpy/core/feature_detection_locale.h
@@ -0,0 +1,2 @@
+#pragma GCC diagnostic ignored "-Wnonnull"
+long double strtold_l(const char*, char**, locale_t);
diff --git a/numpy/core/feature_detection_math.h b/numpy/core/feature_detection_math.h
new file mode 100644
index 000000000000..27ad7bcf0139
--- /dev/null
+++ b/numpy/core/feature_detection_math.h
@@ -0,0 +1,107 @@
+double expm1(double);
+double log1p(double);
+double acosh(double);
+double asinh(double);
+double atanh(double);
+double rint(double);
+double trunc(double);
+double exp2(double);
+double log2(double);
+double hypot(double, double);
+double atan2(double, double);
+double pow(double, double);
+double copysign(double, double);
+double nextafter(double, double);
+long long strtoll(const char*, char**, int);
+unsigned long long strtoull(const char*, char**, int);
+double cbrt(double);
+long double sinl(long double);
+long double cosl(long double);
+long double tanl(long double);
+long double sinhl(long double);
+long double coshl(long double);
+long double tanhl(long double);
+long double fabsl(long double);
+long double floorl(long double);
+long double ceill(long double);
+long double rintl(long double);
+long double truncl(long double);
+long double sqrtl(long double);
+long double log10l(long double);
+long double logl(long double);
+long double log1pl(long double);
+long double expl(long double);
+long double expm1l(long double);
+long double asinl(long double);
+long double acosl(long double);
+long double atanl(long double);
+long double asinhl(long double);
+long double acoshl(long double);
+long double atanhl(long double);
+long double hypotl(long double, long double);
+long double atan2l(long double, long double);
+long double powl(long double, long double);
+long double fmodl(long double, long double);
+long double modfl(long double, long double*);
+long double frexpl(long double, int*);
+long double ldexpl(long double, int);
+long double exp2l(long double);
+long double log2l(long double);
+long double copysignl(long double, long double);
+long double nextafterl(long double, long double);
+long double cbrtl(long double);
+float sinf(float);
+float cosf(float);
+float tanf(float);
+float sinhf(float);
+float coshf(float);
+float tanhf(float);
+float fabsf(float);
+float floorf(float);
+float ceilf(float);
+float rintf(float);
+float truncf(float);
+float sqrtf(float);
+float log10f(float);
+float logf(float);
+float log1pf(float);
+float expf(float);
+float expm1f(float);
+float asinf(float);
+float acosf(float);
+float atanf(float);
+float asinhf(float);
+float acoshf(float);
+float atanhf(float);
+float hypotf(float, float);
+float atan2f(float, float);
+float powf(float, float);
+float fmodf(float, float);
+float modff(float, float*);
+float frexpf(float, int*);
+float ldexpf(float, int);
+float exp2f(float);
+float log2f(float);
+float copysignf(float, float);
+float nextafterf(float, float);
+float cbrtf(float);
+double sin(double);
+double cos(double);
+double tan(double);
+double sinh(double);
+double cosh(double);
+double tanh(double);
+double fabs(double);
+double floor(double);
+double ceil(double);
+double sqrt(double);
+double log10(double);
+double log(double);
+double exp(double);
+double asin(double);
+double acos(double);
+double atan(double);
+double fmod(double, double);
+double modf(double, double*);
+double frexp(double, int*);
+double ldexp(double, int);
diff --git a/numpy/core/feature_detection_misc.h b/numpy/core/feature_detection_misc.h
new file mode 100644
index 000000000000..f58cf4b62e99
--- /dev/null
+++ b/numpy/core/feature_detection_misc.h
@@ -0,0 +1,4 @@
+#include 
+
+int backtrace(void **, int);
+int madvise(void *, size_t, int);
diff --git a/numpy/core/feature_detection_stdio.h b/numpy/core/feature_detection_stdio.h
new file mode 100644
index 000000000000..bc14d16d04ff
--- /dev/null
+++ b/numpy/core/feature_detection_stdio.h
@@ -0,0 +1,6 @@
+#include 
+#include 
+
+off_t ftello(FILE *stream);
+int fseeko(FILE *stream, off_t offset, int whence);
+int fallocate(int, int, off_t, off_t);
diff --git a/numpy/core/fromnumeric.py b/numpy/core/fromnumeric.py
index 3242124acf50..ca9d55cb758b 100644
--- a/numpy/core/fromnumeric.py
+++ b/numpy/core/fromnumeric.py
@@ -17,7 +17,7 @@
 
 # functions that are methods
 __all__ = [
-    'alen', 'all', 'alltrue', 'amax', 'amin', 'any', 'argmax',
+    'all', 'alltrue', 'amax', 'amin', 'any', 'argmax',
     'argmin', 'argpartition', 'argsort', 'around', 'choose', 'clip',
     'compress', 'cumprod', 'cumproduct', 'cumsum', 'diagonal', 'mean',
     'ndim', 'nonzero', 'partition', 'prod', 'product', 'ptp', 'put',
@@ -601,59 +601,67 @@ def _transpose_dispatcher(a, axes=None):
 @array_function_dispatch(_transpose_dispatcher)
 def transpose(a, axes=None):
     """
-    Reverse or permute the axes of an array; returns the modified array.
+    Returns an array with axes transposed.
 
-    For an array a with two axes, transpose(a) gives the matrix transpose.
-
-    Refer to `numpy.ndarray.transpose` for full documentation.
+    For a 1-D array, this returns an unchanged view of the original array, as a
+    transposed vector is simply the same vector.
+    To convert a 1-D array into a 2-D column vector, an additional dimension
+    must be added, e.g., ``np.atleast2d(a).T`` achieves this, as does
+    ``a[:, np.newaxis]``.
+    For a 2-D array, this is the standard matrix transpose.
+    For an n-D array, if axes are given, their order indicates how the
+    axes are permuted (see Examples). If axes are not provided, then
+    ``transpose(a).shape == a.shape[::-1]``.
 
     Parameters
     ----------
     a : array_like
         Input array.
     axes : tuple or list of ints, optional
-        If specified, it must be a tuple or list which contains a permutation of
-        [0,1,..,N-1] where N is the number of axes of a.  The i'th axis of the
-        returned array will correspond to the axis numbered ``axes[i]`` of the
-        input.  If not specified, defaults to ``range(a.ndim)[::-1]``, which
-        reverses the order of the axes.
+        If specified, it must be a tuple or list which contains a permutation
+        of [0,1,...,N-1] where N is the number of axes of `a`. The `i`'th axis
+        of the returned array will correspond to the axis numbered ``axes[i]``
+        of the input. If not specified, defaults to ``range(a.ndim)[::-1]``,
+        which reverses the order of the axes.
 
     Returns
     -------
     p : ndarray
-        `a` with its axes permuted.  A view is returned whenever
-        possible.
+        `a` with its axes permuted. A view is returned whenever possible.
 
     See Also
     --------
-    ndarray.transpose : Equivalent method
-    moveaxis
-    argsort
+    ndarray.transpose : Equivalent method.
+    moveaxis : Move axes of an array to new positions.
+    argsort : Return the indices that would sort an array.
 
     Notes
     -----
-    Use `transpose(a, argsort(axes))` to invert the transposition of tensors
+    Use ``transpose(a, argsort(axes))`` to invert the transposition of tensors
     when using the `axes` keyword argument.
 
-    Transposing a 1-D array returns an unchanged view of the original array.
-
     Examples
     --------
-    >>> x = np.arange(4).reshape((2,2))
-    >>> x
-    array([[0, 1],
-           [2, 3]])
+    >>> a = np.array([[1, 2], [3, 4]])
+    >>> a
+    array([[1, 2],
+           [3, 4]])
+    >>> np.transpose(a)
+    array([[1, 3],
+           [2, 4]])
 
-    >>> np.transpose(x)
-    array([[0, 2],
-           [1, 3]])
+    >>> a = np.array([1, 2, 3, 4])
+    >>> a
+    array([1, 2, 3, 4])
+    >>> np.transpose(a)
+    array([1, 2, 3, 4])
 
-    >>> x = np.ones((1, 2, 3))
-    >>> np.transpose(x, (1, 0, 2)).shape
+    >>> a = np.ones((1, 2, 3))
+    >>> np.transpose(a, (1, 0, 2)).shape
     (2, 1, 3)
 
-    >>> x = np.ones((2, 3, 4, 5))
-    >>> np.transpose(x).shape
+    >>> a = np.ones((2, 3, 4, 5))
+    >>> np.transpose(a).shape
     (5, 4, 3, 2)
 
     """
@@ -670,10 +678,11 @@ def partition(a, kth, axis=-1, kind='introselect', order=None):
     Return a partitioned copy of an array.
 
     Creates a copy of the array with its elements rearranged in such a
-    way that the value of the element in k-th position is in the
-    position it would be in a sorted array. All elements smaller than
-    the k-th element are moved before this element and all equal or
-    greater are moved behind it. The ordering of the elements in the two
+    way that the value of the element in k-th position is in the position
+    the value would be in a sorted array.  In the partitioned array, all
+    elements before the k-th element are less than or equal to that
+    element, and all the elements after the k-th element are greater than
+    or equal to that element.  The ordering of the elements in the two
     partitions is undefined.
 
     .. versionadded:: 1.8.0
@@ -741,13 +750,30 @@ def partition(a, kth, axis=-1, kind='introselect', order=None):
 
     Examples
     --------
-    >>> a = np.array([3, 4, 2, 1])
-    >>> np.partition(a, 3)
-    array([2, 1, 3, 4])
+    >>> a = np.array([7, 1, 7, 7, 1, 5, 7, 2, 3, 2, 6, 2, 3, 0])
+    >>> p = np.partition(a, 4)
+    >>> p
+    array([0, 1, 2, 1, 2, 5, 2, 3, 3, 6, 7, 7, 7, 7])
 
-    >>> np.partition(a, (1, 3))
-    array([1, 2, 3, 4])
+    ``p[4]`` is 2;  all elements in ``p[:4]`` are less than or equal
+    to ``p[4]``, and all elements in ``p[5:]`` are greater than or
+    equal to ``p[4]``.  The partition is::
+
+        [0, 1, 2, 1], [2], [5, 2, 3, 3, 6, 7, 7, 7, 7]
+
+    The next example shows the use of multiple values passed to `kth`.
+
+    >>> p2 = np.partition(a, (4, 8))
+    >>> p2
+    array([0, 1, 2, 1, 2, 3, 3, 2, 5, 6, 7, 7, 7, 7])
 
+    ``p2[4]`` is 2  and ``p2[8]`` is 5.  All elements in ``p2[:4]``
+    are less than or equal to ``p2[4]``, all elements in ``p2[5:8]``
+    are greater than or equal to ``p2[4]`` and less than or equal to
+    ``p2[8]``, and all elements in ``p2[9:]`` are greater than or
+    equal to ``p2[8]``.  The partition is::
+
+        [0, 1, 2, 1], [2], [3, 3, 2], [5], [6, 7, 7, 7, 7]
     """
     if axis is None:
         # flatten returns (1, N) for np.matrix, so always use the last axis
@@ -780,7 +806,7 @@ def argpartition(a, kth, axis=-1, kind='introselect', order=None):
     kth : int or sequence of ints
         Element index to partition by. The k-th element will be in its
         final sorted position and all smaller elements will be moved
-        before it and all larger elements behind it. The order all
+        before it and all larger elements behind it. The order of all
         elements in the partitions is undefined. If provided with a
         sequence of k-th it will partition all of them into their sorted
         position at once.
@@ -804,8 +830,8 @@ def argpartition(a, kth, axis=-1, kind='introselect', order=None):
     index_array : ndarray, int
         Array of indices that partition `a` along the specified axis.
         If `a` is one-dimensional, ``a[index_array]`` yields a partitioned `a`.
-        More generally, ``np.take_along_axis(a, index_array, axis=a)`` always
-        yields the partitioned `a`, irrespective of dimensionality.
+        More generally, ``np.take_along_axis(a, index_array, axis=axis)``
+        always yields the partitioned `a`, irrespective of dimensionality.
 
     See Also
     --------
@@ -1980,25 +2006,27 @@ def shape(a):
 
     See Also
     --------
-    len
+    len : ``len(a)`` is equivalent to ``np.shape(a)[0]`` for N-D arrays with
+          ``N>=1``.
     ndarray.shape : Equivalent array method.
 
     Examples
     --------
     >>> np.shape(np.eye(3))
     (3, 3)
-    >>> np.shape([[1, 2]])
+    >>> np.shape([[1, 3]])
     (1, 2)
     >>> np.shape([0])
     (1,)
     >>> np.shape(0)
     ()
 
-    >>> a = np.array([(1, 2), (3, 4)], dtype=[('x', 'i4'), ('y', 'i4')])
+    >>> a = np.array([(1, 2), (3, 4), (5, 6)],
+    ...              dtype=[('x', 'i4'), ('y', 'i4')])
     >>> np.shape(a)
-    (2,)
+    (3,)
     >>> a.shape
-    (2,)
+    (3,)
 
     """
     try:
@@ -2307,7 +2335,7 @@ def any(a, axis=None, out=None, keepdims=np._NoValue, *, where=np._NoValue):
     """
     Test whether any array element along a given axis evaluates to True.
 
-    Returns single boolean unless `axis` is not ``None``
+    Returns single boolean if `axis` is ``None``
 
     Parameters
     ----------
@@ -2619,9 +2647,9 @@ def ptp(a, axis=None, out=None, keepdims=np._NoValue):
 
     Returns
     -------
-    ptp : ndarray
-        A new array holding the result, unless `out` was
-        specified, in which case a reference to `out` is returned.
+    ptp : ndarray or scalar
+        The range of a given array - `scalar` if array is one-dimensional
+        or a new array holding the result along the given axis
 
     Examples
     --------
@@ -2722,8 +2750,9 @@ def amax(a, axis=None, out=None, keepdims=np._NoValue, initial=np._NoValue,
     -------
     amax : ndarray or scalar
         Maximum of `a`. If `axis` is None, the result is a scalar value.
-        If `axis` is given, the result is an array of dimension
-        ``a.ndim - 1``.
+        If `axis` is an int, the result is an array of dimension
+        ``a.ndim - 1``. If `axis` is a tuple, the result is an array of 
+        dimension ``a.ndim - len(axis)``.
 
     See Also
     --------
@@ -2847,8 +2876,9 @@ def amin(a, axis=None, out=None, keepdims=np._NoValue, initial=np._NoValue,
     -------
     amin : ndarray or scalar
         Minimum of `a`. If `axis` is None, the result is a scalar value.
-        If `axis` is given, the result is an array of dimension
-        ``a.ndim - 1``.
+        If `axis` is an int, the result is an array of dimension
+        ``a.ndim - 1``.  If `axis` is a tuple, the result is an array of 
+        dimension ``a.ndim - len(axis)``.
 
     See Also
     --------
@@ -2917,51 +2947,6 @@ def amin(a, axis=None, out=None, keepdims=np._NoValue, initial=np._NoValue,
                           keepdims=keepdims, initial=initial, where=where)
 
 
-def _alen_dispathcer(a):
-    return (a,)
-
-
-@array_function_dispatch(_alen_dispathcer)
-def alen(a):
-    """
-    Return the length of the first dimension of the input array.
-
-    .. deprecated:: 1.18
-       `numpy.alen` is deprecated, use `len` instead.
-
-    Parameters
-    ----------
-    a : array_like
-       Input array.
-
-    Returns
-    -------
-    alen : int
-       Length of the first dimension of `a`.
-
-    See Also
-    --------
-    shape, size
-
-    Examples
-    --------
-    >>> a = np.zeros((7,4,5))
-    >>> a.shape[0]
-    7
-    >>> np.alen(a)
-    7
-
-    """
-    # NumPy 1.18.0, 2019-08-02
-    warnings.warn(
-        "`np.alen` is deprecated, use `len` instead",
-        DeprecationWarning, stacklevel=2)
-    try:
-        return len(a)
-    except TypeError:
-        return len(array(a, ndmin=1))
-
-
 def _prod_dispatcher(a, axis=None, dtype=None, out=None, keepdims=None,
                      initial=None, where=None):
     return (a, out)
@@ -3053,14 +3038,17 @@ def prod(a, axis=None, dtype=None, out=None, keepdims=np._NoValue,
 
     Even when the input array is two-dimensional:
 
-    >>> np.prod([[1.,2.],[3.,4.]])
+    >>> a = np.array([[1., 2.], [3., 4.]])
+    >>> np.prod(a)
     24.0
 
     But we can also specify the axis over which to multiply:
 
-    >>> np.prod([[1.,2.],[3.,4.]], axis=1)
+    >>> np.prod(a, axis=1)
     array([  2.,  12.])
-
+    >>> np.prod(a, axis=0)
+    array([3., 8.])
+    
     Or select specific elements to include:
 
     >>> np.prod([1., np.nan, 3.], where=[True, False, True])
@@ -3286,12 +3274,13 @@ def around(a, decimals=0, out=None):
     See Also
     --------
     ndarray.round : equivalent method
-
     ceil, fix, floor, rint, trunc
 
 
     Notes
     -----
+    `~numpy.round` is often used as an alias for `~numpy.around`.
+    
     For values exactly halfway between rounded decimal values, NumPy
     rounds to the nearest even value. Thus 1.5 and 2.5 round to 2.0,
     -0.5 and 0.5 round to 0.0, etc.
@@ -3451,6 +3440,7 @@ def mean(a, axis=None, dtype=None, out=None, keepdims=np._NoValue, *,
     0.55000000074505806 # may vary
 
     Specifying a where argument:
+
     >>> a = np.array([[5, 9, 13], [14, 10, 12], [11, 15, 19]])
     >>> np.mean(a)
     12.0
diff --git a/numpy/core/fromnumeric.pyi b/numpy/core/fromnumeric.pyi
index 3cbe1d5c5ce2..17b17819d704 100644
--- a/numpy/core/fromnumeric.pyi
+++ b/numpy/core/fromnumeric.pyi
@@ -1,12 +1,19 @@
 import datetime as dt
-from typing import Optional, Union, Sequence, Tuple, Any, overload, TypeVar, Literal
+from collections.abc import Sequence
+from typing import Union, Any, overload, TypeVar, Literal, SupportsIndex
 
 from numpy import (
     ndarray,
     number,
-    integer,
+    uint64,
+    int_,
+    int64,
     intp,
+    float16,
     bool_,
+    floating,
+    complexfloating,
+    object_,
     generic,
     _OrderKACF,
     _OrderACF,
@@ -15,230 +22,479 @@ from numpy import (
     _SortKind,
     _SortSide,
 )
-from numpy.typing import (
+from numpy._typing import (
     DTypeLike,
+    _DTypeLike,
     ArrayLike,
+    _ArrayLike,
+    NDArray,
     _ShapeLike,
     _Shape,
     _ArrayLikeBool_co,
+    _ArrayLikeUInt_co,
     _ArrayLikeInt_co,
+    _ArrayLikeFloat_co,
+    _ArrayLikeComplex_co,
+    _ArrayLikeObject_co,
+    _IntLike_co,
+    _BoolLike_co,
+    _ComplexLike_co,
     _NumberLike_co,
+    _ScalarLike_co,
 )
 
-# Various annotations for scalars
+_SCT = TypeVar("_SCT", bound=generic)
+_SCT_uifcO = TypeVar("_SCT_uifcO", bound=number[Any] | object_)
+_ArrayType = TypeVar("_ArrayType", bound=NDArray[Any])
 
-# While dt.datetime and dt.timedelta are not technically part of NumPy,
-# they are one of the rare few builtin scalars which serve as valid return types.
-# See https://github.com/numpy/numpy-stubs/pull/67#discussion_r412604113.
-_ScalarNumpy = Union[generic, dt.datetime, dt.timedelta]
-_ScalarBuiltin = Union[str, bytes, dt.date, dt.timedelta, bool, int, float, complex]
-_Scalar = Union[_ScalarBuiltin, _ScalarNumpy]
+__all__: list[str]
 
-# Integers and booleans can generally be used interchangeably
-_ScalarGeneric = TypeVar("_ScalarGeneric", bound=generic)
-
-_Number = TypeVar("_Number", bound=number)
-
-# The signature of take() follows a common theme with its overloads:
-# 1. A generic comes in; the same generic comes out
-# 2. A scalar comes in; a generic comes out
-# 3. An array-like object comes in; some keyword ensures that a generic comes out
-# 4. An array-like object comes in; an ndarray or generic comes out
+@overload
+def take(
+    a: _ArrayLike[_SCT],
+    indices: _IntLike_co,
+    axis: None = ...,
+    out: None = ...,
+    mode: _ModeKind = ...,
+) -> _SCT: ...
+@overload
 def take(
     a: ArrayLike,
-    indices: _ArrayLikeInt_co,
-    axis: Optional[int] = ...,
-    out: Optional[ndarray] = ...,
+    indices: _IntLike_co,
+    axis: None | SupportsIndex = ...,
+    out: None = ...,
     mode: _ModeKind = ...,
 ) -> Any: ...
+@overload
+def take(
+    a: _ArrayLike[_SCT],
+    indices: _ArrayLikeInt_co,
+    axis: None | SupportsIndex = ...,
+    out: None = ...,
+    mode: _ModeKind = ...,
+) -> NDArray[_SCT]: ...
+@overload
+def take(
+    a: ArrayLike,
+    indices: _ArrayLikeInt_co,
+    axis: None | SupportsIndex = ...,
+    out: None = ...,
+    mode: _ModeKind = ...,
+) -> NDArray[Any]: ...
+@overload
+def take(
+    a: ArrayLike,
+    indices: _ArrayLikeInt_co,
+    axis: None | SupportsIndex = ...,
+    out: _ArrayType = ...,
+    mode: _ModeKind = ...,
+) -> _ArrayType: ...
 
+@overload
+def reshape(
+    a: _ArrayLike[_SCT],
+    newshape: _ShapeLike,
+    order: _OrderACF = ...,
+) -> NDArray[_SCT]: ...
+@overload
 def reshape(
     a: ArrayLike,
     newshape: _ShapeLike,
     order: _OrderACF = ...,
-) -> ndarray: ...
+) -> NDArray[Any]: ...
 
+@overload
 def choose(
-    a: _ArrayLikeInt_co,
+    a: _IntLike_co,
     choices: ArrayLike,
-    out: Optional[ndarray] = ...,
+    out: None = ...,
     mode: _ModeKind = ...,
 ) -> Any: ...
+@overload
+def choose(
+    a: _ArrayLikeInt_co,
+    choices: _ArrayLike[_SCT],
+    out: None = ...,
+    mode: _ModeKind = ...,
+) -> NDArray[_SCT]: ...
+@overload
+def choose(
+    a: _ArrayLikeInt_co,
+    choices: ArrayLike,
+    out: None = ...,
+    mode: _ModeKind = ...,
+) -> NDArray[Any]: ...
+@overload
+def choose(
+    a: _ArrayLikeInt_co,
+    choices: ArrayLike,
+    out: _ArrayType = ...,
+    mode: _ModeKind = ...,
+) -> _ArrayType: ...
 
+@overload
+def repeat(
+    a: _ArrayLike[_SCT],
+    repeats: _ArrayLikeInt_co,
+    axis: None | SupportsIndex = ...,
+) -> NDArray[_SCT]: ...
+@overload
 def repeat(
     a: ArrayLike,
     repeats: _ArrayLikeInt_co,
-    axis: Optional[int] = ...,
-) -> ndarray: ...
+    axis: None | SupportsIndex = ...,
+) -> NDArray[Any]: ...
 
 def put(
-    a: ndarray,
+    a: NDArray[Any],
     ind: _ArrayLikeInt_co,
     v: ArrayLike,
     mode: _ModeKind = ...,
 ) -> None: ...
 
+@overload
+def swapaxes(
+    a: _ArrayLike[_SCT],
+    axis1: SupportsIndex,
+    axis2: SupportsIndex,
+) -> NDArray[_SCT]: ...
+@overload
 def swapaxes(
     a: ArrayLike,
-    axis1: int,
-    axis2: int,
-) -> ndarray: ...
+    axis1: SupportsIndex,
+    axis2: SupportsIndex,
+) -> NDArray[Any]: ...
 
+@overload
+def transpose(
+    a: _ArrayLike[_SCT],
+    axes: None | _ShapeLike = ...
+) -> NDArray[_SCT]: ...
+@overload
 def transpose(
     a: ArrayLike,
-    axes: Union[None, Sequence[int], ndarray] = ...
-) -> ndarray: ...
+    axes: None | _ShapeLike = ...
+) -> NDArray[Any]: ...
 
+@overload
+def partition(
+    a: _ArrayLike[_SCT],
+    kth: _ArrayLikeInt_co,
+    axis: None | SupportsIndex = ...,
+    kind: _PartitionKind = ...,
+    order: None | str | Sequence[str] = ...,
+) -> NDArray[_SCT]: ...
+@overload
 def partition(
     a: ArrayLike,
     kth: _ArrayLikeInt_co,
-    axis: Optional[int] = ...,
+    axis: None | SupportsIndex = ...,
     kind: _PartitionKind = ...,
-    order: Union[None, str, Sequence[str]] = ...,
-) -> ndarray: ...
+    order: None | str | Sequence[str] = ...,
+) -> NDArray[Any]: ...
 
 def argpartition(
     a: ArrayLike,
     kth: _ArrayLikeInt_co,
-    axis: Optional[int] = ...,
+    axis: None | SupportsIndex = ...,
     kind: _PartitionKind = ...,
-    order: Union[None, str, Sequence[str]] = ...,
-) -> Any: ...
+    order: None | str | Sequence[str] = ...,
+) -> NDArray[intp]: ...
 
+@overload
+def sort(
+    a: _ArrayLike[_SCT],
+    axis: None | SupportsIndex = ...,
+    kind: None | _SortKind = ...,
+    order: None | str | Sequence[str] = ...,
+) -> NDArray[_SCT]: ...
+@overload
 def sort(
     a: ArrayLike,
-    axis: Optional[int] = ...,
-    kind: Optional[_SortKind] = ...,
-    order: Union[None, str, Sequence[str]] = ...,
-) -> ndarray: ...
+    axis: None | SupportsIndex = ...,
+    kind: None | _SortKind = ...,
+    order: None | str | Sequence[str] = ...,
+) -> NDArray[Any]: ...
 
 def argsort(
     a: ArrayLike,
-    axis: Optional[int] = ...,
-    kind: Optional[_SortKind] = ...,
-    order: Union[None, str, Sequence[str]] = ...,
-) -> ndarray: ...
+    axis: None | SupportsIndex = ...,
+    kind: None | _SortKind = ...,
+    order: None | str | Sequence[str] = ...,
+) -> NDArray[intp]: ...
 
 @overload
 def argmax(
     a: ArrayLike,
     axis: None = ...,
-    out: Optional[ndarray] = ...,
+    out: None = ...,
     *,
     keepdims: Literal[False] = ...,
 ) -> intp: ...
 @overload
 def argmax(
     a: ArrayLike,
-    axis: Optional[int] = ...,
-    out: Optional[ndarray] = ...,
+    axis: None | SupportsIndex = ...,
+    out: None = ...,
     *,
     keepdims: bool = ...,
 ) -> Any: ...
+@overload
+def argmax(
+    a: ArrayLike,
+    axis: None | SupportsIndex = ...,
+    out: _ArrayType = ...,
+    *,
+    keepdims: bool = ...,
+) -> _ArrayType: ...
 
 @overload
 def argmin(
     a: ArrayLike,
     axis: None = ...,
-    out: Optional[ndarray] = ...,
+    out: None = ...,
     *,
     keepdims: Literal[False] = ...,
 ) -> intp: ...
 @overload
 def argmin(
     a: ArrayLike,
-    axis: Optional[int] = ...,
-    out: Optional[ndarray] = ...,
+    axis: None | SupportsIndex = ...,
+    out: None = ...,
     *,
     keepdims: bool = ...,
 ) -> Any: ...
+@overload
+def argmin(
+    a: ArrayLike,
+    axis: None | SupportsIndex = ...,
+    out: _ArrayType = ...,
+    *,
+    keepdims: bool = ...,
+) -> _ArrayType: ...
 
 @overload
 def searchsorted(
     a: ArrayLike,
-    v: _Scalar,
+    v: _ScalarLike_co,
     side: _SortSide = ...,
-    sorter: Optional[_ArrayLikeInt_co] = ...,  # 1D int array
+    sorter: None | _ArrayLikeInt_co = ...,  # 1D int array
 ) -> intp: ...
 @overload
 def searchsorted(
     a: ArrayLike,
     v: ArrayLike,
     side: _SortSide = ...,
-    sorter: Optional[_ArrayLikeInt_co] = ...,  # 1D int array
-) -> ndarray: ...
+    sorter: None | _ArrayLikeInt_co = ...,  # 1D int array
+) -> NDArray[intp]: ...
 
+@overload
+def resize(
+    a: _ArrayLike[_SCT],
+    new_shape: _ShapeLike,
+) -> NDArray[_SCT]: ...
+@overload
 def resize(
     a: ArrayLike,
     new_shape: _ShapeLike,
-) -> ndarray: ...
+) -> NDArray[Any]: ...
 
 @overload
 def squeeze(
-    a: _ScalarGeneric,
-    axis: Optional[_ShapeLike] = ...,
-) -> _ScalarGeneric: ...
+    a: _SCT,
+    axis: None | _ShapeLike = ...,
+) -> _SCT: ...
+@overload
+def squeeze(
+    a: _ArrayLike[_SCT],
+    axis: None | _ShapeLike = ...,
+) -> NDArray[_SCT]: ...
 @overload
 def squeeze(
     a: ArrayLike,
-    axis: Optional[_ShapeLike] = ...,
-) -> ndarray: ...
+    axis: None | _ShapeLike = ...,
+) -> NDArray[Any]: ...
 
+@overload
+def diagonal(
+    a: _ArrayLike[_SCT],
+    offset: SupportsIndex = ...,
+    axis1: SupportsIndex = ...,
+    axis2: SupportsIndex = ...,  # >= 2D array
+) -> NDArray[_SCT]: ...
+@overload
 def diagonal(
     a: ArrayLike,
-    offset: int = ...,
-    axis1: int = ...,
-    axis2: int = ...,  # >= 2D array
-) -> ndarray: ...
+    offset: SupportsIndex = ...,
+    axis1: SupportsIndex = ...,
+    axis2: SupportsIndex = ...,  # >= 2D array
+) -> NDArray[Any]: ...
 
+@overload
 def trace(
     a: ArrayLike,  # >= 2D array
-    offset: int = ...,
-    axis1: int = ...,
-    axis2: int = ...,
+    offset: SupportsIndex = ...,
+    axis1: SupportsIndex = ...,
+    axis2: SupportsIndex = ...,
     dtype: DTypeLike = ...,
-    out: Optional[ndarray] = ...,
+    out: None = ...,
 ) -> Any: ...
+@overload
+def trace(
+    a: ArrayLike,  # >= 2D array
+    offset: SupportsIndex = ...,
+    axis1: SupportsIndex = ...,
+    axis2: SupportsIndex = ...,
+    dtype: DTypeLike = ...,
+    out: _ArrayType = ...,
+) -> _ArrayType: ...
 
-def ravel(a: ArrayLike, order: _OrderKACF = ...) -> ndarray: ...
+@overload
+def ravel(a: _ArrayLike[_SCT], order: _OrderKACF = ...) -> NDArray[_SCT]: ...
+@overload
+def ravel(a: ArrayLike, order: _OrderKACF = ...) -> NDArray[Any]: ...
 
-def nonzero(a: ArrayLike) -> Tuple[ndarray, ...]: ...
+def nonzero(a: ArrayLike) -> tuple[NDArray[intp], ...]: ...
 
 def shape(a: ArrayLike) -> _Shape: ...
 
+@overload
 def compress(
-    condition: ArrayLike,  # 1D bool array
+    condition: _ArrayLikeBool_co,  # 1D bool array
+    a: _ArrayLike[_SCT],
+    axis: None | SupportsIndex = ...,
+    out: None = ...,
+) -> NDArray[_SCT]: ...
+@overload
+def compress(
+    condition: _ArrayLikeBool_co,  # 1D bool array
+    a: ArrayLike,
+    axis: None | SupportsIndex = ...,
+    out: None = ...,
+) -> NDArray[Any]: ...
+@overload
+def compress(
+    condition: _ArrayLikeBool_co,  # 1D bool array
     a: ArrayLike,
-    axis: Optional[int] = ...,
-    out: Optional[ndarray] = ...,
-) -> ndarray: ...
+    axis: None | SupportsIndex = ...,
+    out: _ArrayType = ...,
+) -> _ArrayType: ...
 
 @overload
 def clip(
-    a: ArrayLike,
-    a_min: ArrayLike,
-    a_max: Optional[ArrayLike],
-    out: Optional[ndarray] = ...,
-    **kwargs: Any,
+    a: _SCT,
+    a_min: None | ArrayLike,
+    a_max: None | ArrayLike,
+    out: None = ...,
+    *,
+    dtype: None = ...,
+    where: None | _ArrayLikeBool_co = ...,
+    order: _OrderKACF = ...,
+    subok: bool = ...,
+    signature: str | tuple[None | str, ...] = ...,
+    extobj: list[Any] = ...,
+) -> _SCT: ...
+@overload
+def clip(
+    a: _ScalarLike_co,
+    a_min: None | ArrayLike,
+    a_max: None | ArrayLike,
+    out: None = ...,
+    *,
+    dtype: None = ...,
+    where: None | _ArrayLikeBool_co = ...,
+    order: _OrderKACF = ...,
+    subok: bool = ...,
+    signature: str | tuple[None | str, ...] = ...,
+    extobj: list[Any] = ...,
 ) -> Any: ...
 @overload
+def clip(
+    a: _ArrayLike[_SCT],
+    a_min: None | ArrayLike,
+    a_max: None | ArrayLike,
+    out: None = ...,
+    *,
+    dtype: None = ...,
+    where: None | _ArrayLikeBool_co = ...,
+    order: _OrderKACF = ...,
+    subok: bool = ...,
+    signature: str | tuple[None | str, ...] = ...,
+    extobj: list[Any] = ...,
+) -> NDArray[_SCT]: ...
+@overload
 def clip(
     a: ArrayLike,
-    a_min: None,
-    a_max: ArrayLike,
-    out: Optional[ndarray] = ...,
-    **kwargs: Any,
+    a_min: None | ArrayLike,
+    a_max: None | ArrayLike,
+    out: None = ...,
+    *,
+    dtype: None = ...,
+    where: None | _ArrayLikeBool_co = ...,
+    order: _OrderKACF = ...,
+    subok: bool = ...,
+    signature: str | tuple[None | str, ...] = ...,
+    extobj: list[Any] = ...,
+) -> NDArray[Any]: ...
+@overload
+def clip(
+    a: ArrayLike,
+    a_min: None | ArrayLike,
+    a_max: None | ArrayLike,
+    out: _ArrayType = ...,
+    *,
+    dtype: DTypeLike,
+    where: None | _ArrayLikeBool_co = ...,
+    order: _OrderKACF = ...,
+    subok: bool = ...,
+    signature: str | tuple[None | str, ...] = ...,
+    extobj: list[Any] = ...,
 ) -> Any: ...
+@overload
+def clip(
+    a: ArrayLike,
+    a_min: None | ArrayLike,
+    a_max: None | ArrayLike,
+    out: _ArrayType,
+    *,
+    dtype: DTypeLike = ...,
+    where: None | _ArrayLikeBool_co = ...,
+    order: _OrderKACF = ...,
+    subok: bool = ...,
+    signature: str | tuple[None | str, ...] = ...,
+    extobj: list[Any] = ...,
+) -> _ArrayType: ...
 
+@overload
+def sum(
+    a: _ArrayLike[_SCT],
+    axis: None = ...,
+    dtype: None = ...,
+    out: None  = ...,
+    keepdims: bool = ...,
+    initial: _NumberLike_co = ...,
+    where: _ArrayLikeBool_co = ...,
+) -> _SCT: ...
+@overload
 def sum(
     a: ArrayLike,
-    axis: _ShapeLike = ...,
+    axis: None | _ShapeLike = ...,
     dtype: DTypeLike = ...,
-    out: Optional[ndarray] = ...,
+    out: None  = ...,
     keepdims: bool = ...,
     initial: _NumberLike_co = ...,
     where: _ArrayLikeBool_co = ...,
 ) -> Any: ...
+@overload
+def sum(
+    a: ArrayLike,
+    axis: None | _ShapeLike = ...,
+    dtype: DTypeLike = ...,
+    out: _ArrayType  = ...,
+    keepdims: bool = ...,
+    initial: _NumberLike_co = ...,
+    where: _ArrayLikeBool_co = ...,
+) -> _ArrayType: ...
 
 @overload
 def all(
@@ -246,14 +502,27 @@ def all(
     axis: None = ...,
     out: None = ...,
     keepdims: Literal[False] = ...,
+    *,
+    where: _ArrayLikeBool_co = ...,
 ) -> bool_: ...
 @overload
 def all(
     a: ArrayLike,
-    axis: Optional[_ShapeLike] = ...,
-    out: Optional[ndarray] = ...,
+    axis: None | _ShapeLike = ...,
+    out: None = ...,
     keepdims: bool = ...,
+    *,
+    where: _ArrayLikeBool_co = ...,
 ) -> Any: ...
+@overload
+def all(
+    a: ArrayLike,
+    axis: None | _ShapeLike = ...,
+    out: _ArrayType = ...,
+    keepdims: bool = ...,
+    *,
+    where: _ArrayLikeBool_co = ...,
+) -> _ArrayType: ...
 
 @overload
 def any(
@@ -261,46 +530,141 @@ def any(
     axis: None = ...,
     out: None = ...,
     keepdims: Literal[False] = ...,
+    *,
+    where: _ArrayLikeBool_co = ...,
 ) -> bool_: ...
 @overload
 def any(
     a: ArrayLike,
-    axis: Optional[_ShapeLike] = ...,
-    out: Optional[ndarray] = ...,
+    axis: None | _ShapeLike = ...,
+    out: None = ...,
     keepdims: bool = ...,
+    *,
+    where: _ArrayLikeBool_co = ...,
 ) -> Any: ...
+@overload
+def any(
+    a: ArrayLike,
+    axis: None | _ShapeLike = ...,
+    out: _ArrayType = ...,
+    keepdims: bool = ...,
+    *,
+    where: _ArrayLikeBool_co = ...,
+) -> _ArrayType: ...
 
+@overload
+def cumsum(
+    a: _ArrayLike[_SCT],
+    axis: None | SupportsIndex = ...,
+    dtype: None = ...,
+    out: None = ...,
+) -> NDArray[_SCT]: ...
+@overload
 def cumsum(
     a: ArrayLike,
-    axis: Optional[int] = ...,
+    axis: None | SupportsIndex = ...,
+    dtype: None = ...,
+    out: None = ...,
+) -> NDArray[Any]: ...
+@overload
+def cumsum(
+    a: ArrayLike,
+    axis: None | SupportsIndex = ...,
+    dtype: _DTypeLike[_SCT] = ...,
+    out: None = ...,
+) -> NDArray[_SCT]: ...
+@overload
+def cumsum(
+    a: ArrayLike,
+    axis: None | SupportsIndex = ...,
     dtype: DTypeLike = ...,
-    out: Optional[ndarray] = ...,
-) -> ndarray: ...
+    out: None = ...,
+) -> NDArray[Any]: ...
+@overload
+def cumsum(
+    a: ArrayLike,
+    axis: None | SupportsIndex = ...,
+    dtype: DTypeLike = ...,
+    out: _ArrayType = ...,
+) -> _ArrayType: ...
 
+@overload
+def ptp(
+    a: _ArrayLike[_SCT],
+    axis: None = ...,
+    out: None = ...,
+    keepdims: Literal[False] = ...,
+) -> _SCT: ...
+@overload
 def ptp(
     a: ArrayLike,
-    axis: Optional[_ShapeLike] = ...,
-    out: Optional[ndarray] = ...,
+    axis: None | _ShapeLike = ...,
+    out: None = ...,
     keepdims: bool = ...,
 ) -> Any: ...
+@overload
+def ptp(
+    a: ArrayLike,
+    axis: None | _ShapeLike = ...,
+    out: _ArrayType = ...,
+    keepdims: bool = ...,
+) -> _ArrayType: ...
 
+@overload
+def amax(
+    a: _ArrayLike[_SCT],
+    axis: None = ...,
+    out: None = ...,
+    keepdims: Literal[False] = ...,
+    initial: _NumberLike_co = ...,
+    where: _ArrayLikeBool_co = ...,
+) -> _SCT: ...
+@overload
 def amax(
     a: ArrayLike,
-    axis: Optional[_ShapeLike] = ...,
-    out: Optional[ndarray] = ...,
+    axis: None | _ShapeLike = ...,
+    out: None = ...,
     keepdims: bool = ...,
     initial: _NumberLike_co = ...,
     where: _ArrayLikeBool_co = ...,
 ) -> Any: ...
+@overload
+def amax(
+    a: ArrayLike,
+    axis: None | _ShapeLike = ...,
+    out: _ArrayType = ...,
+    keepdims: bool = ...,
+    initial: _NumberLike_co = ...,
+    where: _ArrayLikeBool_co = ...,
+) -> _ArrayType: ...
 
+@overload
+def amin(
+    a: _ArrayLike[_SCT],
+    axis: None = ...,
+    out: None = ...,
+    keepdims: Literal[False] = ...,
+    initial: _NumberLike_co = ...,
+    where: _ArrayLikeBool_co = ...,
+) -> _SCT: ...
+@overload
 def amin(
     a: ArrayLike,
-    axis: Optional[_ShapeLike] = ...,
-    out: Optional[ndarray] = ...,
+    axis: None | _ShapeLike = ...,
+    out: None = ...,
     keepdims: bool = ...,
     initial: _NumberLike_co = ...,
     where: _ArrayLikeBool_co = ...,
 ) -> Any: ...
+@overload
+def amin(
+    a: ArrayLike,
+    axis: None | _ShapeLike = ...,
+    out: _ArrayType = ...,
+    keepdims: bool = ...,
+    initial: _NumberLike_co = ...,
+    where: _ArrayLikeBool_co = ...,
+) -> _ArrayType: ...
 
 # TODO: `np.prod()``: For object arrays `initial` does not necessarily
 # have to be a numerical scalar.
@@ -309,55 +673,377 @@ def amin(
 
 # Note that the same situation holds for all wrappers around
 # `np.ufunc.reduce`, e.g. `np.sum()` (`.__add__()`).
+@overload
 def prod(
-    a: ArrayLike,
-    axis: Optional[_ShapeLike] = ...,
-    dtype: DTypeLike = ...,
-    out: Optional[ndarray] = ...,
+    a: _ArrayLikeBool_co,
+    axis: None = ...,
+    dtype: None = ...,
+    out: None = ...,
+    keepdims: Literal[False] = ...,
+    initial: _NumberLike_co = ...,
+    where: _ArrayLikeBool_co = ...,
+) -> int_: ...
+@overload
+def prod(
+    a: _ArrayLikeUInt_co,
+    axis: None = ...,
+    dtype: None = ...,
+    out: None = ...,
+    keepdims: Literal[False] = ...,
+    initial: _NumberLike_co = ...,
+    where: _ArrayLikeBool_co = ...,
+) -> uint64: ...
+@overload
+def prod(
+    a: _ArrayLikeInt_co,
+    axis: None = ...,
+    dtype: None = ...,
+    out: None = ...,
+    keepdims: Literal[False] = ...,
+    initial: _NumberLike_co = ...,
+    where: _ArrayLikeBool_co = ...,
+) -> int64: ...
+@overload
+def prod(
+    a: _ArrayLikeFloat_co,
+    axis: None = ...,
+    dtype: None = ...,
+    out: None = ...,
+    keepdims: Literal[False] = ...,
+    initial: _NumberLike_co = ...,
+    where: _ArrayLikeBool_co = ...,
+) -> floating[Any]: ...
+@overload
+def prod(
+    a: _ArrayLikeComplex_co,
+    axis: None = ...,
+    dtype: None = ...,
+    out: None = ...,
+    keepdims: Literal[False] = ...,
+    initial: _NumberLike_co = ...,
+    where: _ArrayLikeBool_co = ...,
+) -> complexfloating[Any, Any]: ...
+@overload
+def prod(
+    a: _ArrayLikeComplex_co | _ArrayLikeObject_co,
+    axis: None | _ShapeLike = ...,
+    dtype: None = ...,
+    out: None = ...,
     keepdims: bool = ...,
     initial: _NumberLike_co = ...,
     where: _ArrayLikeBool_co = ...,
 ) -> Any: ...
+@overload
+def prod(
+    a: _ArrayLikeComplex_co | _ArrayLikeObject_co,
+    axis: None = ...,
+    dtype: _DTypeLike[_SCT] = ...,
+    out: None = ...,
+    keepdims: Literal[False] = ...,
+    initial: _NumberLike_co = ...,
+    where: _ArrayLikeBool_co = ...,
+) -> _SCT: ...
+@overload
+def prod(
+    a: _ArrayLikeComplex_co | _ArrayLikeObject_co,
+    axis: None | _ShapeLike = ...,
+    dtype: None | DTypeLike = ...,
+    out: None = ...,
+    keepdims: bool = ...,
+    initial: _NumberLike_co = ...,
+    where: _ArrayLikeBool_co = ...,
+) -> Any: ...
+@overload
+def prod(
+    a: _ArrayLikeComplex_co | _ArrayLikeObject_co,
+    axis: None | _ShapeLike = ...,
+    dtype: None | DTypeLike = ...,
+    out: _ArrayType = ...,
+    keepdims: bool = ...,
+    initial: _NumberLike_co = ...,
+    where: _ArrayLikeBool_co = ...,
+) -> _ArrayType: ...
 
+@overload
 def cumprod(
-    a: ArrayLike,
-    axis: Optional[int] = ...,
+    a: _ArrayLikeBool_co,
+    axis: None | SupportsIndex = ...,
+    dtype: None = ...,
+    out: None = ...,
+) -> NDArray[int_]: ...
+@overload
+def cumprod(
+    a: _ArrayLikeUInt_co,
+    axis: None | SupportsIndex = ...,
+    dtype: None = ...,
+    out: None = ...,
+) -> NDArray[uint64]: ...
+@overload
+def cumprod(
+    a: _ArrayLikeInt_co,
+    axis: None | SupportsIndex = ...,
+    dtype: None = ...,
+    out: None = ...,
+) -> NDArray[int64]: ...
+@overload
+def cumprod(
+    a: _ArrayLikeFloat_co,
+    axis: None | SupportsIndex = ...,
+    dtype: None = ...,
+    out: None = ...,
+) -> NDArray[floating[Any]]: ...
+@overload
+def cumprod(
+    a: _ArrayLikeComplex_co,
+    axis: None | SupportsIndex = ...,
+    dtype: None = ...,
+    out: None = ...,
+) -> NDArray[complexfloating[Any, Any]]: ...
+@overload
+def cumprod(
+    a: _ArrayLikeObject_co,
+    axis: None | SupportsIndex = ...,
+    dtype: None = ...,
+    out: None = ...,
+) -> NDArray[object_]: ...
+@overload
+def cumprod(
+    a: _ArrayLikeComplex_co | _ArrayLikeObject_co,
+    axis: None | SupportsIndex = ...,
+    dtype: _DTypeLike[_SCT] = ...,
+    out: None = ...,
+) -> NDArray[_SCT]: ...
+@overload
+def cumprod(
+    a: _ArrayLikeComplex_co | _ArrayLikeObject_co,
+    axis: None | SupportsIndex = ...,
     dtype: DTypeLike = ...,
-    out: Optional[ndarray] = ...,
-) -> ndarray: ...
+    out: None = ...,
+) -> NDArray[Any]: ...
+@overload
+def cumprod(
+    a: _ArrayLikeComplex_co | _ArrayLikeObject_co,
+    axis: None | SupportsIndex = ...,
+    dtype: DTypeLike = ...,
+    out: _ArrayType = ...,
+) -> _ArrayType: ...
 
 def ndim(a: ArrayLike) -> int: ...
 
-def size(a: ArrayLike, axis: Optional[int] = ...) -> int: ...
+def size(a: ArrayLike, axis: None | int = ...) -> int: ...
 
+@overload
 def around(
-    a: ArrayLike,
-    decimals: int = ...,
-    out: Optional[ndarray] = ...,
+    a: _BoolLike_co,
+    decimals: SupportsIndex = ...,
+    out: None = ...,
+) -> float16: ...
+@overload
+def around(
+    a: _SCT_uifcO,
+    decimals: SupportsIndex = ...,
+    out: None = ...,
+) -> _SCT_uifcO: ...
+@overload
+def around(
+    a: _ComplexLike_co | object_,
+    decimals: SupportsIndex = ...,
+    out: None = ...,
 ) -> Any: ...
+@overload
+def around(
+    a: _ArrayLikeBool_co,
+    decimals: SupportsIndex = ...,
+    out: None = ...,
+) -> NDArray[float16]: ...
+@overload
+def around(
+    a: _ArrayLike[_SCT_uifcO],
+    decimals: SupportsIndex = ...,
+    out: None = ...,
+) -> NDArray[_SCT_uifcO]: ...
+@overload
+def around(
+    a: _ArrayLikeComplex_co | _ArrayLikeObject_co,
+    decimals: SupportsIndex = ...,
+    out: None = ...,
+) -> NDArray[Any]: ...
+@overload
+def around(
+    a: _ArrayLikeComplex_co | _ArrayLikeObject_co,
+    decimals: SupportsIndex = ...,
+    out: _ArrayType = ...,
+) -> _ArrayType: ...
 
+@overload
 def mean(
-    a: ArrayLike,
-    axis: Optional[_ShapeLike] = ...,
+    a: _ArrayLikeFloat_co,
+    axis: None = ...,
+    dtype: None = ...,
+    out: None = ...,
+    keepdims: Literal[False] = ...,
+    *,
+    where: _ArrayLikeBool_co = ...,
+) -> floating[Any]: ...
+@overload
+def mean(
+    a: _ArrayLikeComplex_co,
+    axis: None = ...,
+    dtype: None = ...,
+    out: None = ...,
+    keepdims: Literal[False] = ...,
+    *,
+    where: _ArrayLikeBool_co = ...,
+) -> complexfloating[Any, Any]: ...
+@overload
+def mean(
+    a: _ArrayLikeComplex_co | _ArrayLikeObject_co,
+    axis: None | _ShapeLike = ...,
+    dtype: None = ...,
+    out: None = ...,
+    keepdims: bool = ...,
+    *,
+    where: _ArrayLikeBool_co = ...,
+) -> Any: ...
+@overload
+def mean(
+    a: _ArrayLikeComplex_co | _ArrayLikeObject_co,
+    axis: None = ...,
+    dtype: _DTypeLike[_SCT] = ...,
+    out: None = ...,
+    keepdims: Literal[False] = ...,
+    *,
+    where: _ArrayLikeBool_co = ...,
+) -> _SCT: ...
+@overload
+def mean(
+    a: _ArrayLikeComplex_co | _ArrayLikeObject_co,
+    axis: None | _ShapeLike = ...,
     dtype: DTypeLike = ...,
-    out: Optional[ndarray] = ...,
+    out: None = ...,
     keepdims: bool = ...,
+    *,
+    where: _ArrayLikeBool_co = ...,
 ) -> Any: ...
+@overload
+def mean(
+    a: _ArrayLikeComplex_co | _ArrayLikeObject_co,
+    axis: None | _ShapeLike = ...,
+    dtype: DTypeLike = ...,
+    out: _ArrayType = ...,
+    keepdims: bool = ...,
+    *,
+    where: _ArrayLikeBool_co = ...,
+) -> _ArrayType: ...
 
+@overload
 def std(
-    a: ArrayLike,
-    axis: Optional[_ShapeLike] = ...,
+    a: _ArrayLikeComplex_co,
+    axis: None = ...,
+    dtype: None = ...,
+    out: None = ...,
+    ddof: float = ...,
+    keepdims: Literal[False] = ...,
+    *,
+    where: _ArrayLikeBool_co = ...,
+) -> floating[Any]: ...
+@overload
+def std(
+    a: _ArrayLikeComplex_co | _ArrayLikeObject_co,
+    axis: None | _ShapeLike = ...,
+    dtype: None = ...,
+    out: None = ...,
+    ddof: float = ...,
+    keepdims: bool = ...,
+    *,
+    where: _ArrayLikeBool_co = ...,
+) -> Any: ...
+@overload
+def std(
+    a: _ArrayLikeComplex_co | _ArrayLikeObject_co,
+    axis: None = ...,
+    dtype: _DTypeLike[_SCT] = ...,
+    out: None = ...,
+    ddof: float = ...,
+    keepdims: Literal[False] = ...,
+    *,
+    where: _ArrayLikeBool_co = ...,
+) -> _SCT: ...
+@overload
+def std(
+    a: _ArrayLikeComplex_co | _ArrayLikeObject_co,
+    axis: None | _ShapeLike = ...,
     dtype: DTypeLike = ...,
-    out: Optional[ndarray] = ...,
-    ddof: int = ...,
+    out: None = ...,
+    ddof: float = ...,
     keepdims: bool = ...,
+    *,
+    where: _ArrayLikeBool_co = ...,
 ) -> Any: ...
+@overload
+def std(
+    a: _ArrayLikeComplex_co | _ArrayLikeObject_co,
+    axis: None | _ShapeLike = ...,
+    dtype: DTypeLike = ...,
+    out: _ArrayType = ...,
+    ddof: float = ...,
+    keepdims: bool = ...,
+    *,
+    where: _ArrayLikeBool_co = ...,
+) -> _ArrayType: ...
 
+@overload
 def var(
-    a: ArrayLike,
-    axis: Optional[_ShapeLike] = ...,
+    a: _ArrayLikeComplex_co,
+    axis: None = ...,
+    dtype: None = ...,
+    out: None = ...,
+    ddof: float = ...,
+    keepdims: Literal[False] = ...,
+    *,
+    where: _ArrayLikeBool_co = ...,
+) -> floating[Any]: ...
+@overload
+def var(
+    a: _ArrayLikeComplex_co | _ArrayLikeObject_co,
+    axis: None | _ShapeLike = ...,
+    dtype: None = ...,
+    out: None = ...,
+    ddof: float = ...,
+    keepdims: bool = ...,
+    *,
+    where: _ArrayLikeBool_co = ...,
+) -> Any: ...
+@overload
+def var(
+    a: _ArrayLikeComplex_co | _ArrayLikeObject_co,
+    axis: None = ...,
+    dtype: _DTypeLike[_SCT] = ...,
+    out: None = ...,
+    ddof: float = ...,
+    keepdims: Literal[False] = ...,
+    *,
+    where: _ArrayLikeBool_co = ...,
+) -> _SCT: ...
+@overload
+def var(
+    a: _ArrayLikeComplex_co | _ArrayLikeObject_co,
+    axis: None | _ShapeLike = ...,
     dtype: DTypeLike = ...,
-    out: Optional[ndarray] = ...,
-    ddof: int = ...,
+    out: None = ...,
+    ddof: float = ...,
     keepdims: bool = ...,
+    *,
+    where: _ArrayLikeBool_co = ...,
 ) -> Any: ...
+@overload
+def var(
+    a: _ArrayLikeComplex_co | _ArrayLikeObject_co,
+    axis: None | _ShapeLike = ...,
+    dtype: DTypeLike = ...,
+    out: _ArrayType = ...,
+    ddof: float = ...,
+    keepdims: bool = ...,
+    *,
+    where: _ArrayLikeBool_co = ...,
+) -> _ArrayType: ...
diff --git a/numpy/core/function_base.py b/numpy/core/function_base.py
index e940ac230537..3dc51a81b18b 100644
--- a/numpy/core/function_base.py
+++ b/numpy/core/function_base.py
@@ -91,6 +91,7 @@ def linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None,
                 scale (a geometric progression).
     logspace : Similar to `geomspace`, but with the end points specified as
                logarithms.
+    :ref:`how-to-partition`
 
     Examples
     --------
@@ -130,16 +131,21 @@ def linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None,
     dt = result_type(start, stop, float(num))
     if dtype is None:
         dtype = dt
+        integer_dtype = False
+    else:
+        integer_dtype = _nx.issubdtype(dtype, _nx.integer)
 
     delta = stop - start
     y = _nx.arange(0, num, dtype=dt).reshape((-1,) + (1,) * ndim(delta))
     # In-place multiplication y *= delta/div is faster, but prevents the multiplicant
     # from overriding what class is produced, and thus prevents, e.g. use of Quantities,
     # see gh-7142. Hence, we multiply in place only for standard scalar types.
-    _mult_inplace = _nx.isscalar(delta)
     if div > 0:
+        _mult_inplace = _nx.isscalar(delta)
         step = delta / div
-        if _nx.any(step == 0):
+        any_step_zero = (
+            step == 0 if _mult_inplace else _nx.asanyarray(step == 0).any())
+        if any_step_zero:
             # Special handling for denormal numbers, gh-5437
             y /= div
             if _mult_inplace:
@@ -166,7 +172,7 @@ def linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None,
     if axis != 0:
         y = _nx.moveaxis(y, 0, axis)
 
-    if _nx.issubdtype(dtype, _nx.integer):
+    if integer_dtype:
         _nx.floor(y, out=y)
 
     if retstep:
@@ -237,6 +243,7 @@ def logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None,
     linspace : Similar to logspace, but with the samples uniformly distributed
                in linear space, instead of log space.
     geomspace : Similar to logspace, but with endpoints specified directly.
+    :ref:`how-to-partition`
 
     Notes
     -----
@@ -333,6 +340,7 @@ def geomspace(start, stop, num=50, endpoint=True, dtype=None, axis=0):
                progression.
     arange : Similar to linspace, with the step size specified instead of the
              number of samples.
+    :ref:`how-to-partition`
 
     Notes
     -----
diff --git a/numpy/core/function_base.pyi b/numpy/core/function_base.pyi
index 68d3b3a98f57..2c2a277b1b1b 100644
--- a/numpy/core/function_base.pyi
+++ b/numpy/core/function_base.pyi
@@ -1,60 +1,187 @@
-from typing import overload, Tuple, Union, Sequence, Any, SupportsIndex, Literal, List
+from typing import (
+    Literal as L,
+    overload,
+    Any,
+    SupportsIndex,
+    TypeVar,
+)
 
-from numpy import ndarray
-from numpy.typing import ArrayLike, DTypeLike, _SupportsArray, _NumberLike_co
+from numpy import floating, complexfloating, generic
+from numpy._typing import (
+    NDArray,
+    DTypeLike,
+    _DTypeLike,
+    _ArrayLikeFloat_co,
+    _ArrayLikeComplex_co,
+)
 
-# TODO: wait for support for recursive types
-_ArrayLikeNested = Sequence[Sequence[Any]]
-_ArrayLikeNumber = Union[
-    _NumberLike_co, Sequence[_NumberLike_co], ndarray, _SupportsArray, _ArrayLikeNested
-]
+_SCT = TypeVar("_SCT", bound=generic)
 
-__all__: List[str]
+__all__: list[str]
 
 @overload
 def linspace(
-    start: _ArrayLikeNumber,
-    stop: _ArrayLikeNumber,
+    start: _ArrayLikeFloat_co,
+    stop: _ArrayLikeFloat_co,
     num: SupportsIndex = ...,
     endpoint: bool = ...,
-    retstep: Literal[False] = ...,
+    retstep: L[False] = ...,
+    dtype: None = ...,
+    axis: SupportsIndex = ...,
+) -> NDArray[floating[Any]]: ...
+@overload
+def linspace(
+    start: _ArrayLikeComplex_co,
+    stop: _ArrayLikeComplex_co,
+    num: SupportsIndex = ...,
+    endpoint: bool = ...,
+    retstep: L[False] = ...,
+    dtype: None = ...,
+    axis: SupportsIndex = ...,
+) -> NDArray[complexfloating[Any, Any]]: ...
+@overload
+def linspace(
+    start: _ArrayLikeComplex_co,
+    stop: _ArrayLikeComplex_co,
+    num: SupportsIndex = ...,
+    endpoint: bool = ...,
+    retstep: L[False] = ...,
+    dtype: _DTypeLike[_SCT] = ...,
+    axis: SupportsIndex = ...,
+) -> NDArray[_SCT]: ...
+@overload
+def linspace(
+    start: _ArrayLikeComplex_co,
+    stop: _ArrayLikeComplex_co,
+    num: SupportsIndex = ...,
+    endpoint: bool = ...,
+    retstep: L[False] = ...,
     dtype: DTypeLike = ...,
     axis: SupportsIndex = ...,
-) -> ndarray: ...
+) -> NDArray[Any]: ...
 @overload
 def linspace(
-    start: _ArrayLikeNumber,
-    stop: _ArrayLikeNumber,
+    start: _ArrayLikeFloat_co,
+    stop: _ArrayLikeFloat_co,
     num: SupportsIndex = ...,
     endpoint: bool = ...,
-    retstep: Literal[True] = ...,
+    retstep: L[True] = ...,
+    dtype: None = ...,
+    axis: SupportsIndex = ...,
+) -> tuple[NDArray[floating[Any]], floating[Any]]: ...
+@overload
+def linspace(
+    start: _ArrayLikeComplex_co,
+    stop: _ArrayLikeComplex_co,
+    num: SupportsIndex = ...,
+    endpoint: bool = ...,
+    retstep: L[True] = ...,
+    dtype: None = ...,
+    axis: SupportsIndex = ...,
+) -> tuple[NDArray[complexfloating[Any, Any]], complexfloating[Any, Any]]: ...
+@overload
+def linspace(
+    start: _ArrayLikeComplex_co,
+    stop: _ArrayLikeComplex_co,
+    num: SupportsIndex = ...,
+    endpoint: bool = ...,
+    retstep: L[True] = ...,
+    dtype: _DTypeLike[_SCT] = ...,
+    axis: SupportsIndex = ...,
+) -> tuple[NDArray[_SCT], _SCT]: ...
+@overload
+def linspace(
+    start: _ArrayLikeComplex_co,
+    stop: _ArrayLikeComplex_co,
+    num: SupportsIndex = ...,
+    endpoint: bool = ...,
+    retstep: L[True] = ...,
     dtype: DTypeLike = ...,
     axis: SupportsIndex = ...,
-) -> Tuple[ndarray, Any]: ...
+) -> tuple[NDArray[Any], Any]: ...
 
+@overload
 def logspace(
-    start: _ArrayLikeNumber,
-    stop: _ArrayLikeNumber,
+    start: _ArrayLikeFloat_co,
+    stop: _ArrayLikeFloat_co,
     num: SupportsIndex = ...,
     endpoint: bool = ...,
-    base: _ArrayLikeNumber = ...,
+    base: _ArrayLikeFloat_co = ...,
+    dtype: None = ...,
+    axis: SupportsIndex = ...,
+) -> NDArray[floating[Any]]: ...
+@overload
+def logspace(
+    start: _ArrayLikeComplex_co,
+    stop: _ArrayLikeComplex_co,
+    num: SupportsIndex = ...,
+    endpoint: bool = ...,
+    base: _ArrayLikeComplex_co = ...,
+    dtype: None = ...,
+    axis: SupportsIndex = ...,
+) -> NDArray[complexfloating[Any, Any]]: ...
+@overload
+def logspace(
+    start: _ArrayLikeComplex_co,
+    stop: _ArrayLikeComplex_co,
+    num: SupportsIndex = ...,
+    endpoint: bool = ...,
+    base: _ArrayLikeComplex_co = ...,
+    dtype: _DTypeLike[_SCT] = ...,
+    axis: SupportsIndex = ...,
+) -> NDArray[_SCT]: ...
+@overload
+def logspace(
+    start: _ArrayLikeComplex_co,
+    stop: _ArrayLikeComplex_co,
+    num: SupportsIndex = ...,
+    endpoint: bool = ...,
+    base: _ArrayLikeComplex_co = ...,
     dtype: DTypeLike = ...,
     axis: SupportsIndex = ...,
-) -> ndarray: ...
+) -> NDArray[Any]: ...
 
+@overload
+def geomspace(
+    start: _ArrayLikeFloat_co,
+    stop: _ArrayLikeFloat_co,
+    num: SupportsIndex = ...,
+    endpoint: bool = ...,
+    dtype: None = ...,
+    axis: SupportsIndex = ...,
+) -> NDArray[floating[Any]]: ...
+@overload
+def geomspace(
+    start: _ArrayLikeComplex_co,
+    stop: _ArrayLikeComplex_co,
+    num: SupportsIndex = ...,
+    endpoint: bool = ...,
+    dtype: None = ...,
+    axis: SupportsIndex = ...,
+) -> NDArray[complexfloating[Any, Any]]: ...
+@overload
+def geomspace(
+    start: _ArrayLikeComplex_co,
+    stop: _ArrayLikeComplex_co,
+    num: SupportsIndex = ...,
+    endpoint: bool = ...,
+    dtype: _DTypeLike[_SCT] = ...,
+    axis: SupportsIndex = ...,
+) -> NDArray[_SCT]: ...
+@overload
 def geomspace(
-    start: _ArrayLikeNumber,
-    stop: _ArrayLikeNumber,
+    start: _ArrayLikeComplex_co,
+    stop: _ArrayLikeComplex_co,
     num: SupportsIndex = ...,
     endpoint: bool = ...,
     dtype: DTypeLike = ...,
     axis: SupportsIndex = ...,
-) -> ndarray: ...
+) -> NDArray[Any]: ...
 
 # Re-exported to `np.lib.function_base`
 def add_newdoc(
     place: str,
     obj: str,
-    doc: str | Tuple[str, str] | List[Tuple[str, str]],
+    doc: str | tuple[str, str] | list[tuple[str, str]],
     warn_on_python: bool = ...,
 ) -> None: ...
diff --git a/numpy/core/getlimits.py b/numpy/core/getlimits.py
index ab4a4d2be696..2c0f462cc49f 100644
--- a/numpy/core/getlimits.py
+++ b/numpy/core/getlimits.py
@@ -343,8 +343,9 @@ def _get_machar(ftype):
         return ma_like
     # Fall back to parameter discovery
     warnings.warn(
-        'Signature {} for {} does not match any known type: '
-        'falling back to type probe function'.format(key, ftype),
+        f'Signature {key} for {ftype} does not match any known type: '
+        'falling back to type probe function.\n'
+        'This warnings indicates broken support for the dtype!',
         UserWarning, stacklevel=2)
     return _discovered_machar(ftype)
 
@@ -371,6 +372,10 @@ class finfo:
     ----------
     bits : int
         The number of bits occupied by the type.
+    dtype : dtype
+        Returns the dtype for which `finfo` returns information. For complex
+        input, the returned dtype is the associated ``float*`` dtype for its
+        real and complex components.
     eps : float
         The difference between 1.0 and the next smallest representable float
         larger than 1.0. For example, for 64-bit binary floats in the IEEE-754
@@ -422,7 +427,8 @@ class finfo:
     Parameters
     ----------
     dtype : float, dtype, or instance
-        Kind of floating point data-type about which to get information.
+        Kind of floating point or complex floating point
+        data-type about which to get information.
 
     See Also
     --------
@@ -444,12 +450,25 @@ class finfo:
     fill the gap between 0 and ``smallest_normal``. However, subnormal numbers
     may have significantly reduced precision [2]_.
 
+    This function can also be used for complex data types as well. If used,
+    the output will be the same as the corresponding real float type
+    (e.g. numpy.finfo(numpy.csingle) is the same as numpy.finfo(numpy.single)).
+    However, the output is true for the real and imaginary components.
+
     References
     ----------
     .. [1] IEEE Standard for Floating-Point Arithmetic, IEEE Std 754-2008,
            pp.1-70, 2008, http://www.doi.org/10.1109/IEEESTD.2008.4610935
     .. [2] Wikipedia, "Denormal Numbers",
            https://en.wikipedia.org/wiki/Denormal_number
+
+    Examples
+    --------
+    >>> np.finfo(np.float64).dtype
+    dtype('float64')
+    >>> np.finfo(np.complex64).dtype
+    dtype('float32')
+
     """
 
     _finfo_cache = {}
@@ -602,6 +621,8 @@ class iinfo:
     ----------
     bits : int
         The number of bits occupied by the type.
+    dtype : dtype
+        Returns the dtype for which `iinfo` returns information.
     min : int
         The smallest integer expressible by the type.
     max : int
diff --git a/numpy/core/getlimits.pyi b/numpy/core/getlimits.pyi
index 66d0629954d2..da5e3c23ea72 100644
--- a/numpy/core/getlimits.pyi
+++ b/numpy/core/getlimits.pyi
@@ -1,8 +1,6 @@
-from typing import List
-
 from numpy import (
     finfo as finfo,
     iinfo as iinfo,
 )
 
-__all__: List[str]
+__all__: list[str]
diff --git a/numpy/core/include/numpy/experimental_dtype_api.h b/numpy/core/include/numpy/experimental_dtype_api.h
index 554c7fb6ce47..1fbd41981029 100644
--- a/numpy/core/include/numpy/experimental_dtype_api.h
+++ b/numpy/core/include/numpy/experimental_dtype_api.h
@@ -24,6 +24,12 @@
  *     Register a new loop for a ufunc.  This uses the `PyArrayMethod_Spec`
  *     which must be filled in (see in-line comments).
  *
+ * - PyUFunc_AddWrappingLoop:
+ *
+ *     Register a new loop which reuses an existing one, but modifies the
+ *     result dtypes.  Please search the internal NumPy docs for more info
+ *     at this point.  (Used for physical units dtype.)
+ *
  * - PyUFunc_AddPromoter:
  *
  *     Register a new promoter for a ufunc.  A promoter is a function stored
@@ -58,6 +64,16 @@
  *     also promote C; where "promotes" means implements the promotion.
  *     (There are some exceptions for abstract DTypes)
  *
+ * - PyArray_GetDefaultDescr:
+ *
+ *     Given a DType class, returns the default instance (descriptor).
+ *     This is an inline function checking for `singleton` first and only
+ *     calls the `default_descr` function if necessary.
+ *
+ * - PyArray_DoubleDType, etc.:
+ *
+ *     Aliases to the DType classes for the builtin NumPy DTypes.
+ *
  * WARNING
  * =======
  *
@@ -82,6 +98,15 @@
  * The new DType API is designed in a way to make it potentially useful for
  * alternative "array-like" implementations.  This will require careful
  * exposure of details and functions and is not part of this experimental API.
+ *
+ * Brief (incompatibility) changelog
+ * =================================
+ *
+ * 2. None (only additions).
+ * 3. New `npy_intp *view_offset` argument for `resolve_descriptors`.
+ *    This replaces the `NPY_CAST_IS_VIEW` flag.  It can be set to 0 if the
+ *    operation is a view, and is pre-initialized to `NPY_MIN_INTP` indicating
+ *    that the operation is not a view.
  */
 
 #ifndef NUMPY_CORE_INCLUDE_NUMPY_EXPERIMENTAL_DTYPE_API_H_
@@ -92,20 +117,41 @@
 
 
 /*
- * Just a hack so I don't forget importing as much myself, I spend way too
- * much time noticing it the first time around :).
+ * There must be a better way?! -- Oh well, this is experimental
+ * (my issue with it, is that I cannot undef those helpers).
  */
-static void
-__not_imported(void)
-{
-    printf("*****\nCritical error, dtype API not imported\n*****\n");
-}
-static void *__uninitialized_table[] = {
-        &__not_imported, &__not_imported, &__not_imported, &__not_imported,
-        &__not_imported, &__not_imported, &__not_imported, &__not_imported};
+#if defined(PY_ARRAY_UNIQUE_SYMBOL)
+    #define NPY_EXP_DTYPE_API_CONCAT_HELPER2(x, y) x ## y
+    #define NPY_EXP_DTYPE_API_CONCAT_HELPER(arg) NPY_EXP_DTYPE_API_CONCAT_HELPER2(arg, __experimental_dtype_api_table)
+    #define __experimental_dtype_api_table NPY_EXP_DTYPE_API_CONCAT_HELPER(PY_ARRAY_UNIQUE_SYMBOL)
+#else
+    #define __experimental_dtype_api_table __experimental_dtype_api_table
+#endif
+
+/* Support for correct multi-file projects: */
+#if defined(NO_IMPORT) || defined(NO_IMPORT_ARRAY)
+    extern void **__experimental_dtype_api_table;
+#else
+    /*
+     * Just a hack so I don't forget importing as much myself, I spend way too
+     * much time noticing it the first time around :).
+     */
+    static void
+    __not_imported(void)
+    {
+        printf("*****\nCritical error, dtype API not imported\n*****\n");
+    }
 
+    static void *__uninitialized_table[] = {
+            &__not_imported, &__not_imported, &__not_imported, &__not_imported,
+            &__not_imported, &__not_imported, &__not_imported, &__not_imported};
 
-static void **__experimental_dtype_api_table = __uninitialized_table;
+    #if defined(PY_ARRAY_UNIQUE_SYMBOL)
+        void **__experimental_dtype_api_table = __uninitialized_table;
+    #else
+        static void **__experimental_dtype_api_table = __uninitialized_table;
+    #endif
+#endif
 
 
 /*
@@ -132,7 +178,7 @@ typedef struct {
  * NOTE: Expected changes:
  *       * invert logic of floating point error flag
  *       * probably split runtime and general flags into two
- *       * should possibly not use an enum for typdef for more stable ABI?
+ *       * should possibly not use an enum for typedef for more stable ABI?
  */
 typedef enum {
     /* Flag for whether the GIL is required */
@@ -163,12 +209,12 @@ typedef struct {
     int nin, nout;
     NPY_CASTING casting;
     NPY_ARRAYMETHOD_FLAGS flags;
-    PyObject **dtypes;  /* array of DType class objects */
+    PyArray_DTypeMeta **dtypes;
     PyType_Slot *slots;
 } PyArrayMethod_Spec;
 
 
-typedef PyObject *_ufunc_addloop_fromspec_func(
+typedef int _ufunc_addloop_fromspec_func(
         PyObject *ufunc, PyArrayMethod_Spec *spec);
 /*
  * The main ufunc registration function.  This adds a new implementation/loop
@@ -178,9 +224,30 @@ typedef PyObject *_ufunc_addloop_fromspec_func(
     (*(_ufunc_addloop_fromspec_func *)(__experimental_dtype_api_table[0]))
 
 
+/* Please see the NumPy definitions in `array_method.h` for details on these */
+typedef int translate_given_descrs_func(int nin, int nout,
+        PyArray_DTypeMeta *wrapped_dtypes[],
+        PyArray_Descr *given_descrs[], PyArray_Descr *new_descrs[]);
+typedef int translate_loop_descrs_func(int nin, int nout,
+        PyArray_DTypeMeta *new_dtypes[], PyArray_Descr *given_descrs[],
+        PyArray_Descr *original_descrs[], PyArray_Descr *loop_descrs[]);
+
+typedef int _ufunc_wrapping_loop_func(PyObject *ufunc_obj,
+        PyArray_DTypeMeta *new_dtypes[], PyArray_DTypeMeta *wrapped_dtypes[],
+        translate_given_descrs_func *translate_given_descrs,
+        translate_loop_descrs_func *translate_loop_descrs);
+#define PyUFunc_AddWrappingLoop \
+    (*(_ufunc_wrapping_loop_func *)(__experimental_dtype_api_table[7]))
+
 /*
  * Type of the C promoter function, which must be wrapped into a
  * PyCapsule with name "numpy._ufunc_promoter".
+ *
+ * Note that currently the output dtypes are always NULL unless they are
+ * also part of the signature.  This is an implementation detail and could
+ * change in the future.  However, in general promoters should not have a
+ * need for output dtypes.
+ * (There are potential use-cases, these are currently unsupported.)
  */
 typedef int promoter_function(PyObject *ufunc,
         PyArray_DTypeMeta *op_dtypes[], PyArray_DTypeMeta *signature[],
@@ -200,16 +267,6 @@ typedef int _ufunc_addpromoter_func(
 #define PyUFunc_AddPromoter \
     (*(_ufunc_addpromoter_func *)(__experimental_dtype_api_table[1]))
 
-/*
- * In addition to the normal casting levels, NPY_CAST_IS_VIEW indicates
- * that no cast operation is necessary at all (although a copy usually will be)
- *
- * NOTE: The most likely modification here is to add an additional
- *       `view_offset` output to resolve_descriptors.  If set, it would
- *       indicate both that it is a view and what offset to use.  This means that
- *       e.g. `arr.imag` could be implemented by an ArrayMethod.
- */
-#define NPY_CAST_IS_VIEW _NPY_CAST_IS_VIEW
 
 /*
  * The resolve descriptors function, must be able to handle NULL values for
@@ -230,7 +287,8 @@ typedef NPY_CASTING (resolve_descriptors_function)(
         /* Input descriptors (instances).  Outputs may be NULL. */
         PyArray_Descr **given_descrs,
         /* Exact loop descriptors to use, must not hold references on error */
-        PyArray_Descr **loop_descrs);
+        PyArray_Descr **loop_descrs,
+        npy_intp *view_offset);
 
 /* NOT public yet: Signature needs adapting as external API. */
 #define _NPY_METH_get_loop 2
@@ -278,8 +336,9 @@ typedef int (PyArrayMethod_StridedLoop)(PyArrayMethod_Context *context,
 #define NPY_DT_default_descr 3
 #define NPY_DT_common_dtype 4
 #define NPY_DT_common_instance 5
-#define NPY_DT_setitem 6
-#define NPY_DT_getitem 7
+#define NPY_DT_ensure_canonical 6
+#define NPY_DT_setitem 7
+#define NPY_DT_getitem 8
 
 
 // TODO: These slots probably still need some thought, and/or a way to "grow"?
@@ -328,6 +387,65 @@ typedef PyArray_DTypeMeta *__promote_dtype_sequence(
     ((__promote_dtype_sequence *)(__experimental_dtype_api_table[5]))
 
 
+typedef PyArray_Descr *__get_default_descr(
+        PyArray_DTypeMeta *DType);
+#define _PyArray_GetDefaultDescr \
+    ((__get_default_descr *)(__experimental_dtype_api_table[6]))
+
+static NPY_INLINE PyArray_Descr *
+PyArray_GetDefaultDescr(PyArray_DTypeMeta *DType)
+{
+    if (DType->singleton != NULL) {
+        Py_INCREF(DType->singleton);
+        return DType->singleton;
+    }
+    return _PyArray_GetDefaultDescr(DType);
+}
+
+
+/*
+ * NumPy's builtin DTypes:
+ */
+#define PyArray_BoolDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[10])
+/* Integers */
+#define PyArray_ByteDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[11])
+#define PyArray_UByteDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[12])
+#define PyArray_ShortDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[13])
+#define PyArray_UShortDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[14])
+#define PyArray_IntDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[15])
+#define PyArray_UIntDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[16])
+#define PyArray_LongDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[17])
+#define PyArray_ULongDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[18])
+#define PyArray_LongLongDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[19])
+#define PyArray_ULongLongDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[20])
+/* Integer aliases */
+#define PyArray_Int8Type (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[21])
+#define PyArray_UInt8DType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[22])
+#define PyArray_Int16DType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[23])
+#define PyArray_UInt16DType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[24])
+#define PyArray_Int32DType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[25])
+#define PyArray_UInt32DType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[26])
+#define PyArray_Int64DType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[27])
+#define PyArray_UInt64DType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[28])
+#define PyArray_IntpDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[29])
+#define PyArray_UIntpDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[30])
+/* Floats */
+#define PyArray_HalfType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[31])
+#define PyArray_FloatDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[32])
+#define PyArray_DoubleDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[33])
+#define PyArray_LongDoubleDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[34])
+/* Complex */
+#define PyArray_CFloatDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[35])
+#define PyArray_CDoubleDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[36])
+#define PyArray_CLongDoubleDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[37])
+/* String/Bytes */
+#define PyArray_StringDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[38])
+#define PyArray_UnicodeDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[39])
+/* Datetime/Timedelta */
+#define PyArray_DatetimeDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[40])
+#define PyArray_TimedeltaDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[41])
+
+
 /*
  * ********************************
  *         Initialization
@@ -338,7 +456,9 @@ typedef PyArray_DTypeMeta *__promote_dtype_sequence(
  * runtime-check this.
  * You must call this function to use the symbols defined in this file.
  */
-#define __EXPERIMENTAL_DTYPE_VERSION 2
+#if !defined(NO_IMPORT) && !defined(NO_IMPORT_ARRAY)
+
+#define __EXPERIMENTAL_DTYPE_VERSION 5
 
 static int
 import_experimental_dtype_api(int version)
@@ -366,7 +486,7 @@ import_experimental_dtype_api(int version)
     if (api == NULL) {
         return -1;
     }
-    __experimental_dtype_api_table = PyCapsule_GetPointer(api,
+    __experimental_dtype_api_table = (void **)PyCapsule_GetPointer(api,
             "experimental_dtype_api_table");
     Py_DECREF(api);
 
@@ -377,4 +497,6 @@ import_experimental_dtype_api(int version)
     return 0;
 }
 
+#endif  /* !defined(NO_IMPORT) && !defined(NO_IMPORT_ARRAY) */
+
 #endif  /* NUMPY_CORE_INCLUDE_NUMPY_EXPERIMENTAL_DTYPE_API_H_ */
diff --git a/numpy/core/include/numpy/ndarrayobject.h b/numpy/core/include/numpy/ndarrayobject.h
index 2eb951486e82..aaaefd7defb3 100644
--- a/numpy/core/include/numpy/ndarrayobject.h
+++ b/numpy/core/include/numpy/ndarrayobject.h
@@ -152,19 +152,16 @@ extern "C" {
                                             (k)*PyArray_STRIDES(obj)[2] + \
                                             (l)*PyArray_STRIDES(obj)[3]))
 
-/* Move to arrayobject.c once PyArray_XDECREF_ERR is removed */
 static NPY_INLINE void
 PyArray_DiscardWritebackIfCopy(PyArrayObject *arr)
 {
     PyArrayObject_fields *fa = (PyArrayObject_fields *)arr;
     if (fa && fa->base) {
-        if ((fa->flags & NPY_ARRAY_UPDATEIFCOPY) ||
-                (fa->flags & NPY_ARRAY_WRITEBACKIFCOPY)) {
+        if (fa->flags & NPY_ARRAY_WRITEBACKIFCOPY) {
             PyArray_ENABLEFLAGS((PyArrayObject*)fa->base, NPY_ARRAY_WRITEABLE);
             Py_DECREF(fa->base);
             fa->base = NULL;
             PyArray_CLEARFLAGS(arr, NPY_ARRAY_WRITEBACKIFCOPY);
-            PyArray_CLEARFLAGS(arr, NPY_ARRAY_UPDATEIFCOPY);
         }
     }
 }
@@ -246,20 +243,6 @@ NPY_TITLE_KEY_check(PyObject *key, PyObject *value)
 #define DEPRECATE(msg) PyErr_WarnEx(PyExc_DeprecationWarning,msg,1)
 #define DEPRECATE_FUTUREWARNING(msg) PyErr_WarnEx(PyExc_FutureWarning,msg,1)
 
-#if !defined(NPY_NO_DEPRECATED_API) || \
-    (NPY_NO_DEPRECATED_API < NPY_1_14_API_VERSION)
-static NPY_INLINE void
-PyArray_XDECREF_ERR(PyArrayObject *arr)
-{
-    /* 2017-Nov-10 1.14 */
-    DEPRECATE("PyArray_XDECREF_ERR is deprecated, call "
-        "PyArray_DiscardWritebackIfCopy then Py_XDECREF instead");
-    PyArray_DiscardWritebackIfCopy(arr);
-    Py_XDECREF(arr);
-}
-#endif
-
-
 #ifdef __cplusplus
 }
 #endif
diff --git a/numpy/core/include/numpy/ndarraytypes.h b/numpy/core/include/numpy/ndarraytypes.h
index 6240adc0c7f1..e894b08f6927 100644
--- a/numpy/core/include/numpy/ndarraytypes.h
+++ b/numpy/core/include/numpy/ndarraytypes.h
@@ -87,7 +87,7 @@ enum NPY_TYPES {    NPY_BOOL=0,
                     /* The number of types not including the new 1.6 types */
                     NPY_NTYPES_ABI_COMPATIBLE=21
 };
-#ifdef _MSC_VER
+#if defined(_MSC_VER) && !defined(__clang__)
 #pragma deprecated(NPY_CHAR)
 #endif
 
@@ -221,13 +221,6 @@ typedef enum {
         NPY_SAME_KIND_CASTING=3,
         /* Allow any casts */
         NPY_UNSAFE_CASTING=4,
-        /*
-         * Flag to allow signalling that a cast is a view, this flag is not
-         * valid when requesting a cast of specific safety.
-         * _NPY_CAST_IS_VIEW|NPY_EQUIV_CASTING means the same as NPY_NO_CASTING.
-         */
-        // TODO-DTYPES: Needs to be documented.
-        _NPY_CAST_IS_VIEW = 1 << 16,
 } NPY_CASTING;
 
 typedef enum {
@@ -841,11 +834,9 @@ typedef int (PyArray_FinalizeFunc)(PyArrayObject *, PyObject *);
  * 1-d array is C_CONTIGUOUS it is also F_CONTIGUOUS. Arrays with
  * more then one dimension can be C_CONTIGUOUS and F_CONTIGUOUS
  * at the same time if they have either zero or one element.
- * If NPY_RELAXED_STRIDES_CHECKING is set, a higher dimensional
- * array is always C_CONTIGUOUS and F_CONTIGUOUS if it has zero elements
- * and the array is contiguous if ndarray.squeeze() is contiguous.
- * I.e. dimensions for which `ndarray.shape[dimension] == 1` are
- * ignored.
+ * A higher dimensional array always has the same contiguity flags as
+ * `array.squeeze()`; dimensions with `array.shape[dimension] == 1` are
+ * effectively ignored when checking for contiguity.
  */
 
 /*
@@ -881,17 +872,6 @@ typedef int (PyArray_FinalizeFunc)(PyArrayObject *, PyObject *);
  */
 #define NPY_ARRAY_ENSUREARRAY     0x0040
 
-#if defined(NPY_INTERNAL_BUILD) && NPY_INTERNAL_BUILD
-    /*
-     * Dual use of the ENSUREARRAY flag, to indicate that this was converted
-     * from a python float, int, or complex.
-     * An array using this flag must be a temporary array that can never
-     * leave the C internals of NumPy.  Even if it does, ENSUREARRAY is
-     * absolutely safe to abuse, since it already is a base class array :).
-     */
-    #define _NPY_ARRAY_WAS_PYSCALAR   0x0040
-#endif  /* NPY_INTERNAL_BUILD */
-
 /*
  * Make sure that the strides are in units of the element size Needed
  * for some operations with record-arrays.
@@ -934,7 +914,6 @@ typedef int (PyArray_FinalizeFunc)(PyArrayObject *, PyObject *);
  * This flag may be requested in constructor functions.
  * This flag may be tested for in PyArray_FLAGS(arr).
  */
-#define NPY_ARRAY_UPDATEIFCOPY    0x1000 /* Deprecated in 1.14 */
 #define NPY_ARRAY_WRITEBACKIFCOPY 0x2000
 
 /*
@@ -965,14 +944,12 @@ typedef int (PyArray_FinalizeFunc)(PyArrayObject *, PyObject *);
 #define NPY_ARRAY_DEFAULT      (NPY_ARRAY_CARRAY)
 #define NPY_ARRAY_IN_ARRAY     (NPY_ARRAY_CARRAY_RO)
 #define NPY_ARRAY_OUT_ARRAY    (NPY_ARRAY_CARRAY)
-#define NPY_ARRAY_INOUT_ARRAY  (NPY_ARRAY_CARRAY | \
-                                NPY_ARRAY_UPDATEIFCOPY)
+#define NPY_ARRAY_INOUT_ARRAY  (NPY_ARRAY_CARRAY)
 #define NPY_ARRAY_INOUT_ARRAY2 (NPY_ARRAY_CARRAY | \
                                 NPY_ARRAY_WRITEBACKIFCOPY)
 #define NPY_ARRAY_IN_FARRAY    (NPY_ARRAY_FARRAY_RO)
 #define NPY_ARRAY_OUT_FARRAY   (NPY_ARRAY_FARRAY)
-#define NPY_ARRAY_INOUT_FARRAY (NPY_ARRAY_FARRAY | \
-                                NPY_ARRAY_UPDATEIFCOPY)
+#define NPY_ARRAY_INOUT_FARRAY (NPY_ARRAY_FARRAY)
 #define NPY_ARRAY_INOUT_FARRAY2 (NPY_ARRAY_FARRAY | \
                                 NPY_ARRAY_WRITEBACKIFCOPY)
 
@@ -1392,7 +1369,10 @@ typedef struct {
         int                   nd_fancy;
         npy_intp              fancy_dims[NPY_MAXDIMS];
 
-        /* Whether the iterator (any of the iterators) requires API */
+        /*
+         * Whether the iterator (any of the iterators) requires API.  This is
+         * unused by NumPy itself; ArrayMethod flags are more precise.
+         */
         int                   needs_api;
 
         /*
@@ -1898,7 +1878,7 @@ typedef void (PyDataMem_EventHookFunc)(void *inp, void *outp, size_t size,
     /*
      * The Structures defined in this block are currently considered
      * private API and may change without warning!
-     * Part of this (at least the size) is exepcted to be public API without
+     * Part of this (at least the size) is expected to be public API without
      * further modifications.
      */
     /* TODO: Make this definition public in the API, as soon as its settled */
diff --git a/numpy/core/include/numpy/noprefix.h b/numpy/core/include/numpy/noprefix.h
index 2c0ce1420e2c..cea5b0d46783 100644
--- a/numpy/core/include/numpy/noprefix.h
+++ b/numpy/core/include/numpy/noprefix.h
@@ -165,7 +165,6 @@
 #define ALIGNED            NPY_ALIGNED
 #define NOTSWAPPED         NPY_NOTSWAPPED
 #define WRITEABLE          NPY_WRITEABLE
-#define UPDATEIFCOPY       NPY_UPDATEIFCOPY
 #define WRITEBACKIFCOPY    NPY_ARRAY_WRITEBACKIFCOPY
 #define ARR_HAS_DESCR      NPY_ARR_HAS_DESCR
 #define BEHAVED            NPY_BEHAVED
diff --git a/numpy/core/include/numpy/npy_1_7_deprecated_api.h b/numpy/core/include/numpy/npy_1_7_deprecated_api.h
index 4fd4015a991a..6455d40d223b 100644
--- a/numpy/core/include/numpy/npy_1_7_deprecated_api.h
+++ b/numpy/core/include/numpy/npy_1_7_deprecated_api.h
@@ -48,7 +48,6 @@
 #define NPY_ALIGNED        NPY_ARRAY_ALIGNED
 #define NPY_NOTSWAPPED     NPY_ARRAY_NOTSWAPPED
 #define NPY_WRITEABLE      NPY_ARRAY_WRITEABLE
-#define NPY_UPDATEIFCOPY   NPY_ARRAY_UPDATEIFCOPY
 #define NPY_BEHAVED        NPY_ARRAY_BEHAVED
 #define NPY_BEHAVED_NS     NPY_ARRAY_BEHAVED_NS
 #define NPY_CARRAY         NPY_ARRAY_CARRAY
diff --git a/numpy/core/include/numpy/npy_3kcompat.h b/numpy/core/include/numpy/npy_3kcompat.h
index 22c103e93da9..11cc477655a4 100644
--- a/numpy/core/include/numpy/npy_3kcompat.h
+++ b/numpy/core/include/numpy/npy_3kcompat.h
@@ -1,6 +1,8 @@
 /*
  * This is a convenience header file providing compatibility utilities
- * for supporting Python 2 and Python 3 in the same code base.
+ * for supporting different minor versions of Python 3.
+ * It was originally used to support the transition from Python 2,
+ * hence the "3k" naming.
  *
  * If you want to use this for your own projects, it's recommended to make a
  * copy of it. Although the stuff below is unlikely to change, we don't provide
diff --git a/numpy/core/include/numpy/npy_common.h b/numpy/core/include/numpy/npy_common.h
index 88794ca07e36..2bcc45e4f677 100644
--- a/numpy/core/include/numpy/npy_common.h
+++ b/numpy/core/include/numpy/npy_common.h
@@ -131,9 +131,10 @@
 #endif
 #endif
 
-#if defined(_MSC_VER)
-        #define NPY_INLINE __inline
-#elif defined(__GNUC__)
+#if defined(_MSC_VER) && !defined(__clang__)
+    #define NPY_INLINE __inline
+/* clang included here to handle clang-cl on Windows */
+#elif defined(__GNUC__) || defined(__clang__)
     #if defined(__STRICT_ANSI__)
          #define NPY_INLINE __inline__
     #else
@@ -180,12 +181,6 @@
     defined(__MINGW32__) || defined(__MINGW64__)
     #include 
 
-/* mingw based on 3.4.5 has lseek but not ftell/fseek */
-#if defined(__MINGW32__) || defined(__MINGW64__)
-extern int __cdecl _fseeki64(FILE *, long long, int);
-extern long long __cdecl _ftelli64(FILE *);
-#endif
-
     #define npy_fseek _fseeki64
     #define npy_ftell _ftelli64
     #define npy_lseek _lseeki64
diff --git a/numpy/core/include/numpy/npy_math.h b/numpy/core/include/numpy/npy_math.h
index bead0dc14064..900508662e47 100644
--- a/numpy/core/include/numpy/npy_math.h
+++ b/numpy/core/include/numpy/npy_math.h
@@ -1,16 +1,9 @@
 #ifndef NUMPY_CORE_INCLUDE_NUMPY_NPY_MATH_H_
 #define NUMPY_CORE_INCLUDE_NUMPY_NPY_MATH_H_
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 #include 
 
 #include 
-#ifdef __SUNPRO_CC
-#include 
-#endif
 
 /* By adding static inline specifiers to npy_math function definitions when
    appropriate, compiler is given the opportunity to optimize */
@@ -21,6 +14,10 @@ extern "C" {
 #endif
 
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
  * NAN and INFINITY like macros (same behavior as glibc for NAN, same as C99
  * for INFINITY)
@@ -162,49 +159,48 @@ NPY_INPLACE uint8_t npy_popcountl(npy_long a);
 NPY_INPLACE uint8_t npy_popcountll(npy_longlong a);
 
 /*
- * C99 double math funcs
+ * C99 double math funcs that need fixups or are blocklist-able
  */
 NPY_INPLACE double npy_sin(double x);
 NPY_INPLACE double npy_cos(double x);
 NPY_INPLACE double npy_tan(double x);
-NPY_INPLACE double npy_sinh(double x);
-NPY_INPLACE double npy_cosh(double x);
-NPY_INPLACE double npy_tanh(double x);
-
-NPY_INPLACE double npy_asin(double x);
-NPY_INPLACE double npy_acos(double x);
-NPY_INPLACE double npy_atan(double x);
-
-NPY_INPLACE double npy_log(double x);
-NPY_INPLACE double npy_log10(double x);
-NPY_INPLACE double npy_exp(double x);
-NPY_INPLACE double npy_sqrt(double x);
-NPY_INPLACE double npy_cbrt(double x);
-
-NPY_INPLACE double npy_fabs(double x);
-NPY_INPLACE double npy_ceil(double x);
-NPY_INPLACE double npy_fmod(double x, double y);
-NPY_INPLACE double npy_floor(double x);
-
-NPY_INPLACE double npy_expm1(double x);
-NPY_INPLACE double npy_log1p(double x);
 NPY_INPLACE double npy_hypot(double x, double y);
-NPY_INPLACE double npy_acosh(double x);
-NPY_INPLACE double npy_asinh(double xx);
-NPY_INPLACE double npy_atanh(double x);
-NPY_INPLACE double npy_rint(double x);
-NPY_INPLACE double npy_trunc(double x);
-NPY_INPLACE double npy_exp2(double x);
 NPY_INPLACE double npy_log2(double x);
-
 NPY_INPLACE double npy_atan2(double x, double y);
-NPY_INPLACE double npy_pow(double x, double y);
-NPY_INPLACE double npy_modf(double x, double* y);
-NPY_INPLACE double npy_frexp(double x, int* y);
-NPY_INPLACE double npy_ldexp(double n, int y);
 
-NPY_INPLACE double npy_copysign(double x, double y);
+/* Mandatory C99 double math funcs, no blocklisting or fixups */
+/* defined for legacy reasons, should be deprecated at some point */
+#define npy_sinh sinh
+#define npy_cosh cosh
+#define npy_tanh tanh
+#define npy_asin asin
+#define npy_acos acos
+#define npy_atan atan
+#define npy_log log
+#define npy_log10 log10
+#define npy_cbrt cbrt
+#define npy_fabs fabs
+#define npy_ceil ceil
+#define npy_fmod fmod
+#define npy_floor floor
+#define npy_expm1 expm1
+#define npy_log1p log1p
+#define npy_acosh acosh
+#define npy_asinh asinh
+#define npy_atanh atanh
+#define npy_rint rint
+#define npy_trunc trunc
+#define npy_exp2 exp2
+#define npy_frexp frexp
+#define npy_ldexp ldexp
+#define npy_copysign copysign
+#define npy_exp exp
+#define npy_sqrt sqrt
+#define npy_pow pow
+#define npy_modf modf
+
 double npy_nextafter(double x, double y);
+
 double npy_spacing(double x);
 
 /*
@@ -219,11 +215,7 @@ double npy_spacing(double x);
     #ifndef NPY_HAVE_DECL_ISNAN
         #define npy_isnan(x) ((x) != (x))
     #else
-        #if defined(_MSC_VER) && (_MSC_VER < 1900)
-            #define npy_isnan(x) _isnan((x))
-        #else
-            #define npy_isnan(x) isnan(x)
-        #endif
+        #define npy_isnan(x) isnan(x)
     #endif
 #endif
 
@@ -250,11 +242,7 @@ double npy_spacing(double x);
     #ifndef NPY_HAVE_DECL_ISINF
         #define npy_isinf(x) (!npy_isfinite(x) && !npy_isnan(x))
     #else
-        #if defined(_MSC_VER) && (_MSC_VER < 1900)
-            #define npy_isinf(x) (!_finite((x)) && !_isnan((x)))
-        #else
-            #define npy_isinf(x) isinf((x))
-        #endif
+        #define npy_isinf(x) isinf((x))
     #endif
 #endif
 
@@ -271,88 +259,91 @@ double npy_spacing(double x);
 #endif
 
 /*
- * float C99 math functions
+ * float C99 math funcs that need fixups or are blocklist-able
  */
 NPY_INPLACE float npy_sinf(float x);
 NPY_INPLACE float npy_cosf(float x);
 NPY_INPLACE float npy_tanf(float x);
-NPY_INPLACE float npy_sinhf(float x);
-NPY_INPLACE float npy_coshf(float x);
-NPY_INPLACE float npy_tanhf(float x);
-NPY_INPLACE float npy_fabsf(float x);
-NPY_INPLACE float npy_floorf(float x);
-NPY_INPLACE float npy_ceilf(float x);
-NPY_INPLACE float npy_rintf(float x);
-NPY_INPLACE float npy_truncf(float x);
-NPY_INPLACE float npy_sqrtf(float x);
-NPY_INPLACE float npy_cbrtf(float x);
-NPY_INPLACE float npy_log10f(float x);
-NPY_INPLACE float npy_logf(float x);
 NPY_INPLACE float npy_expf(float x);
-NPY_INPLACE float npy_expm1f(float x);
-NPY_INPLACE float npy_asinf(float x);
-NPY_INPLACE float npy_acosf(float x);
-NPY_INPLACE float npy_atanf(float x);
-NPY_INPLACE float npy_asinhf(float x);
-NPY_INPLACE float npy_acoshf(float x);
-NPY_INPLACE float npy_atanhf(float x);
-NPY_INPLACE float npy_log1pf(float x);
-NPY_INPLACE float npy_exp2f(float x);
+NPY_INPLACE float npy_sqrtf(float x);
+NPY_INPLACE float npy_hypotf(float x, float y);
 NPY_INPLACE float npy_log2f(float x);
-
 NPY_INPLACE float npy_atan2f(float x, float y);
-NPY_INPLACE float npy_hypotf(float x, float y);
 NPY_INPLACE float npy_powf(float x, float y);
-NPY_INPLACE float npy_fmodf(float x, float y);
-
 NPY_INPLACE float npy_modff(float x, float* y);
-NPY_INPLACE float npy_frexpf(float x, int* y);
-NPY_INPLACE float npy_ldexpf(float x, int y);
 
-NPY_INPLACE float npy_copysignf(float x, float y);
+/* Mandatory C99 float math funcs, no blocklisting or fixups */
+/* defined for legacy reasons, should be deprecated at some point */
+
+#define npy_sinhf sinhf
+#define npy_coshf coshf
+#define npy_tanhf tanhf
+#define npy_asinf asinf
+#define npy_acosf acosf
+#define npy_atanf atanf
+#define npy_logf logf
+#define npy_log10f log10f
+#define npy_cbrtf cbrtf
+#define npy_fabsf fabsf
+#define npy_ceilf ceilf
+#define npy_fmodf fmodf
+#define npy_floorf floorf
+#define npy_expm1f expm1f
+#define npy_log1pf log1pf
+#define npy_asinhf asinhf
+#define npy_acoshf acoshf
+#define npy_atanhf atanhf
+#define npy_rintf rintf
+#define npy_truncf truncf
+#define npy_exp2f exp2f
+#define npy_frexpf frexpf
+#define npy_ldexpf ldexpf
+#define npy_copysignf copysignf
+
 float npy_nextafterf(float x, float y);
 float npy_spacingf(float x);
 
 /*
- * long double C99 math functions
+ * long double C99 double math funcs that need fixups or are blocklist-able
  */
 NPY_INPLACE npy_longdouble npy_sinl(npy_longdouble x);
 NPY_INPLACE npy_longdouble npy_cosl(npy_longdouble x);
 NPY_INPLACE npy_longdouble npy_tanl(npy_longdouble x);
-NPY_INPLACE npy_longdouble npy_sinhl(npy_longdouble x);
-NPY_INPLACE npy_longdouble npy_coshl(npy_longdouble x);
-NPY_INPLACE npy_longdouble npy_tanhl(npy_longdouble x);
-NPY_INPLACE npy_longdouble npy_fabsl(npy_longdouble x);
-NPY_INPLACE npy_longdouble npy_floorl(npy_longdouble x);
-NPY_INPLACE npy_longdouble npy_ceill(npy_longdouble x);
-NPY_INPLACE npy_longdouble npy_rintl(npy_longdouble x);
-NPY_INPLACE npy_longdouble npy_truncl(npy_longdouble x);
-NPY_INPLACE npy_longdouble npy_sqrtl(npy_longdouble x);
-NPY_INPLACE npy_longdouble npy_cbrtl(npy_longdouble x);
-NPY_INPLACE npy_longdouble npy_log10l(npy_longdouble x);
-NPY_INPLACE npy_longdouble npy_logl(npy_longdouble x);
 NPY_INPLACE npy_longdouble npy_expl(npy_longdouble x);
-NPY_INPLACE npy_longdouble npy_expm1l(npy_longdouble x);
-NPY_INPLACE npy_longdouble npy_asinl(npy_longdouble x);
-NPY_INPLACE npy_longdouble npy_acosl(npy_longdouble x);
-NPY_INPLACE npy_longdouble npy_atanl(npy_longdouble x);
-NPY_INPLACE npy_longdouble npy_asinhl(npy_longdouble x);
-NPY_INPLACE npy_longdouble npy_acoshl(npy_longdouble x);
-NPY_INPLACE npy_longdouble npy_atanhl(npy_longdouble x);
-NPY_INPLACE npy_longdouble npy_log1pl(npy_longdouble x);
-NPY_INPLACE npy_longdouble npy_exp2l(npy_longdouble x);
+NPY_INPLACE npy_longdouble npy_sqrtl(npy_longdouble x);
+NPY_INPLACE npy_longdouble npy_hypotl(npy_longdouble x, npy_longdouble y);
 NPY_INPLACE npy_longdouble npy_log2l(npy_longdouble x);
-
 NPY_INPLACE npy_longdouble npy_atan2l(npy_longdouble x, npy_longdouble y);
-NPY_INPLACE npy_longdouble npy_hypotl(npy_longdouble x, npy_longdouble y);
 NPY_INPLACE npy_longdouble npy_powl(npy_longdouble x, npy_longdouble y);
-NPY_INPLACE npy_longdouble npy_fmodl(npy_longdouble x, npy_longdouble y);
-
 NPY_INPLACE npy_longdouble npy_modfl(npy_longdouble x, npy_longdouble* y);
-NPY_INPLACE npy_longdouble npy_frexpl(npy_longdouble x, int* y);
-NPY_INPLACE npy_longdouble npy_ldexpl(npy_longdouble x, int y);
 
-NPY_INPLACE npy_longdouble npy_copysignl(npy_longdouble x, npy_longdouble y);
+/* Mandatory C99 double math funcs, no blocklisting or fixups */
+/* defined for legacy reasons, should be deprecated at some point */
+#define npy_sinhl sinhl
+#define npy_coshl coshl
+#define npy_tanhl tanhl
+#define npy_fabsl fabsl
+#define npy_floorl floorl
+#define npy_ceill ceill
+#define npy_rintl rintl
+#define npy_truncl truncl
+#define npy_cbrtl cbrtl
+#define npy_log10l log10l
+#define npy_logl logl
+#define npy_expm1l expm1l
+#define npy_asinl asinl
+#define npy_acosl acosl
+#define npy_atanl atanl
+#define npy_asinhl asinhl
+#define npy_acoshl acoshl
+#define npy_atanhl atanhl
+#define npy_log1pl log1pl
+#define npy_exp2l exp2l
+#define npy_fmodl fmodl
+#define npy_frexpl frexpl
+#define npy_ldexpl ldexpl
+#define npy_copysignl copysignl
+
 npy_longdouble npy_nextafterl(npy_longdouble x, npy_longdouble y);
 npy_longdouble npy_spacingl(npy_longdouble x);
 
diff --git a/numpy/core/include/numpy/npy_os.h b/numpy/core/include/numpy/npy_os.h
index efa0e4012f91..6d8317d0667c 100644
--- a/numpy/core/include/numpy/npy_os.h
+++ b/numpy/core/include/numpy/npy_os.h
@@ -21,8 +21,14 @@
     #define NPY_OS_CYGWIN
 #elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
     #define NPY_OS_WIN32
+#elif defined(_WIN64) || defined(__WIN64__) || defined(WIN64)
+    #define NPY_OS_WIN64
+#elif defined(__MINGW32__) || defined(__MINGW64__)
+    #define NPY_OS_MINGW
 #elif defined(__APPLE__)
     #define NPY_OS_DARWIN
+#elif defined(__HAIKU__)
+    #define NPY_OS_HAIKU
 #else
     #define NPY_OS_UNKNOWN
 #endif
diff --git a/numpy/core/include/numpy/numpyconfig.h b/numpy/core/include/numpy/numpyconfig.h
index f761555b90f5..4b5209837317 100644
--- a/numpy/core/include/numpy/numpyconfig.h
+++ b/numpy/core/include/numpy/numpyconfig.h
@@ -6,7 +6,13 @@
 /*
  * On Mac OS X, because there is only one configuration stage for all the archs
  * in universal builds, any macro which depends on the arch needs to be
- * hardcoded
+ * hardcoded.
+ *
+ * Note that distutils/pip will attempt a universal2 build when Python itself
+ * is built as universal2, hence this hardcoding is needed even if we do not
+ * support universal2 wheels anymore (see gh-22796).
+ * This code block can be removed after we have dropped the setup.py based
+ * build completely.
  */
 #ifdef __APPLE__
     #undef NPY_SIZEOF_LONG
@@ -22,18 +28,33 @@
 
     #undef NPY_SIZEOF_LONGDOUBLE
     #undef NPY_SIZEOF_COMPLEX_LONGDOUBLE
+    #ifdef HAVE_LDOUBLE_IEEE_DOUBLE_LE
+      #undef HAVE_LDOUBLE_IEEE_DOUBLE_LE
+    #endif
+    #ifdef HAVE_LDOUBLE_INTEL_EXTENDED_16_BYTES_LE
+      #undef HAVE_LDOUBLE_INTEL_EXTENDED_16_BYTES_LE
+    #endif
 
-    #ifdef __x86_64
-        #define NPY_SIZEOF_LONGDOUBLE         16
-        #define NPY_SIZEOF_COMPLEX_LONGDOUBLE 32
-    #elif defined(__arm64__)
+    #if defined(__arm64__)
         #define NPY_SIZEOF_LONGDOUBLE         8
         #define NPY_SIZEOF_COMPLEX_LONGDOUBLE 16
+        #define HAVE_LDOUBLE_IEEE_DOUBLE_LE 1
+    #elif defined(__x86_64)
+        #define NPY_SIZEOF_LONGDOUBLE         16
+        #define NPY_SIZEOF_COMPLEX_LONGDOUBLE 32
+        #define HAVE_LDOUBLE_INTEL_EXTENDED_16_BYTES_LE 1
+    #elif defined (__i386)
+        #define NPY_SIZEOF_LONGDOUBLE         12
+        #define NPY_SIZEOF_COMPLEX_LONGDOUBLE 24
+    #elif defined(__ppc__) || defined (__ppc64__)
+        #define NPY_SIZEOF_LONGDOUBLE         16
+        #define NPY_SIZEOF_COMPLEX_LONGDOUBLE 32
     #else
         #error "unknown architecture"
     #endif
 #endif
 
+
 /**
  * To help with the NPY_NO_DEPRECATED_API macro, we include API version
  * numbers for specific versions of NumPy. To exclude all API that was
@@ -57,5 +78,7 @@
 #define NPY_1_20_API_VERSION 0x0000000e
 #define NPY_1_21_API_VERSION 0x0000000e
 #define NPY_1_22_API_VERSION 0x0000000f
+#define NPY_1_23_API_VERSION 0x00000010
+#define NPY_1_24_API_VERSION 0x00000010
 
 #endif  /* NUMPY_CORE_INCLUDE_NUMPY_NPY_NUMPYCONFIG_H_ */
diff --git a/numpy/core/include/numpy/random/distributions.h b/numpy/core/include/numpy/random/distributions.h
index dacf7782909f..78bd06ff5250 100644
--- a/numpy/core/include/numpy/random/distributions.h
+++ b/numpy/core/include/numpy/random/distributions.h
@@ -28,7 +28,7 @@ extern "C" {
 #define RAND_INT_MAX INT64_MAX
 #endif
 
-#if defined(_MSC_VER) || defined(__CYGWIN__)
+#ifdef _MSC_VER
 #define DECLDIR __declspec(dllexport)
 #else
 #define DECLDIR extern
diff --git a/numpy/core/include/numpy/ufuncobject.h b/numpy/core/include/numpy/ufuncobject.h
index 1d7050bbe5a3..bb0633100795 100644
--- a/numpy/core/include/numpy/ufuncobject.h
+++ b/numpy/core/include/numpy/ufuncobject.h
@@ -173,7 +173,11 @@ typedef struct _tagPyUFuncObject {
          * but this was never implemented. (This is also why the above
          * selector is called the "legacy" selector.)
          */
-        vectorcallfunc vectorcall;
+        #ifndef Py_LIMITED_API
+            vectorcallfunc vectorcall;
+        #else
+            void *vectorcall;
+        #endif
 
         /* Was previously the `PyUFunc_MaskedInnerLoopSelectionFunc` */
         void *_always_null_previously_masked_innerloop_selector;
diff --git a/numpy/core/include/numpy/utils.h b/numpy/core/include/numpy/utils.h
index e2b57f9e508d..97f06092e540 100644
--- a/numpy/core/include/numpy/utils.h
+++ b/numpy/core/include/numpy/utils.h
@@ -24,7 +24,7 @@
 /* Use this to tag a variable as not used. It will remove unused variable
  * warning on support platforms (see __COM_NPY_UNUSED) and mangle the variable
  * to avoid accidental use */
-#define NPY_UNUSED(x) (__NPY_UNUSED_TAGGED ## x) __COMP_NPY_UNUSED
+#define NPY_UNUSED(x) __NPY_UNUSED_TAGGED ## x __COMP_NPY_UNUSED
 #define NPY_EXPAND(x) x
 
 #define NPY_STRINGIFY(x) #x
diff --git a/numpy/core/memmap.pyi b/numpy/core/memmap.pyi
index ba595bf1ef64..03c6b772dcd5 100644
--- a/numpy/core/memmap.pyi
+++ b/numpy/core/memmap.pyi
@@ -1,5 +1,3 @@
-from typing import List
-
 from numpy import memmap as memmap
 
-__all__: List[str]
+__all__: list[str]
diff --git a/numpy/core/multiarray.py b/numpy/core/multiarray.py
index f88d75978697..31b77978392c 100644
--- a/numpy/core/multiarray.py
+++ b/numpy/core/multiarray.py
@@ -14,17 +14,18 @@
 # do not change them. issue gh-15518
 # _get_ndarray_c_version is semi-public, on purpose not added to __all__
 from ._multiarray_umath import (
-    _fastCopyAndTranspose, _flagdict, _from_dlpack, _insert, _reconstruct,
+    fastCopyAndTranspose, _flagdict, from_dlpack, _insert, _reconstruct,
     _vec_string, _ARRAY_API, _monotonicity, _get_ndarray_c_version,
-    _set_madvise_hugepage,
+    _get_madvise_hugepage, _set_madvise_hugepage,
+    _get_promotion_state, _set_promotion_state,
     )
 
 __all__ = [
     '_ARRAY_API', 'ALLOW_THREADS', 'BUFSIZE', 'CLIP', 'DATETIMEUNITS',
     'ITEM_HASOBJECT', 'ITEM_IS_POINTER', 'LIST_PICKLE', 'MAXDIMS',
     'MAY_SHARE_BOUNDS', 'MAY_SHARE_EXACT', 'NEEDS_INIT', 'NEEDS_PYAPI',
-    'RAISE', 'USE_GETITEM', 'USE_SETITEM', 'WRAP', '_fastCopyAndTranspose',
-    '_flagdict', '_from_dlpack', '_insert', '_reconstruct', '_vec_string',
+    'RAISE', 'USE_GETITEM', 'USE_SETITEM', 'WRAP',
+    '_flagdict', 'from_dlpack', '_insert', '_reconstruct', '_vec_string',
     '_monotonicity', 'add_docstring', 'arange', 'array', 'asarray',
     'asanyarray', 'ascontiguousarray', 'asfortranarray', 'bincount',
     'broadcast', 'busday_count', 'busday_offset', 'busdaycalendar', 'can_cast',
@@ -40,14 +41,15 @@
     'ravel_multi_index', 'result_type', 'scalar', 'set_datetimeparse_function',
     'set_legacy_print_mode', 'set_numeric_ops', 'set_string_function',
     'set_typeDict', 'shares_memory', 'tracemalloc_domain', 'typeinfo',
-    'unpackbits', 'unravel_index', 'vdot', 'where', 'zeros']
+    'unpackbits', 'unravel_index', 'vdot', 'where', 'zeros',
+    '_get_promotion_state', '_set_promotion_state']
 
 # For backward compatibility, make sure pickle imports these functions from here
 _reconstruct.__module__ = 'numpy.core.multiarray'
 scalar.__module__ = 'numpy.core.multiarray'
 
 
-_from_dlpack.__module__ = 'numpy'
+from_dlpack.__module__ = 'numpy'
 arange.__module__ = 'numpy'
 array.__module__ = 'numpy'
 asarray.__module__ = 'numpy'
@@ -68,6 +70,8 @@
 set_numeric_ops.__module__ = 'numpy'
 seterrobj.__module__ = 'numpy'
 zeros.__module__ = 'numpy'
+_get_promotion_state.__module__ = 'numpy'
+_set_promotion_state.__module__ = 'numpy'
 
 
 # We can't verify dispatcher signatures because NumPy's C functions don't
@@ -287,7 +291,7 @@ def inner(a, b):
 
         np.inner(a, b) = sum(a[:]*b[:])
 
-    More generally, if `ndim(a) = r > 0` and `ndim(b) = s > 0`::
+    More generally, if ``ndim(a) = r > 0`` and ``ndim(b) = s > 0``::
 
         np.inner(a, b) = np.tensordot(a, b, axes=(-1,-1))
 
@@ -746,17 +750,21 @@ def dot(a, b, out=None):
     - If both `a` and `b` are 2-D arrays, it is matrix multiplication,
       but using :func:`matmul` or ``a @ b`` is preferred.
 
-    - If either `a` or `b` is 0-D (scalar), it is equivalent to :func:`multiply`
-      and using ``numpy.multiply(a, b)`` or ``a * b`` is preferred.
+    - If either `a` or `b` is 0-D (scalar), it is equivalent to
+      :func:`multiply` and using ``numpy.multiply(a, b)`` or ``a * b`` is
+      preferred.
 
     - If `a` is an N-D array and `b` is a 1-D array, it is a sum product over
       the last axis of `a` and `b`.
 
     - If `a` is an N-D array and `b` is an M-D array (where ``M>=2``), it is a
-      sum product over the last axis of `a` and the second-to-last axis of `b`::
+      sum product over the last axis of `a` and the second-to-last axis of
+      `b`::
 
         dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])
 
+    It uses an optimized BLAS library when possible (see `numpy.linalg`).
+
     Parameters
     ----------
     a : array_like
@@ -1099,6 +1107,22 @@ def copyto(dst, src, casting=None, where=None):
         A boolean array which is broadcasted to match the dimensions
         of `dst`, and selects elements to copy from `src` to `dst`
         wherever it contains the value True.
+
+    Examples
+    --------
+    >>> A = np.array([4, 5, 6])
+    >>> B = [1, 2, 3]
+    >>> np.copyto(A, B)
+    >>> A
+    array([1, 2, 3])
+
+    >>> A = np.array([[1, 2, 3], [4, 5, 6]])
+    >>> B = [[4, 5, 6], [7, 8, 9]]
+    >>> np.copyto(A, B)
+    >>> A
+    array([[4, 5, 6],
+           [7, 8, 9]])
+       
     """
     return (dst, src, where)
 
diff --git a/numpy/core/multiarray.pyi b/numpy/core/multiarray.pyi
index a9f68e1815cf..0701085b757d 100644
--- a/numpy/core/multiarray.pyi
+++ b/numpy/core/multiarray.pyi
@@ -2,23 +2,17 @@
 
 import os
 import datetime as dt
+from collections.abc import Sequence, Callable, Iterable
 from typing import (
     Literal as L,
     Any,
-    Callable,
-    Iterable,
-    Optional,
     overload,
     TypeVar,
-    List,
-    Type,
-    Union,
-    Sequence,
-    Tuple,
     SupportsIndex,
     final,
     Final,
     Protocol,
+    ClassVar,
 )
 
 from numpy import (
@@ -55,19 +49,20 @@ from numpy import (
     _NDIterOpFlagsKind,
 )
 
-from numpy.typing import (
+from numpy._typing import (
     # Shapes
     _ShapeLike,
 
     # DTypes
     DTypeLike,
-    _SupportsDType,
+    _DTypeLike,
 
     # Arrays
     NDArray,
     ArrayLike,
-    _SupportsArray,
-    _FiniteNestedSequence,
+    _ArrayLike,
+    _SupportsArrayFunc,
+    _NestedSequence,
     _ArrayLikeBool_co,
     _ArrayLikeUInt_co,
     _ArrayLikeInt_co,
@@ -84,17 +79,11 @@ from numpy.typing import (
     _TD64Like_co,
 )
 
+_T_co = TypeVar("_T_co", covariant=True)
+_T_contra = TypeVar("_T_contra", contravariant=True)
 _SCT = TypeVar("_SCT", bound=generic)
 _ArrayType = TypeVar("_ArrayType", bound=NDArray[Any])
 
-# Subscriptable subsets of `npt.DTypeLike` and `npt.ArrayLike`
-_DTypeLike = Union[
-    dtype[_SCT],
-    Type[_SCT],
-    _SupportsDType[dtype[_SCT]],
-]
-_ArrayLike = _FiniteNestedSequence[_SupportsArray[dtype[_SCT]]]
-
 # Valid time units
 _UnitKind = L[
     "Y",
@@ -120,7 +109,11 @@ _RollKind = L[  # `raise` is deliberately excluded
     "modifiedpreceding",
 ]
 
-__all__: List[str]
+class _SupportsLenAndGetItem(Protocol[_T_contra, _T_co]):
+    def __len__(self) -> int: ...
+    def __getitem__(self, key: _T_contra, /) -> _T_co: ...
+
+__all__: list[str]
 
 ALLOW_THREADS: Final[int]  # 0 or 1 (system-specific)
 BUFSIZE: L[8192]
@@ -138,7 +131,7 @@ def empty_like(
     dtype: None = ...,
     order: _OrderKACF = ...,
     subok: bool = ...,
-    shape: Optional[_ShapeLike] = ...,
+    shape: None | _ShapeLike = ...,
 ) -> _ArrayType: ...
 @overload
 def empty_like(
@@ -146,7 +139,7 @@ def empty_like(
     dtype: None = ...,
     order: _OrderKACF = ...,
     subok: bool = ...,
-    shape: Optional[_ShapeLike] = ...,
+    shape: None | _ShapeLike = ...,
 ) -> NDArray[_SCT]: ...
 @overload
 def empty_like(
@@ -154,7 +147,7 @@ def empty_like(
     dtype: None = ...,
     order: _OrderKACF = ...,
     subok: bool = ...,
-    shape: Optional[_ShapeLike] = ...,
+    shape: None | _ShapeLike = ...,
 ) -> NDArray[Any]: ...
 @overload
 def empty_like(
@@ -162,7 +155,7 @@ def empty_like(
     dtype: _DTypeLike[_SCT],
     order: _OrderKACF = ...,
     subok: bool = ...,
-    shape: Optional[_ShapeLike] = ...,
+    shape: None | _ShapeLike = ...,
 ) -> NDArray[_SCT]: ...
 @overload
 def empty_like(
@@ -170,7 +163,7 @@ def empty_like(
     dtype: DTypeLike,
     order: _OrderKACF = ...,
     subok: bool = ...,
-    shape: Optional[_ShapeLike] = ...,
+    shape: None | _ShapeLike = ...,
 ) -> NDArray[Any]: ...
 
 @overload
@@ -182,7 +175,7 @@ def array(
     order: _OrderKACF = ...,
     subok: L[True],
     ndmin: int = ...,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> _ArrayType: ...
 @overload
 def array(
@@ -193,7 +186,7 @@ def array(
     order: _OrderKACF = ...,
     subok: bool = ...,
     ndmin: int = ...,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[_SCT]: ...
 @overload
 def array(
@@ -204,7 +197,7 @@ def array(
     order: _OrderKACF = ...,
     subok: bool = ...,
     ndmin: int = ...,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[Any]: ...
 @overload
 def array(
@@ -215,7 +208,7 @@ def array(
     order: _OrderKACF = ...,
     subok: bool = ...,
     ndmin: int = ...,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[_SCT]: ...
 @overload
 def array(
@@ -226,7 +219,7 @@ def array(
     order: _OrderKACF = ...,
     subok: bool = ...,
     ndmin: int = ...,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[Any]: ...
 
 @overload
@@ -235,7 +228,7 @@ def zeros(
     dtype: None = ...,
     order: _OrderCF = ...,
     *,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[float64]: ...
 @overload
 def zeros(
@@ -243,7 +236,7 @@ def zeros(
     dtype: _DTypeLike[_SCT],
     order: _OrderCF = ...,
     *,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[_SCT]: ...
 @overload
 def zeros(
@@ -251,7 +244,7 @@ def zeros(
     dtype: DTypeLike,
     order: _OrderCF = ...,
     *,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[Any]: ...
 
 @overload
@@ -260,7 +253,7 @@ def empty(
     dtype: None = ...,
     order: _OrderCF = ...,
     *,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[float64]: ...
 @overload
 def empty(
@@ -268,7 +261,7 @@ def empty(
     dtype: _DTypeLike[_SCT],
     order: _OrderCF = ...,
     *,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[_SCT]: ...
 @overload
 def empty(
@@ -276,7 +269,7 @@ def empty(
     dtype: DTypeLike,
     order: _OrderCF = ...,
     *,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[Any]: ...
 
 @overload
@@ -284,78 +277,79 @@ def unravel_index(  # type: ignore[misc]
     indices: _IntLike_co,
     shape: _ShapeLike,
     order: _OrderCF = ...,
-) -> Tuple[intp, ...]: ...
+) -> tuple[intp, ...]: ...
 @overload
 def unravel_index(
     indices: _ArrayLikeInt_co,
     shape: _ShapeLike,
     order: _OrderCF = ...,
-) -> Tuple[NDArray[intp], ...]: ...
+) -> tuple[NDArray[intp], ...]: ...
 
 @overload
 def ravel_multi_index(  # type: ignore[misc]
     multi_index: Sequence[_IntLike_co],
     dims: Sequence[SupportsIndex],
-    mode: Union[_ModeKind, Tuple[_ModeKind, ...]] = ...,
+    mode: _ModeKind | tuple[_ModeKind, ...] = ...,
     order: _OrderCF = ...,
 ) -> intp: ...
 @overload
 def ravel_multi_index(
     multi_index: Sequence[_ArrayLikeInt_co],
     dims: Sequence[SupportsIndex],
-    mode: Union[_ModeKind, Tuple[_ModeKind, ...]] = ...,
+    mode: _ModeKind | tuple[_ModeKind, ...] = ...,
     order: _OrderCF = ...,
 ) -> NDArray[intp]: ...
 
+# NOTE: Allow any sequence of array-like objects
 @overload
 def concatenate(  # type: ignore[misc]
     arrays: _ArrayLike[_SCT],
     /,
-    axis: Optional[SupportsIndex] = ...,
+    axis: None | SupportsIndex = ...,
     out: None = ...,
     *,
     dtype: None = ...,
-    casting: Optional[_CastingKind] = ...
+    casting: None | _CastingKind = ...
 ) -> NDArray[_SCT]: ...
 @overload
 def concatenate(  # type: ignore[misc]
-    arrays: ArrayLike,
+    arrays: _SupportsLenAndGetItem[int, ArrayLike],
     /,
-    axis: Optional[SupportsIndex] = ...,
+    axis: None | SupportsIndex = ...,
     out: None = ...,
     *,
     dtype: None = ...,
-    casting: Optional[_CastingKind] = ...
+    casting: None | _CastingKind = ...
 ) -> NDArray[Any]: ...
 @overload
 def concatenate(  # type: ignore[misc]
-    arrays: ArrayLike,
+    arrays: _SupportsLenAndGetItem[int, ArrayLike],
     /,
-    axis: Optional[SupportsIndex] = ...,
+    axis: None | SupportsIndex = ...,
     out: None = ...,
     *,
     dtype: _DTypeLike[_SCT],
-    casting: Optional[_CastingKind] = ...
+    casting: None | _CastingKind = ...
 ) -> NDArray[_SCT]: ...
 @overload
 def concatenate(  # type: ignore[misc]
-    arrays: ArrayLike,
+    arrays: _SupportsLenAndGetItem[int, ArrayLike],
     /,
-    axis: Optional[SupportsIndex] = ...,
+    axis: None | SupportsIndex = ...,
     out: None = ...,
     *,
     dtype: DTypeLike,
-    casting: Optional[_CastingKind] = ...
+    casting: None | _CastingKind = ...
 ) -> NDArray[Any]: ...
 @overload
 def concatenate(
-    arrays: ArrayLike,
+    arrays: _SupportsLenAndGetItem[int, ArrayLike],
     /,
-    axis: Optional[SupportsIndex] = ...,
+    axis: None | SupportsIndex = ...,
     out: _ArrayType = ...,
     *,
     dtype: DTypeLike = ...,
-    casting: Optional[_CastingKind] = ...
+    casting: None | _CastingKind = ...
 ) -> _ArrayType: ...
 
 def inner(
@@ -368,7 +362,7 @@ def inner(
 def where(
     condition: ArrayLike,
     /,
-) -> Tuple[NDArray[intp], ...]: ...
+) -> tuple[NDArray[intp], ...]: ...
 @overload
 def where(
     condition: ArrayLike,
@@ -379,13 +373,13 @@ def where(
 
 def lexsort(
     keys: ArrayLike,
-    axis: Optional[SupportsIndex] = ...,
+    axis: None | SupportsIndex = ...,
 ) -> Any: ...
 
 def can_cast(
-    from_: Union[ArrayLike, DTypeLike],
+    from_: ArrayLike | DTypeLike,
     to: DTypeLike,
-    casting: Optional[_CastingKind] = ...,
+    casting: None | _CastingKind = ...,
 ) -> bool: ...
 
 def min_scalar_type(
@@ -393,7 +387,7 @@ def min_scalar_type(
 ) -> dtype[Any]: ...
 
 def result_type(
-    *arrays_and_dtypes: Union[ArrayLike, DTypeLike],
+    *arrays_and_dtypes: ArrayLike | DTypeLike,
 ) -> dtype[Any]: ...
 
 @overload
@@ -421,15 +415,15 @@ def vdot(a: Any, b: _ArrayLikeObject_co, /) -> Any: ...
 def bincount(
     x: ArrayLike,
     /,
-    weights: Optional[ArrayLike] = ...,
+    weights: None | ArrayLike = ...,
     minlength: SupportsIndex = ...,
 ) -> NDArray[intp]: ...
 
 def copyto(
     dst: NDArray[Any],
     src: ArrayLike,
-    casting: Optional[_CastingKind] = ...,
-    where: Optional[_ArrayLikeBool_co] = ...,
+    casting: None | _CastingKind = ...,
+    where: None | _ArrayLikeBool_co = ...,
 ) -> None: ...
 
 def putmask(
@@ -441,15 +435,15 @@ def putmask(
 def packbits(
     a: _ArrayLikeInt_co,
     /,
-    axis: Optional[SupportsIndex] = ...,
+    axis: None | SupportsIndex = ...,
     bitorder: L["big", "little"] = ...,
 ) -> NDArray[uint8]: ...
 
 def unpackbits(
     a: _ArrayLike[uint8],
     /,
-    axis: Optional[SupportsIndex] = ...,
-    count: Optional[SupportsIndex] = ...,
+    axis: None | SupportsIndex = ...,
+    count: None | SupportsIndex = ...,
     bitorder: L["big", "little"] = ...,
 ) -> NDArray[uint8]: ...
 
@@ -457,14 +451,14 @@ def shares_memory(
     a: object,
     b: object,
     /,
-    max_work: Optional[int] = ...,
+    max_work: None | int = ...,
 ) -> bool: ...
 
 def may_share_memory(
     a: object,
     b: object,
     /,
-    max_work: Optional[int] = ...,
+    max_work: None | int = ...,
 ) -> bool: ...
 
 @overload
@@ -473,7 +467,7 @@ def asarray(
     dtype: None = ...,
     order: _OrderKACF = ...,
     *,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[_SCT]: ...
 @overload
 def asarray(
@@ -481,7 +475,7 @@ def asarray(
     dtype: None = ...,
     order: _OrderKACF = ...,
     *,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[Any]: ...
 @overload
 def asarray(
@@ -489,7 +483,7 @@ def asarray(
     dtype: _DTypeLike[_SCT],
     order: _OrderKACF = ...,
     *,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[_SCT]: ...
 @overload
 def asarray(
@@ -497,7 +491,7 @@ def asarray(
     dtype: DTypeLike,
     order: _OrderKACF = ...,
     *,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[Any]: ...
 
 @overload
@@ -506,7 +500,7 @@ def asanyarray(
     dtype: None = ...,
     order: _OrderKACF = ...,
     *,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> _ArrayType: ...
 @overload
 def asanyarray(
@@ -514,7 +508,7 @@ def asanyarray(
     dtype: None = ...,
     order: _OrderKACF = ...,
     *,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[_SCT]: ...
 @overload
 def asanyarray(
@@ -522,7 +516,7 @@ def asanyarray(
     dtype: None = ...,
     order: _OrderKACF = ...,
     *,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[Any]: ...
 @overload
 def asanyarray(
@@ -530,7 +524,7 @@ def asanyarray(
     dtype: _DTypeLike[_SCT],
     order: _OrderKACF = ...,
     *,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[_SCT]: ...
 @overload
 def asanyarray(
@@ -538,7 +532,7 @@ def asanyarray(
     dtype: DTypeLike,
     order: _OrderKACF = ...,
     *,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[Any]: ...
 
 @overload
@@ -546,28 +540,28 @@ def ascontiguousarray(
     a: _ArrayLike[_SCT],
     dtype: None = ...,
     *,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[_SCT]: ...
 @overload
 def ascontiguousarray(
     a: object,
     dtype: None = ...,
     *,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[Any]: ...
 @overload
 def ascontiguousarray(
     a: Any,
     dtype: _DTypeLike[_SCT],
     *,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[_SCT]: ...
 @overload
 def ascontiguousarray(
     a: Any,
     dtype: DTypeLike,
     *,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[Any]: ...
 
 @overload
@@ -575,34 +569,34 @@ def asfortranarray(
     a: _ArrayLike[_SCT],
     dtype: None = ...,
     *,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[_SCT]: ...
 @overload
 def asfortranarray(
     a: object,
     dtype: None = ...,
     *,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[Any]: ...
 @overload
 def asfortranarray(
     a: Any,
     dtype: _DTypeLike[_SCT],
     *,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[_SCT]: ...
 @overload
 def asfortranarray(
     a: Any,
     dtype: DTypeLike,
     *,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[Any]: ...
 
-# In practice `List[Any]` is list with an int, int and a valid
+# In practice `list[Any]` is list with an int, int and a valid
 # `np.seterrcall()` object
-def geterrobj() -> List[Any]: ...
-def seterrobj(errobj: List[Any], /) -> None: ...
+def geterrobj() -> list[Any]: ...
+def seterrobj(errobj: list[Any], /) -> None: ...
 
 def promote_types(__type1: DTypeLike, __type2: DTypeLike) -> dtype[Any]: ...
 
@@ -614,7 +608,7 @@ def fromstring(
     count: SupportsIndex = ...,
     *,
     sep: str,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[float64]: ...
 @overload
 def fromstring(
@@ -623,7 +617,7 @@ def fromstring(
     count: SupportsIndex = ...,
     *,
     sep: str,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[_SCT]: ...
 @overload
 def fromstring(
@@ -632,7 +626,7 @@ def fromstring(
     count: SupportsIndex = ...,
     *,
     sep: str,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[Any]: ...
 
 def frompyfunc(
@@ -651,7 +645,7 @@ def fromfile(
     sep: str = ...,
     offset: SupportsIndex = ...,
     *,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[float64]: ...
 @overload
 def fromfile(
@@ -661,7 +655,7 @@ def fromfile(
     sep: str = ...,
     offset: SupportsIndex = ...,
     *,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[_SCT]: ...
 @overload
 def fromfile(
@@ -671,7 +665,7 @@ def fromfile(
     sep: str = ...,
     offset: SupportsIndex = ...,
     *,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[Any]: ...
 
 @overload
@@ -680,7 +674,7 @@ def fromiter(
     dtype: _DTypeLike[_SCT],
     count: SupportsIndex = ...,
     *,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[_SCT]: ...
 @overload
 def fromiter(
@@ -688,7 +682,7 @@ def fromiter(
     dtype: DTypeLike,
     count: SupportsIndex = ...,
     *,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[Any]: ...
 
 @overload
@@ -698,7 +692,7 @@ def frombuffer(
     count: SupportsIndex = ...,
     offset: SupportsIndex = ...,
     *,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[float64]: ...
 @overload
 def frombuffer(
@@ -707,7 +701,7 @@ def frombuffer(
     count: SupportsIndex = ...,
     offset: SupportsIndex = ...,
     *,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[_SCT]: ...
 @overload
 def frombuffer(
@@ -716,7 +710,7 @@ def frombuffer(
     count: SupportsIndex = ...,
     offset: SupportsIndex = ...,
     *,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[Any]: ...
 
 @overload
@@ -724,7 +718,7 @@ def arange(  # type: ignore[misc]
     stop: _IntLike_co,
     /, *,
     dtype: None = ...,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[signedinteger[Any]]: ...
 @overload
 def arange(  # type: ignore[misc]
@@ -733,14 +727,14 @@ def arange(  # type: ignore[misc]
     step: _IntLike_co = ...,
     dtype: None = ...,
     *,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[signedinteger[Any]]: ...
 @overload
 def arange(  # type: ignore[misc]
     stop: _FloatLike_co,
     /, *,
     dtype: None = ...,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[floating[Any]]: ...
 @overload
 def arange(  # type: ignore[misc]
@@ -749,14 +743,14 @@ def arange(  # type: ignore[misc]
     step: _FloatLike_co = ...,
     dtype: None = ...,
     *,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[floating[Any]]: ...
 @overload
 def arange(
     stop: _TD64Like_co,
     /, *,
     dtype: None = ...,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[timedelta64]: ...
 @overload
 def arange(
@@ -765,7 +759,7 @@ def arange(
     step: _TD64Like_co = ...,
     dtype: None = ...,
     *,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[timedelta64]: ...
 @overload
 def arange(  # both start and stop must always be specified for datetime64
@@ -774,14 +768,14 @@ def arange(  # both start and stop must always be specified for datetime64
     step: datetime64 = ...,
     dtype: None = ...,
     *,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[datetime64]: ...
 @overload
 def arange(
     stop: Any,
     /, *,
     dtype: _DTypeLike[_SCT],
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[_SCT]: ...
 @overload
 def arange(
@@ -790,14 +784,14 @@ def arange(
     step: Any = ...,
     dtype: _DTypeLike[_SCT] = ...,
     *,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[_SCT]: ...
 @overload
 def arange(
     stop: Any, /,
     *,
     dtype: DTypeLike,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[Any]: ...
 @overload
 def arange(
@@ -806,40 +800,40 @@ def arange(
     step: Any = ...,
     dtype: DTypeLike = ...,
     *,
-    like: ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[Any]: ...
 
 def datetime_data(
     dtype: str | _DTypeLike[datetime64] | _DTypeLike[timedelta64], /,
-) -> Tuple[str, int]: ...
+) -> tuple[str, int]: ...
 
 # The datetime functions perform unsafe casts to `datetime64[D]`,
 # so a lot of different argument types are allowed here
 
 @overload
 def busday_count(  # type: ignore[misc]
-    begindates: _ScalarLike_co,
-    enddates: _ScalarLike_co,
+    begindates: _ScalarLike_co | dt.date,
+    enddates: _ScalarLike_co | dt.date,
     weekmask: ArrayLike = ...,
-    holidays: None | ArrayLike = ...,
+    holidays: None | ArrayLike | dt.date | _NestedSequence[dt.date] = ...,
     busdaycal: None | busdaycalendar = ...,
     out: None = ...,
 ) -> int_: ...
 @overload
 def busday_count(  # type: ignore[misc]
-    begindates: ArrayLike,
-    enddates: ArrayLike,
+    begindates: ArrayLike | dt.date | _NestedSequence[dt.date],
+    enddates: ArrayLike | dt.date | _NestedSequence[dt.date],
     weekmask: ArrayLike = ...,
-    holidays: None | ArrayLike = ...,
+    holidays: None | ArrayLike | dt.date | _NestedSequence[dt.date] = ...,
     busdaycal: None | busdaycalendar = ...,
     out: None = ...,
 ) -> NDArray[int_]: ...
 @overload
 def busday_count(
-    begindates: ArrayLike,
-    enddates: ArrayLike,
+    begindates: ArrayLike | dt.date | _NestedSequence[dt.date],
+    enddates: ArrayLike | dt.date | _NestedSequence[dt.date],
     weekmask: ArrayLike = ...,
-    holidays: None | ArrayLike = ...,
+    holidays: None | ArrayLike | dt.date | _NestedSequence[dt.date] = ...,
     busdaycal: None | busdaycalendar = ...,
     out: _ArrayType = ...,
 ) -> _ArrayType: ...
@@ -847,100 +841,100 @@ def busday_count(
 # `roll="raise"` is (more or less?) equivalent to `casting="safe"`
 @overload
 def busday_offset(  # type: ignore[misc]
-    dates: datetime64,
-    offsets: _TD64Like_co,
+    dates: datetime64 | dt.date,
+    offsets: _TD64Like_co | dt.timedelta,
     roll: L["raise"] = ...,
     weekmask: ArrayLike = ...,
-    holidays: None | ArrayLike = ...,
+    holidays: None | ArrayLike | dt.date | _NestedSequence[dt.date] = ...,
     busdaycal: None | busdaycalendar = ...,
     out: None = ...,
 ) -> datetime64: ...
 @overload
 def busday_offset(  # type: ignore[misc]
-    dates: _ArrayLike[datetime64],
-    offsets: _ArrayLikeTD64_co,
+    dates: _ArrayLike[datetime64] | dt.date | _NestedSequence[dt.date],
+    offsets: _ArrayLikeTD64_co | dt.timedelta | _NestedSequence[dt.timedelta],
     roll: L["raise"] = ...,
     weekmask: ArrayLike = ...,
-    holidays: None | ArrayLike = ...,
+    holidays: None | ArrayLike | dt.date | _NestedSequence[dt.date] = ...,
     busdaycal: None | busdaycalendar = ...,
     out: None = ...,
 ) -> NDArray[datetime64]: ...
 @overload
 def busday_offset(  # type: ignore[misc]
-    dates: _ArrayLike[datetime64],
-    offsets: _ArrayLike[timedelta64],
+    dates: _ArrayLike[datetime64] | dt.date | _NestedSequence[dt.date],
+    offsets: _ArrayLikeTD64_co | dt.timedelta | _NestedSequence[dt.timedelta],
     roll: L["raise"] = ...,
     weekmask: ArrayLike = ...,
-    holidays: None | ArrayLike = ...,
+    holidays: None | ArrayLike | dt.date | _NestedSequence[dt.date] = ...,
     busdaycal: None | busdaycalendar = ...,
     out: _ArrayType = ...,
 ) -> _ArrayType: ...
 @overload
 def busday_offset(  # type: ignore[misc]
-    dates: _ScalarLike_co,
-    offsets: _ScalarLike_co,
+    dates: _ScalarLike_co | dt.date,
+    offsets: _ScalarLike_co | dt.timedelta,
     roll: _RollKind,
     weekmask: ArrayLike = ...,
-    holidays: None | ArrayLike = ...,
+    holidays: None | ArrayLike | dt.date | _NestedSequence[dt.date] = ...,
     busdaycal: None | busdaycalendar = ...,
     out: None = ...,
 ) -> datetime64: ...
 @overload
 def busday_offset(  # type: ignore[misc]
-    dates: ArrayLike,
-    offsets: ArrayLike,
+    dates: ArrayLike | dt.date | _NestedSequence[dt.date],
+    offsets: ArrayLike | dt.timedelta | _NestedSequence[dt.timedelta],
     roll: _RollKind,
     weekmask: ArrayLike = ...,
-    holidays: None | ArrayLike = ...,
+    holidays: None | ArrayLike | dt.date | _NestedSequence[dt.date] = ...,
     busdaycal: None | busdaycalendar = ...,
     out: None = ...,
 ) -> NDArray[datetime64]: ...
 @overload
 def busday_offset(
-    dates: ArrayLike,
-    offsets: ArrayLike,
+    dates: ArrayLike | dt.date | _NestedSequence[dt.date],
+    offsets: ArrayLike | dt.timedelta | _NestedSequence[dt.timedelta],
     roll: _RollKind,
     weekmask: ArrayLike = ...,
-    holidays: None | ArrayLike = ...,
+    holidays: None | ArrayLike | dt.date | _NestedSequence[dt.date] = ...,
     busdaycal: None | busdaycalendar = ...,
     out: _ArrayType = ...,
 ) -> _ArrayType: ...
 
 @overload
 def is_busday(  # type: ignore[misc]
-    dates: _ScalarLike_co,
+    dates: _ScalarLike_co | dt.date,
     weekmask: ArrayLike = ...,
-    holidays: None | ArrayLike = ...,
+    holidays: None | ArrayLike | dt.date | _NestedSequence[dt.date] = ...,
     busdaycal: None | busdaycalendar = ...,
     out: None = ...,
 ) -> bool_: ...
 @overload
 def is_busday(  # type: ignore[misc]
-    dates: ArrayLike,
+    dates: ArrayLike | _NestedSequence[dt.date],
     weekmask: ArrayLike = ...,
-    holidays: None | ArrayLike = ...,
+    holidays: None | ArrayLike | dt.date | _NestedSequence[dt.date] = ...,
     busdaycal: None | busdaycalendar = ...,
     out: None = ...,
 ) -> NDArray[bool_]: ...
 @overload
 def is_busday(
-    dates: ArrayLike,
+    dates: ArrayLike | _NestedSequence[dt.date],
     weekmask: ArrayLike = ...,
-    holidays: None | ArrayLike = ...,
+    holidays: None | ArrayLike | dt.date | _NestedSequence[dt.date] = ...,
     busdaycal: None | busdaycalendar = ...,
     out: _ArrayType = ...,
 ) -> _ArrayType: ...
 
 @overload
 def datetime_as_string(  # type: ignore[misc]
-    arr: datetime64,
+    arr: datetime64 | dt.date,
     unit: None | L["auto"] | _UnitKind = ...,
     timezone: L["naive", "UTC", "local"] | dt.tzinfo = ...,
     casting: _CastingKind = ...,
 ) -> str_: ...
 @overload
 def datetime_as_string(
-    arr: _ArrayLikeDT64_co,
+    arr: _ArrayLikeDT64_co | _NestedSequence[dt.date],
     unit: None | L["auto"] | _UnitKind = ...,
     timezone: L["naive", "UTC", "local"] | dt.tzinfo = ...,
     casting: _CastingKind = ...,
@@ -978,13 +972,13 @@ _GetItemKeys = L[
 ]
 _SetItemKeys = L[
     "A", "ALIGNED",
-    "W", "WRITABLE",
+    "W", "WRITEABLE",
     "X", "WRITEBACKIFCOPY",
 ]
 
 @final
 class flagsobj:
-    __hash__: None  # type: ignore[assignment]
+    __hash__: ClassVar[None]  # type: ignore[assignment]
     aligned: bool
     # NOTE: deprecated
     # updateifcopy: bool
@@ -1024,4 +1018,4 @@ def nested_iters(
     order: _OrderKACF = ...,
     casting: _CastingKind = ...,
     buffersize: SupportsIndex = ...,
-) -> Tuple[nditer, ...]: ...
+) -> tuple[nditer, ...]: ...
diff --git a/numpy/core/numeric.py b/numpy/core/numeric.py
index 344d40d934cf..fdd81a20ebe8 100644
--- a/numpy/core/numeric.py
+++ b/numpy/core/numeric.py
@@ -8,16 +8,16 @@
 import numpy as np
 from . import multiarray
 from .multiarray import (
-    _fastCopyAndTranspose as fastCopyAndTranspose, ALLOW_THREADS,
+    fastCopyAndTranspose, ALLOW_THREADS,
     BUFSIZE, CLIP, MAXDIMS, MAY_SHARE_BOUNDS, MAY_SHARE_EXACT, RAISE,
     WRAP, arange, array, asarray, asanyarray, ascontiguousarray,
     asfortranarray, broadcast, can_cast, compare_chararrays,
     concatenate, copyto, dot, dtype, empty,
-    empty_like, flatiter, frombuffer, _from_dlpack, fromfile, fromiter,
+    empty_like, flatiter, frombuffer, from_dlpack, fromfile, fromiter,
     fromstring, inner, lexsort, matmul, may_share_memory,
     min_scalar_type, ndarray, nditer, nested_iters, promote_types,
     putmask, result_type, set_numeric_ops, shares_memory, vdot, where,
-    zeros, normalize_axis_index)
+    zeros, normalize_axis_index, _get_promotion_state, _set_promotion_state)
 
 from . import overrides
 from . import umath
@@ -27,7 +27,7 @@
 from . import numerictypes
 from .numerictypes import longlong, intc, int_, float_, complex_, bool_
 from ._exceptions import TooHardError, AxisError
-from ._ufunc_config import errstate
+from ._ufunc_config import errstate, _no_nep50_warning
 
 bitwise_not = invert
 ufunc = type(sin)
@@ -41,7 +41,7 @@
     'newaxis', 'ndarray', 'flatiter', 'nditer', 'nested_iters', 'ufunc',
     'arange', 'array', 'asarray', 'asanyarray', 'ascontiguousarray',
     'asfortranarray', 'zeros', 'count_nonzero', 'empty', 'broadcast', 'dtype',
-    'fromstring', 'fromfile', 'frombuffer', '_from_dlpack', 'where',
+    'fromstring', 'fromfile', 'frombuffer', 'from_dlpack', 'where',
     'argwhere', 'copyto', 'concatenate', 'fastCopyAndTranspose', 'lexsort',
     'set_numeric_ops', 'can_cast', 'promote_types', 'min_scalar_type',
     'result_type', 'isfortran', 'empty_like', 'zeros_like', 'ones_like',
@@ -54,7 +54,8 @@
     'False_', 'True_', 'bitwise_not', 'CLIP', 'RAISE', 'WRAP', 'MAXDIMS',
     'BUFSIZE', 'ALLOW_THREADS', 'ComplexWarning', 'full', 'full_like',
     'matmul', 'shares_memory', 'may_share_memory', 'MAY_SHARE_BOUNDS',
-    'MAY_SHARE_EXACT', 'TooHardError', 'AxisError']
+    'MAY_SHARE_EXACT', 'TooHardError', 'AxisError',
+    '_get_promotion_state', '_set_promotion_state']
 
 
 @set_module('numpy')
@@ -136,7 +137,7 @@ def zeros_like(a, dtype=None, order='K', subok=True, shape=None):
 
     """
     res = empty_like(a, dtype=dtype, order=order, subok=subok, shape=shape)
-    # needed instead of a 0 to get same result as zeros for for string dtypes
+    # needed instead of a 0 to get same result as zeros for string dtypes
     z = zeros(1, dtype=res.dtype)
     multiarray.copyto(res, z, casting='unsafe')
     return res
@@ -207,7 +208,7 @@ def ones(shape, dtype=None, order='C', *, like=None):
 
 
 _ones_with_like = array_function_dispatch(
-    _ones_dispatcher
+    _ones_dispatcher, use_like=True
 )(ones)
 
 
@@ -346,7 +347,7 @@ def full(shape, fill_value, dtype=None, order='C', *, like=None):
 
 
 _full_with_like = array_function_dispatch(
-    _full_dispatcher
+    _full_dispatcher, use_like=True
 )(full)
 
 
@@ -364,7 +365,7 @@ def full_like(a, fill_value, dtype=None, order='K', subok=True, shape=None):
     a : array_like
         The shape and data-type of `a` define these same attributes of
         the returned array.
-    fill_value : scalar
+    fill_value : array_like
         Fill value.
     dtype : data-type, optional
         Overrides the data type of the result.
@@ -412,6 +413,12 @@ def full_like(a, fill_value, dtype=None, order='K', subok=True, shape=None):
     >>> np.full_like(y, 0.1)
     array([0.1, 0.1, 0.1, 0.1, 0.1, 0.1])
 
+    >>> y = np.zeros([2, 2, 3], dtype=int)
+    >>> np.full_like(y, [0, 0, 255])
+    array([[[  0,   0, 255],
+            [  0,   0, 255]],
+           [[  0,   0, 255],
+            [  0,   0, 255]]])
     """
     res = empty_like(a, dtype=dtype, order=order, subok=subok, shape=shape)
     multiarray.copyto(res, fill_value, casting='unsafe')
@@ -627,7 +634,7 @@ def flatnonzero(a):
     """
     Return indices that are non-zero in the flattened version of a.
 
-    This is equivalent to np.nonzero(np.ravel(a))[0].
+    This is equivalent to ``np.nonzero(np.ravel(a))[0]``.
 
     Parameters
     ----------
@@ -637,7 +644,7 @@ def flatnonzero(a):
     Returns
     -------
     res : ndarray
-        Output array, containing the indices of the elements of `a.ravel()`
+        Output array, containing the indices of the elements of ``a.ravel()``
         that are non-zero.
 
     See Also
@@ -669,16 +676,16 @@ def _correlate_dispatcher(a, v, mode=None):
 
 @array_function_dispatch(_correlate_dispatcher)
 def correlate(a, v, mode='valid'):
-    """
+    r"""
     Cross-correlation of two 1-dimensional sequences.
 
     This function computes the correlation as generally defined in signal
-    processing texts::
+    processing texts:
 
-        c_{av}[k] = sum_n a[n+k] * conj(v[n])
+    .. math:: c_k = \sum_n a_{n+k} \cdot \overline{v}_n
 
-    with a and v sequences being zero-padded where necessary and conj being
-    the conjugate.
+    with a and v sequences being zero-padded where necessary and
+    :math:`\overline x` denoting complex conjugation.
 
     Parameters
     ----------
@@ -705,11 +712,11 @@ def correlate(a, v, mode='valid'):
     Notes
     -----
     The definition of correlation above is not unique and sometimes correlation
-    may be defined differently. Another common definition is::
+    may be defined differently. Another common definition is:
 
-        c'_{av}[k] = sum_n a[n] conj(v[n+k])
+    .. math:: c'_k = \sum_n a_{n} \cdot \overline{v_{n+k}}
 
-    which is related to ``c_{av}[k]`` by ``c'_{av}[k] = c_{av}[-k]``.
+    which is related to :math:`c_k` by :math:`c'_k = c_{-k}`.
 
     `numpy.correlate` may perform slowly in large arrays (i.e. n = 1e5) because it does
     not use the FFT to compute the convolution; in that case, `scipy.signal.correlate` might
@@ -731,8 +738,8 @@ def correlate(a, v, mode='valid'):
     array([ 0.5-0.5j,  1.0+0.j ,  1.5-1.5j,  3.0-1.j ,  0.0+0.j ])
 
     Note that you get the time reversed, complex conjugated result
-    when the two input sequences change places, i.e.,
-    ``c_{va}[k] = c^{*}_{av}[-k]``:
+    (:math:`\overline{c_{-k}}`) when the two input sequences a and v change 
+    places:
 
     >>> np.correlate([0, 1, 0.5j], [1+1j, 2, 3-1j], 'full')
     array([ 0.0+0.j ,  3.0+1.j ,  1.5+1.5j,  1.0+0.j ,  0.5+0.5j])
@@ -798,7 +805,7 @@ def convolve(a, v, mode='full'):
     -----
     The discrete convolution operation is defined as
 
-    .. math:: (a * v)[n] = \\sum_{m = -\\infty}^{\\infty} a[m] v[n - m]
+    .. math:: (a * v)_n = \\sum_{m = -\\infty}^{\\infty} a_m v_{n - m}
 
     It can be shown that a convolution :math:`x(t) * y(t)` in time/space
     is equivalent to the multiplication :math:`X(f) Y(f)` in the Fourier
@@ -1561,7 +1568,7 @@ def cross(a, b, axisa=-1, axisb=-1, axisc=-1, axis=None):
     array(-3)
 
     Multiple vector cross-products. Note that the direction of the cross
-    product vector is defined by the `right-hand rule`.
+    product vector is defined by the *right-hand rule*.
 
     >>> x = np.array([[1,2,3], [4,5,6]])
     >>> y = np.array([[4,5,6], [1,2,3]])
@@ -1615,6 +1622,10 @@ def cross(a, b, axisa=-1, axisb=-1, axisc=-1, axis=None):
     dtype = promote_types(a.dtype, b.dtype)
     cp = empty(shape, dtype)
 
+    # recast arrays as dtype
+    a = a.astype(dtype)
+    b = b.astype(dtype)
+
     # create local aliases for readability
     a0 = a[..., 0]
     a1 = a[..., 1]
@@ -1825,10 +1836,18 @@ def fromfunction(function, shape, *, dtype=float, like=None, **kwargs):
 
     Notes
     -----
-    Keywords other than `dtype` are passed to `function`.
+    Keywords other than `dtype` and `like` are passed to `function`.
 
     Examples
     --------
+    >>> np.fromfunction(lambda i, j: i, (2, 2), dtype=float)
+    array([[0., 0.],
+           [1., 1.]])
+           
+    >>> np.fromfunction(lambda i, j: j, (2, 2), dtype=float)    
+    array([[0., 1.],
+           [0., 1.]])
+           
     >>> np.fromfunction(lambda i, j: i == j, (3, 3), dtype=int)
     array([[ True, False, False],
            [False,  True, False],
@@ -1848,7 +1867,7 @@ def fromfunction(function, shape, *, dtype=float, like=None, **kwargs):
 
 
 _fromfunction_with_like = array_function_dispatch(
-    _fromfunction_dispatcher
+    _fromfunction_dispatcher, use_like=True
 )(fromfunction)
 
 
@@ -2169,7 +2188,7 @@ def identity(n, dtype=None, *, like=None):
 
 
 _identity_with_like = array_function_dispatch(
-    _identity_dispatcher
+    _identity_dispatcher, use_like=True
 )(identity)
 
 
@@ -2338,7 +2357,7 @@ def isclose(a, b, rtol=1.e-5, atol=1.e-8, equal_nan=False):
     array([False,  True])
     """
     def within_tol(x, y, atol, rtol):
-        with errstate(invalid='ignore'):
+        with errstate(invalid='ignore'), _no_nep50_warning():
             return less_equal(abs(x-y), atol + rtol * abs(y))
 
     x = asanyarray(a)
diff --git a/numpy/core/numeric.pyi b/numpy/core/numeric.pyi
index d7ec303518a2..98d3789a579e 100644
--- a/numpy/core/numeric.pyi
+++ b/numpy/core/numeric.pyi
@@ -1,14 +1,9 @@
+from collections.abc import Callable, Sequence
 from typing import (
     Any,
-    Union,
-    Sequence,
-    Tuple,
-    Callable,
-    List,
     overload,
     TypeVar,
     Literal,
-    Type,
     SupportsAbs,
     SupportsIndex,
     NoReturn,
@@ -17,7 +12,6 @@ from typing_extensions import TypeGuard
 
 from numpy import (
     ComplexWarning as ComplexWarning,
-    dtype,
     generic,
     unsignedinteger,
     signedinteger,
@@ -33,14 +27,14 @@ from numpy import (
     _OrderCF,
 )
 
-from numpy.typing import (
+from numpy._typing import (
     ArrayLike,
     NDArray,
     DTypeLike,
     _ShapeLike,
-    _SupportsDType,
-    _FiniteNestedSequence,
-    _SupportsArray,
+    _DTypeLike,
+    _ArrayLike,
+    _SupportsArrayFunc,
     _ScalarLike_co,
     _ArrayLikeBool_co,
     _ArrayLikeUInt_co,
@@ -49,21 +43,16 @@ from numpy.typing import (
     _ArrayLikeComplex_co,
     _ArrayLikeTD64_co,
     _ArrayLikeObject_co,
+    _ArrayLikeUnknown,
 )
 
 _T = TypeVar("_T")
 _SCT = TypeVar("_SCT", bound=generic)
 _ArrayType = TypeVar("_ArrayType", bound=NDArray[Any])
 
-_DTypeLike = Union[
-    dtype[_SCT],
-    Type[_SCT],
-    _SupportsDType[dtype[_SCT]],
-]
-_ArrayLike = _FiniteNestedSequence[_SupportsArray[dtype[_SCT]]]
 _CorrelateMode = Literal["valid", "same", "full"]
 
-__all__: List[str]
+__all__: list[str]
 
 @overload
 def zeros_like(
@@ -112,7 +101,7 @@ def ones(
     dtype: None = ...,
     order: _OrderCF = ...,
     *,
-    like: ArrayLike = ...,
+    like: _SupportsArrayFunc = ...,
 ) -> NDArray[float64]: ...
 @overload
 def ones(
@@ -120,7 +109,7 @@ def ones(
     dtype: _DTypeLike[_SCT],
     order: _OrderCF = ...,
     *,
-    like: ArrayLike = ...,
+    like: _SupportsArrayFunc = ...,
 ) -> NDArray[_SCT]: ...
 @overload
 def ones(
@@ -128,7 +117,7 @@ def ones(
     dtype: DTypeLike,
     order: _OrderCF = ...,
     *,
-    like: ArrayLike = ...,
+    like: _SupportsArrayFunc = ...,
 ) -> NDArray[Any]: ...
 
 @overload
@@ -179,7 +168,7 @@ def full(
     dtype: None = ...,
     order: _OrderCF = ...,
     *,
-    like: ArrayLike = ...,
+    like: _SupportsArrayFunc = ...,
 ) -> NDArray[Any]: ...
 @overload
 def full(
@@ -188,7 +177,7 @@ def full(
     dtype: _DTypeLike[_SCT],
     order: _OrderCF = ...,
     *,
-    like: ArrayLike = ...,
+    like: _SupportsArrayFunc = ...,
 ) -> NDArray[_SCT]: ...
 @overload
 def full(
@@ -197,7 +186,7 @@ def full(
     dtype: DTypeLike,
     order: _OrderCF = ...,
     *,
-    like: ArrayLike = ...,
+    like: _SupportsArrayFunc = ...,
 ) -> NDArray[Any]: ...
 
 @overload
@@ -267,6 +256,12 @@ def argwhere(a: ArrayLike) -> NDArray[intp]: ...
 
 def flatnonzero(a: ArrayLike) -> NDArray[intp]: ...
 
+@overload
+def correlate(
+    a: _ArrayLikeUnknown,
+    v: _ArrayLikeUnknown,
+    mode: _CorrelateMode = ...,
+) -> NDArray[Any]: ...
 @overload
 def correlate(
     a: _ArrayLikeBool_co,
@@ -310,6 +305,12 @@ def correlate(
     mode: _CorrelateMode = ...,
 ) -> NDArray[object_]: ...
 
+@overload
+def convolve(
+    a: _ArrayLikeUnknown,
+    v: _ArrayLikeUnknown,
+    mode: _CorrelateMode = ...,
+) -> NDArray[Any]: ...
 @overload
 def convolve(
     a: _ArrayLikeBool_co,
@@ -353,6 +354,12 @@ def convolve(
     mode: _CorrelateMode = ...,
 ) -> NDArray[object_]: ...
 
+@overload
+def outer(
+    a: _ArrayLikeUnknown,
+    b: _ArrayLikeUnknown,
+    out: None = ...,
+) -> NDArray[Any]: ...
 @overload
 def outer(
     a: _ArrayLikeBool_co,
@@ -402,47 +409,53 @@ def outer(
     out: _ArrayType,
 ) -> _ArrayType: ...
 
+@overload
+def tensordot(
+    a: _ArrayLikeUnknown,
+    b: _ArrayLikeUnknown,
+    axes: int | tuple[_ShapeLike, _ShapeLike] = ...,
+) -> NDArray[Any]: ...
 @overload
 def tensordot(
     a: _ArrayLikeBool_co,
     b: _ArrayLikeBool_co,
-    axes: int | Tuple[_ShapeLike, _ShapeLike] = ...,
+    axes: int | tuple[_ShapeLike, _ShapeLike] = ...,
 ) -> NDArray[bool_]: ...
 @overload
 def tensordot(
     a: _ArrayLikeUInt_co,
     b: _ArrayLikeUInt_co,
-    axes: int | Tuple[_ShapeLike, _ShapeLike] = ...,
+    axes: int | tuple[_ShapeLike, _ShapeLike] = ...,
 ) -> NDArray[unsignedinteger[Any]]: ...
 @overload
 def tensordot(
     a: _ArrayLikeInt_co,
     b: _ArrayLikeInt_co,
-    axes: int | Tuple[_ShapeLike, _ShapeLike] = ...,
+    axes: int | tuple[_ShapeLike, _ShapeLike] = ...,
 ) -> NDArray[signedinteger[Any]]: ...
 @overload
 def tensordot(
     a: _ArrayLikeFloat_co,
     b: _ArrayLikeFloat_co,
-    axes: int | Tuple[_ShapeLike, _ShapeLike] = ...,
+    axes: int | tuple[_ShapeLike, _ShapeLike] = ...,
 ) -> NDArray[floating[Any]]: ...
 @overload
 def tensordot(
     a: _ArrayLikeComplex_co,
     b: _ArrayLikeComplex_co,
-    axes: int | Tuple[_ShapeLike, _ShapeLike] = ...,
+    axes: int | tuple[_ShapeLike, _ShapeLike] = ...,
 ) -> NDArray[complexfloating[Any, Any]]: ...
 @overload
 def tensordot(
     a: _ArrayLikeTD64_co,
     b: _ArrayLikeTD64_co,
-    axes: int | Tuple[_ShapeLike, _ShapeLike] = ...,
+    axes: int | tuple[_ShapeLike, _ShapeLike] = ...,
 ) -> NDArray[timedelta64]: ...
 @overload
 def tensordot(
     a: _ArrayLikeObject_co,
     b: _ArrayLikeObject_co,
-    axes: int | Tuple[_ShapeLike, _ShapeLike] = ...,
+    axes: int | tuple[_ShapeLike, _ShapeLike] = ...,
 ) -> NDArray[object_]: ...
 
 @overload
@@ -470,6 +483,15 @@ def moveaxis(
     destination: _ShapeLike,
 ) -> NDArray[_SCT]: ...
 
+@overload
+def cross(
+    a: _ArrayLikeUnknown,
+    b: _ArrayLikeUnknown,
+    axisa: int = ...,
+    axisb: int = ...,
+    axisc: int = ...,
+    axis: None | int = ...,
+) -> NDArray[Any]: ...
 @overload
 def cross(
     a: _ArrayLikeBool_co,
@@ -528,15 +550,15 @@ def cross(
 @overload
 def indices(
     dimensions: Sequence[int],
-    dtype: Type[int] = ...,
+    dtype: type[int] = ...,
     sparse: Literal[False] = ...,
 ) -> NDArray[int_]: ...
 @overload
 def indices(
     dimensions: Sequence[int],
-    dtype: Type[int] = ...,
+    dtype: type[int] = ...,
     sparse: Literal[True] = ...,
-) -> Tuple[NDArray[int_], ...]: ...
+) -> tuple[NDArray[int_], ...]: ...
 @overload
 def indices(
     dimensions: Sequence[int],
@@ -548,7 +570,7 @@ def indices(
     dimensions: Sequence[int],
     dtype: _DTypeLike[_SCT],
     sparse: Literal[True],
-) -> Tuple[NDArray[_SCT], ...]: ...
+) -> tuple[NDArray[_SCT], ...]: ...
 @overload
 def indices(
     dimensions: Sequence[int],
@@ -560,14 +582,14 @@ def indices(
     dimensions: Sequence[int],
     dtype: DTypeLike,
     sparse: Literal[True],
-) -> Tuple[NDArray[Any], ...]: ...
+) -> tuple[NDArray[Any], ...]: ...
 
 def fromfunction(
     function: Callable[..., _T],
     shape: Sequence[int],
     *,
     dtype: DTypeLike = ...,
-    like: ArrayLike = ...,
+    like: _SupportsArrayFunc = ...,
     **kwargs: Any,
 ) -> _T: ...
 
@@ -588,21 +610,21 @@ def identity(
     n: int,
     dtype: None = ...,
     *,
-    like: ArrayLike = ...,
+    like: _SupportsArrayFunc = ...,
 ) -> NDArray[float64]: ...
 @overload
 def identity(
     n: int,
     dtype: _DTypeLike[_SCT],
     *,
-    like: ArrayLike = ...,
+    like: _SupportsArrayFunc = ...,
 ) -> NDArray[_SCT]: ...
 @overload
 def identity(
     n: int,
     dtype: DTypeLike,
     *,
-    like: ArrayLike = ...,
+    like: _SupportsArrayFunc = ...,
 ) -> NDArray[Any]: ...
 
 def allclose(
diff --git a/numpy/core/numerictypes.py b/numpy/core/numerictypes.py
index 8e5de852bcff..21a00ac6fc6d 100644
--- a/numpy/core/numerictypes.py
+++ b/numpy/core/numerictypes.py
@@ -47,14 +47,14 @@
      |   |   |     byte
      |   |   |     short
      |   |   |     intc
-     |   |   |     intp            int0
+     |   |   |     intp
      |   |   |     int_
      |   |   |     longlong
      |   |   \\-> unsignedinteger  (uintxx)     (kind=u)
      |   |         ubyte
      |   |         ushort
      |   |         uintc
-     |   |         uintp           uint0
+     |   |         uintp
      |   |         uint_
      |   |         ulonglong
      |   +-> inexact
@@ -516,7 +516,7 @@ def _scalar_type_key(typ):
     return (dt.kind.lower(), dt.itemsize)
 
 
-ScalarType = [int, float, complex, int, bool, bytes, str, memoryview]
+ScalarType = [int, float, complex, bool, bytes, str, memoryview]
 ScalarType += sorted(_concrete_types, key=_scalar_type_key)
 ScalarType = tuple(ScalarType)
 
diff --git a/numpy/core/numerictypes.pyi b/numpy/core/numerictypes.pyi
index 1d3ff773bbd7..d10e4822ad09 100644
--- a/numpy/core/numerictypes.pyi
+++ b/numpy/core/numerictypes.pyi
@@ -1,16 +1,12 @@
 import sys
 import types
+from collections.abc import Iterable
 from typing import (
     Literal as L,
-    Type,
     Union,
-    Tuple,
     overload,
     Any,
     TypeVar,
-    Dict,
-    List,
-    Iterable,
     Protocol,
     TypedDict,
 )
@@ -50,18 +46,11 @@ from numpy.core._type_aliases import (
     sctypes as sctypes,
 )
 
-from numpy.typing import DTypeLike, ArrayLike, _SupportsDType
+from numpy._typing import DTypeLike, ArrayLike, _DTypeLike
 
 _T = TypeVar("_T")
 _SCT = TypeVar("_SCT", bound=generic)
 
-# A paramtrizable subset of `npt.DTypeLike`
-_DTypeLike = Union[
-    Type[_SCT],
-    dtype[_SCT],
-    _SupportsDType[dtype[_SCT]],
-]
-
 class _CastFunc(Protocol):
     def __call__(
         self, x: ArrayLike, k: DTypeLike = ...
@@ -78,48 +67,48 @@ class _TypeCodes(TypedDict):
     Datetime: L['Mm']
     All: L['?bhilqpBHILQPefdgFDGSUVOMm']
 
-class _typedict(Dict[Type[generic], _T]):
+class _typedict(dict[type[generic], _T]):
     def __getitem__(self, key: DTypeLike) -> _T: ...
 
 if sys.version_info >= (3, 10):
     _TypeTuple = Union[
-        Type[Any],
+        type[Any],
         types.UnionType,
-        Tuple[Union[Type[Any], types.UnionType, Tuple[Any, ...]], ...],
+        tuple[Union[type[Any], types.UnionType, tuple[Any, ...]], ...],
     ]
 else:
     _TypeTuple = Union[
-        Type[Any],
-        Tuple[Union[Type[Any], Tuple[Any, ...]], ...],
+        type[Any],
+        tuple[Union[type[Any], tuple[Any, ...]], ...],
     ]
 
-__all__: List[str]
+__all__: list[str]
 
 @overload
-def maximum_sctype(t: _DTypeLike[_SCT]) -> Type[_SCT]: ...
+def maximum_sctype(t: _DTypeLike[_SCT]) -> type[_SCT]: ...
 @overload
-def maximum_sctype(t: DTypeLike) -> Type[Any]: ...
+def maximum_sctype(t: DTypeLike) -> type[Any]: ...
 
 @overload
-def issctype(rep: dtype[Any] | Type[Any]) -> bool: ...
+def issctype(rep: dtype[Any] | type[Any]) -> bool: ...
 @overload
 def issctype(rep: object) -> L[False]: ...
 
 @overload
-def obj2sctype(rep: _DTypeLike[_SCT], default: None = ...) -> None | Type[_SCT]: ...
+def obj2sctype(rep: _DTypeLike[_SCT], default: None = ...) -> None | type[_SCT]: ...
 @overload
-def obj2sctype(rep: _DTypeLike[_SCT], default: _T) -> _T | Type[_SCT]: ...
+def obj2sctype(rep: _DTypeLike[_SCT], default: _T) -> _T | type[_SCT]: ...
 @overload
-def obj2sctype(rep: DTypeLike, default: None = ...) -> None | Type[Any]: ...
+def obj2sctype(rep: DTypeLike, default: None = ...) -> None | type[Any]: ...
 @overload
-def obj2sctype(rep: DTypeLike, default: _T) -> _T | Type[Any]: ...
+def obj2sctype(rep: DTypeLike, default: _T) -> _T | type[Any]: ...
 @overload
 def obj2sctype(rep: object, default: None = ...) -> None: ...
 @overload
 def obj2sctype(rep: object, default: _T) -> _T: ...
 
 @overload
-def issubclass_(arg1: Type[Any], arg2: _TypeTuple) -> bool: ...
+def issubclass_(arg1: type[Any], arg2: _TypeTuple) -> bool: ...
 @overload
 def issubclass_(arg1: object, arg2: object) -> L[False]: ...
 
@@ -137,37 +126,36 @@ def find_common_type(
 cast: _typedict[_CastFunc]
 nbytes: _typedict[int]
 typecodes: _TypeCodes
-ScalarType: Tuple[
-    Type[int],
-    Type[float],
-    Type[complex],
-    Type[int],
-    Type[bool],
-    Type[bytes],
-    Type[str],
-    Type[memoryview],
-    Type[bool_],
-    Type[csingle],
-    Type[cdouble],
-    Type[clongdouble],
-    Type[half],
-    Type[single],
-    Type[double],
-    Type[longdouble],
-    Type[byte],
-    Type[short],
-    Type[intc],
-    Type[int_],
-    Type[longlong],
-    Type[timedelta64],
-    Type[datetime64],
-    Type[object_],
-    Type[bytes_],
-    Type[str_],
-    Type[ubyte],
-    Type[ushort],
-    Type[uintc],
-    Type[uint],
-    Type[ulonglong],
-    Type[void],
+ScalarType: tuple[
+    type[int],
+    type[float],
+    type[complex],
+    type[bool],
+    type[bytes],
+    type[str],
+    type[memoryview],
+    type[bool_],
+    type[csingle],
+    type[cdouble],
+    type[clongdouble],
+    type[half],
+    type[single],
+    type[double],
+    type[longdouble],
+    type[byte],
+    type[short],
+    type[intc],
+    type[int_],
+    type[longlong],
+    type[timedelta64],
+    type[datetime64],
+    type[object_],
+    type[bytes_],
+    type[str_],
+    type[ubyte],
+    type[ushort],
+    type[uintc],
+    type[uint],
+    type[ulonglong],
+    type[void],
 ]
diff --git a/numpy/core/overrides.py b/numpy/core/overrides.py
index 840cf38c9ccb..c567dfefda71 100644
--- a/numpy/core/overrides.py
+++ b/numpy/core/overrides.py
@@ -12,7 +12,7 @@
     int(os.environ.get('NUMPY_EXPERIMENTAL_ARRAY_FUNCTION', 1)))
 
 array_function_like_doc = (
-    """like : array_like
+    """like : array_like, optional
         Reference object to allow the creation of arrays which are not
         NumPy arrays. If an array-like passed in as ``like`` supports
         the ``__array_function__`` protocol, the result will be defined
@@ -126,7 +126,7 @@ def decorator(func):
 
 
 def array_function_dispatch(dispatcher, module=None, verify=True,
-                            docs_from_dispatcher=False):
+                            docs_from_dispatcher=False, use_like=False):
     """Decorator for adding dispatch with the __array_function__ protocol.
 
     See NEP-18 for example usage.
@@ -176,9 +176,30 @@ def decorator(implementation):
 
         @functools.wraps(implementation)
         def public_api(*args, **kwargs):
-            relevant_args = dispatcher(*args, **kwargs)
+            try:
+                relevant_args = dispatcher(*args, **kwargs)
+            except TypeError as exc:
+                # Try to clean up a signature related TypeError.  Such an
+                # error will be something like:
+                #     dispatcher.__name__() got an unexpected keyword argument
+                #
+                # So replace the dispatcher name in this case.  In principle
+                # TypeErrors may be raised from _within_ the dispatcher, so
+                # we check that the traceback contains a string that starts
+                # with the name.  (In principle we could also check the
+                # traceback length, as it would be deeper.)
+                msg = exc.args[0]
+                disp_name = dispatcher.__name__
+                if not isinstance(msg, str) or not msg.startswith(disp_name):
+                    raise
+
+                # Replace with the correct name and re-raise:
+                new_msg = msg.replace(disp_name, public_api.__name__)
+                raise TypeError(new_msg) from None
+
             return implement_array_function(
-                implementation, public_api, relevant_args, args, kwargs)
+                implementation, public_api, relevant_args, args, kwargs,
+                use_like)
 
         public_api.__code__ = public_api.__code__.replace(
                 co_name=implementation.__name__,
diff --git a/numpy/core/records.pyi b/numpy/core/records.pyi
index fda118276166..d3bbe0e70eef 100644
--- a/numpy/core/records.pyi
+++ b/numpy/core/records.pyi
@@ -1,12 +1,9 @@
 import os
+from collections.abc import Sequence, Iterable
 from typing import (
-    List,
-    Sequence,
     Any,
     TypeVar,
-    Iterable,
     overload,
-    Tuple,
     Protocol,
 )
 
@@ -21,7 +18,7 @@ from numpy import (
     _SupportsBuffer,
 )
 
-from numpy.typing import (
+from numpy._typing import (
     ArrayLike,
     DTypeLike,
     NDArray,
@@ -39,7 +36,7 @@ class _SupportsReadInto(Protocol):
     def tell(self, /) -> int: ...
     def readinto(self, buffer: memoryview, /) -> int: ...
 
-__all__: List[str]
+__all__: list[str]
 
 @overload
 def fromarrays(
@@ -67,7 +64,7 @@ def fromarrays(
 
 @overload
 def fromrecords(
-    recList: _ArrayLikeVoid_co | Tuple[Any, ...] | _NestedSequence[Tuple[Any, ...]],
+    recList: _ArrayLikeVoid_co | tuple[Any, ...] | _NestedSequence[tuple[Any, ...]],
     dtype: DTypeLike = ...,
     shape: None | _ShapeLike = ...,
     formats: None = ...,
@@ -78,7 +75,7 @@ def fromrecords(
 ) -> _RecArray[record]: ...
 @overload
 def fromrecords(
-    recList: _ArrayLikeVoid_co | Tuple[Any, ...] | _NestedSequence[Tuple[Any, ...]],
+    recList: _ArrayLikeVoid_co | tuple[Any, ...] | _NestedSequence[tuple[Any, ...]],
     dtype: None = ...,
     shape: None | _ShapeLike = ...,
     *,
@@ -181,3 +178,57 @@ def array(
     byteorder: None | _ByteOrder = ...,
     copy: bool = ...,
 ) -> _RecArray[record]: ...
+@overload
+def array(
+    obj: None,
+    dtype: DTypeLike,
+    shape: _ShapeLike,
+    offset: int = ...,
+    formats: None = ...,
+    names: None = ...,
+    titles: None = ...,
+    aligned: bool = ...,
+    byteorder: None = ...,
+    copy: bool = ...,
+) -> _RecArray[Any]: ...
+@overload
+def array(
+    obj: None,
+    dtype: None = ...,
+    *,
+    shape: _ShapeLike,
+    offset: int = ...,
+    formats: DTypeLike,
+    names: None | str | Sequence[str] = ...,
+    titles: None | str | Sequence[str] = ...,
+    aligned: bool = ...,
+    byteorder: None | _ByteOrder = ...,
+    copy: bool = ...,
+) -> _RecArray[record]: ...
+@overload
+def array(
+    obj: _SupportsReadInto,
+    dtype: DTypeLike,
+    shape: None | _ShapeLike = ...,
+    offset: int = ...,
+    formats: None = ...,
+    names: None = ...,
+    titles: None = ...,
+    aligned: bool = ...,
+    byteorder: None = ...,
+    copy: bool = ...,
+) -> _RecArray[Any]: ...
+@overload
+def array(
+    obj: _SupportsReadInto,
+    dtype: None = ...,
+    shape: None | _ShapeLike = ...,
+    offset: int = ...,
+    *,
+    formats: DTypeLike,
+    names: None | str | Sequence[str] = ...,
+    titles: None | str | Sequence[str] = ...,
+    aligned: bool = ...,
+    byteorder: None | _ByteOrder = ...,
+    copy: bool = ...,
+) -> _RecArray[record]: ...
diff --git a/numpy/core/setup.py b/numpy/core/setup.py
index a5f423d8fe4f..927defa0625d 100644
--- a/numpy/core/setup.py
+++ b/numpy/core/setup.py
@@ -1,14 +1,15 @@
 import os
 import sys
+import sysconfig
 import pickle
 import copy
 import warnings
-import platform
 import textwrap
 import glob
 from os.path import join
 
 from numpy.distutils import log
+from numpy.distutils.msvccompiler import lib_opts_if_msvc
 from distutils.dep_util import newer
 from sysconfig import get_config_var
 from numpy.compat import npy_load_module
@@ -17,6 +18,10 @@
 # Set to True to enable relaxed strides checking. This (mostly) means
 # that `strides[dim]` is ignored if `shape[dim] == 1` when setting flags.
 NPY_RELAXED_STRIDES_CHECKING = (os.environ.get('NPY_RELAXED_STRIDES_CHECKING', "1") != "0")
+if not NPY_RELAXED_STRIDES_CHECKING:
+    raise SystemError(
+        "Support for NPY_RELAXED_STRIDES_CHECKING=0 has been remove as of "
+        "NumPy 1.23.  This error will eventually be removed entirely.")
 
 # Put NPY_RELAXED_STRIDES_DEBUG=1 in the environment if you want numpy to use a
 # bogus value for affected strides in order to help smoke out bad stride usage
@@ -24,6 +29,11 @@
 NPY_RELAXED_STRIDES_DEBUG = (os.environ.get('NPY_RELAXED_STRIDES_DEBUG', "0") != "0")
 NPY_RELAXED_STRIDES_DEBUG = NPY_RELAXED_STRIDES_DEBUG and NPY_RELAXED_STRIDES_CHECKING
 
+# Set NPY_DISABLE_SVML=1 in the environment to disable the vendored SVML
+# library. This option only has significance on a Linux x86_64 host and is most
+# useful to avoid improperly requiring SVML when cross compiling.
+NPY_DISABLE_SVML = (os.environ.get('NPY_DISABLE_SVML', "0") == "1")
+
 # XXX: ugly, we use a class to avoid calling twice some expensive functions in
 # config.h/numpyconfig.h. I don't see a better way because distutils force
 # config.h generation inside an Extension class, and as such sharing
@@ -68,9 +78,12 @@ def can_link_svml():
     """SVML library is supported only on x86_64 architecture and currently
     only on linux
     """
-    machine = platform.machine()
-    system = platform.system()
-    return "x86_64" in machine and system == "Linux"
+    if NPY_DISABLE_SVML:
+        return False
+    platform = sysconfig.get_platform()
+    return ("x86_64" in platform
+            and "linux" in platform
+            and sys.maxsize > 2**31)
 
 def check_svml_submodule(svmlpath):
     if not os.path.exists(svmlpath + "/README.md"):
@@ -118,33 +131,64 @@ def win32_checks(deflist):
         deflist.append('FORCE_NO_LONG_DOUBLE_FORMATTING')
 
 def check_math_capabilities(config, ext, moredefs, mathlibs):
-    def check_func(func_name):
-        return config.check_func(func_name, libraries=mathlibs,
-                                 decl=True, call=True)
-
-    def check_funcs_once(funcs_name):
-        decl = dict([(f, True) for f in funcs_name])
-        st = config.check_funcs_once(funcs_name, libraries=mathlibs,
-                                     decl=decl, call=decl)
-        if st:
+    def check_func(
+        func_name,
+        decl=False,
+        headers=["feature_detection_math.h", "feature_detection_cmath.h"],
+    ):
+        return config.check_func(
+            func_name,
+            libraries=mathlibs,
+            decl=decl,
+            call=True,
+            call_args=FUNC_CALL_ARGS[func_name],
+            headers=headers,
+        )
+
+    def check_funcs_once(
+            funcs_name,
+            headers=["feature_detection_math.h", "feature_detection_cmath.h"],
+            add_to_moredefs=True):
+        call = dict([(f, True) for f in funcs_name])
+        call_args = dict([(f, FUNC_CALL_ARGS[f]) for f in funcs_name])
+        st = config.check_funcs_once(
+            funcs_name,
+            libraries=mathlibs,
+            decl=False,
+            call=call,
+            call_args=call_args,
+            headers=headers,
+        )
+        if st and add_to_moredefs:
             moredefs.extend([(fname2def(f), 1) for f in funcs_name])
         return st
 
-    def check_funcs(funcs_name):
+    def check_funcs(
+            funcs_name,
+            headers=["feature_detection_math.h", "feature_detection_cmath.h"]):
         # Use check_funcs_once first, and if it does not work, test func per
         # func. Return success only if all the functions are available
-        if not check_funcs_once(funcs_name):
+        if not check_funcs_once(funcs_name, headers=headers):
             # Global check failed, check func per func
             for f in funcs_name:
-                if check_func(f):
+                if check_func(f, headers=headers):
                     moredefs.append((fname2def(f), 1))
             return 0
         else:
             return 1
 
-    #use_msvc = config.check_decl("_MSC_VER")
+    # GH-14787: Work around GCC<8.4 bug when compiling with AVX512
+    # support on Windows-based platforms
+    def check_gh14787(fn):
+        if fn == 'attribute_target_avx512f':
+            if (sys.platform in ('win32', 'cygwin') and
+                    config.check_compiler_gcc() and
+                    not config.check_gcc_version_at_least(8, 4)):
+                ext.extra_compile_args.extend(
+                        ['-ffixed-xmm%s' % n for n in range(16, 32)])
 
-    if not check_funcs_once(MANDATORY_FUNCS):
+    #use_msvc = config.check_decl("_MSC_VER")
+    if not check_funcs_once(MANDATORY_FUNCS, add_to_moredefs=False):
         raise SystemError("One of the required function to build numpy is not"
                 " available (the list is %s)." % str(MANDATORY_FUNCS))
 
@@ -155,18 +199,29 @@ def check_funcs(funcs_name):
     # config.h in the public namespace, so we have a clash for the common
     # functions we test. We remove every function tested by python's
     # autoconf, hoping their own test are correct
-    for f in OPTIONAL_STDFUNCS_MAYBE:
-        if config.check_decl(fname2def(f),
-                    headers=["Python.h", "math.h"]):
-            OPTIONAL_STDFUNCS.remove(f)
+    for f in OPTIONAL_FUNCS_MAYBE:
+        if config.check_decl(fname2def(f), headers=["Python.h"]):
+            OPTIONAL_FILE_FUNCS.remove(f)
 
-    check_funcs(OPTIONAL_STDFUNCS)
+    check_funcs(OPTIONAL_FILE_FUNCS, headers=["feature_detection_stdio.h"])
+    check_funcs(OPTIONAL_MISC_FUNCS, headers=["feature_detection_misc.h"])
 
     for h in OPTIONAL_HEADERS:
         if config.check_func("", decl=False, call=False, headers=[h]):
             h = h.replace(".", "_").replace(os.path.sep, "_")
             moredefs.append((fname2def(h), 1))
 
+    # Try with both "locale.h" and "xlocale.h"
+    locale_headers = [
+        "stdlib.h",
+        "xlocale.h",
+        "feature_detection_locale.h",
+    ]
+    if not check_funcs(OPTIONAL_LOCALE_FUNCS, headers=locale_headers):
+        # It didn't work with xlocale.h, maybe it will work with locale.h?
+        locale_headers[1] = "locale.h"
+        check_funcs(OPTIONAL_LOCALE_FUNCS, headers=locale_headers)
+
     for tup in OPTIONAL_INTRINSICS:
         headers = None
         if len(tup) == 2:
@@ -182,41 +237,29 @@ def check_funcs(funcs_name):
     for dec, fn in OPTIONAL_FUNCTION_ATTRIBUTES:
         if config.check_gcc_function_attribute(dec, fn):
             moredefs.append((fname2def(fn), 1))
-            if fn == 'attribute_target_avx512f':
-                # GH-14787: Work around GCC<8.4 bug when compiling with AVX512
-                # support on Windows-based platforms
-                if (sys.platform in ('win32', 'cygwin') and
-                        config.check_compiler_gcc() and
-                        not config.check_gcc_version_at_least(8, 4)):
-                    ext.extra_compile_args.extend(
-                            ['-ffixed-xmm%s' % n for n in range(16, 32)])
-
-    for dec, fn, code, header in OPTIONAL_FUNCTION_ATTRIBUTES_WITH_INTRINSICS:
-        if config.check_gcc_function_attribute_with_intrinsics(dec, fn, code,
-                                                               header):
-            moredefs.append((fname2def(fn), 1))
+            check_gh14787(fn)
+
+    platform = sysconfig.get_platform()
+    if ("x86_64" in platform):
+        for dec, fn in OPTIONAL_FUNCTION_ATTRIBUTES_AVX:
+            if config.check_gcc_function_attribute(dec, fn):
+                moredefs.append((fname2def(fn), 1))
+                check_gh14787(fn)
+        for dec, fn, code, header in (
+        OPTIONAL_FUNCTION_ATTRIBUTES_WITH_INTRINSICS_AVX):
+            if config.check_gcc_function_attribute_with_intrinsics(
+                    dec, fn, code, header):
+                moredefs.append((fname2def(fn), 1))
 
     for fn in OPTIONAL_VARIABLE_ATTRIBUTES:
         if config.check_gcc_variable_attribute(fn):
             m = fn.replace("(", "_").replace(")", "_")
             moredefs.append((fname2def(m), 1))
 
-    # C99 functions: float and long double versions
-    check_funcs(C99_FUNCS_SINGLE)
-    check_funcs(C99_FUNCS_EXTENDED)
-
 def check_complex(config, mathlibs):
     priv = []
     pub = []
 
-    try:
-        if os.uname()[0] == "Interix":
-            warnings.warn("Disabling broken complex support. See #1365", stacklevel=2)
-            return priv, pub
-    except Exception:
-        # os.uname not available on all platforms. blanket except ugly but safe
-        pass
-
     # Check for complex support
     st = config.check_header('complex.h')
     if st:
@@ -387,20 +430,28 @@ def check_types(config_cmd, ext, build_dir):
 def check_mathlib(config_cmd):
     # Testing the C math library
     mathlibs = []
-    mathlibs_choices = [[], ['m'], ['cpml']]
-    mathlib = os.environ.get('MATHLIB')
+    mathlibs_choices = [[], ["m"], ["cpml"]]
+    mathlib = os.environ.get("MATHLIB")
     if mathlib:
-        mathlibs_choices.insert(0, mathlib.split(','))
+        mathlibs_choices.insert(0, mathlib.split(","))
     for libs in mathlibs_choices:
-        if config_cmd.check_func("exp", libraries=libs, decl=True, call=True):
+        if config_cmd.check_func(
+            "log",
+            libraries=libs,
+            call_args="0",
+            decl="double log(double);",
+            call=True
+        ):
             mathlibs = libs
             break
     else:
         raise RuntimeError(
             "math library missing; rerun setup.py after setting the "
-            "MATHLIB env variable")
+            "MATHLIB env variable"
+        )
     return mathlibs
 
+
 def visibility_define(config):
     """Return the define value to use for NPY_VISIBILITY_HIDDEN (may be empty
     string)."""
@@ -411,25 +462,25 @@ def visibility_define(config):
         return ''
 
 def configuration(parent_package='',top_path=None):
-    from numpy.distutils.misc_util import Configuration, dot_join
+    from numpy.distutils.misc_util import (Configuration, dot_join,
+                                           exec_mod_from_location)
     from numpy.distutils.system_info import (get_info, blas_opt_info,
                                              lapack_opt_info)
+    from numpy.distutils.ccompiler_opt import NPY_CXX_FLAGS
+    from numpy.version import release as is_released
 
     config = Configuration('core', parent_package, top_path)
     local_dir = config.local_path
     codegen_dir = join(local_dir, 'code_generators')
 
-    if is_released(config):
-        warnings.simplefilter('error', MismatchCAPIWarning)
-
     # Check whether we have a mismatch between the set C API VERSION and the
-    # actual C API VERSION
+    # actual C API VERSION. Will raise a MismatchCAPIError if so.
     check_api_version(C_API_VERSION, codegen_dir)
 
     generate_umath_py = join(codegen_dir, 'generate_umath.py')
     n = dot_join(config.name, 'generate_umath')
-    generate_umath = npy_load_module('_'.join(n.split('.')),
-                                     generate_umath_py, ('.py', 'U', 1))
+    generate_umath = exec_mod_from_location('_'.join(n.split('.')),
+                                            generate_umath_py)
 
     header_dir = 'include/numpy'  # this is relative to config.path_in_package
 
@@ -473,13 +524,9 @@ def generate_config_h(ext, build_dir):
             if can_link_svml():
                 moredefs.append(('NPY_CAN_LINK_SVML', 1))
 
-            # Use relaxed stride checking
-            if NPY_RELAXED_STRIDES_CHECKING:
-                moredefs.append(('NPY_RELAXED_STRIDES_CHECKING', 1))
-            else:
-                moredefs.append(('NPY_RELAXED_STRIDES_CHECKING', 0))
-
-            # Use bogus stride debug aid when relaxed strides are enabled
+            # Use bogus stride debug aid to flush out bugs where users use
+            # strides of dimensions with length 1 to index a full contiguous
+            # array.
             if NPY_RELAXED_STRIDES_DEBUG:
                 moredefs.append(('NPY_RELAXED_STRIDES_DEBUG', 1))
             else:
@@ -497,6 +544,10 @@ def generate_config_h(ext, build_dir):
 
             # Generate the config.h file from moredefs
             with open(target, 'w') as target_f:
+                if sys.platform == 'darwin':
+                    target_f.write(
+                        "/* may be overridden by numpyconfig.h on darwin */\n"
+                    )
                 for d in moredefs:
                     if isinstance(d, str):
                         target_f.write('#define %s\n' % (d))
@@ -575,9 +626,6 @@ def generate_numpyconfig_h(ext, build_dir):
             moredefs.extend(cocache.check_ieee_macros(config_cmd)[1])
             moredefs.extend(cocache.check_complex(config_cmd, mathlibs)[1])
 
-            if NPY_RELAXED_STRIDES_CHECKING:
-                moredefs.append(('NPY_RELAXED_STRIDES_CHECKING', 1))
-
             if NPY_RELAXED_STRIDES_DEBUG:
                 moredefs.append(('NPY_RELAXED_STRIDES_DEBUG', 1))
 
@@ -688,11 +736,17 @@ def get_mathlib_info(*args):
         ):
             is_cpp = lang == 'c++'
             if is_cpp:
-                # this a workround to get rid of invalid c++ flags
+                # this a workaround to get rid of invalid c++ flags
                 # without doing big changes to config.
                 # c tested first, compiler should be here
                 bk_c = config_cmd.compiler
                 config_cmd.compiler = bk_c.cxx_compiler()
+
+                # Check that Linux compiler actually support the default flags
+                if hasattr(config_cmd.compiler, 'compiler'):
+                    config_cmd.compiler.compiler.extend(NPY_CXX_FLAGS)
+                    config_cmd.compiler.compiler_so.extend(NPY_CXX_FLAGS)
+
             st = config_cmd.try_link(test_code, lang=lang)
             if not st:
                 # rerun the failing command in verbose mode
@@ -713,29 +767,18 @@ def get_mathlib_info(*args):
 
     npymath_sources = [join('src', 'npymath', 'npy_math_internal.h.src'),
                        join('src', 'npymath', 'npy_math.c'),
+                       # join('src', 'npymath', 'ieee754.cpp'),
                        join('src', 'npymath', 'ieee754.c.src'),
                        join('src', 'npymath', 'npy_math_complex.c.src'),
-                       join('src', 'npymath', 'halffloat.c')
+                       join('src', 'npymath', 'halffloat.c'),
                        ]
 
-    def gl_if_msvc(build_cmd):
-        """ Add flag if we are using MSVC compiler
-
-        We can't see this in our scope, because we have not initialized the
-        distutils build command, so use this deferred calculation to run when
-        we are building the library.
-        """
-        if build_cmd.compiler.compiler_type == 'msvc':
-            # explicitly disable whole-program optimization
-            return ['/GL-']
-        return []
-
     config.add_installed_library('npymath',
             sources=npymath_sources + [get_mathlib_info],
             install_dir='lib',
             build_info={
                 'include_dirs' : [],  # empty list required for creating npy_math_internal.h
-                'extra_compiler_args': [gl_if_msvc],
+                'extra_compiler_args': [lib_opts_if_msvc],
             })
     config.add_npy_pkg_config("npymath.ini.in", "lib/npy-pkg-config",
             subst_dict)
@@ -797,7 +840,7 @@ def gl_if_msvc(build_cmd):
             join('src', 'common', 'ucsnarrow.c'),
             join('src', 'common', 'ufunc_override.c'),
             join('src', 'common', 'numpyos.c'),
-            join('src', 'common', 'npy_cpu_features.c.src'),
+            join('src', 'common', 'npy_cpu_features.c'),
             ]
 
     if os.environ.get('NPY_USE_BLAS_ILP64', "0") != "0":
@@ -824,7 +867,7 @@ def gl_if_msvc(build_cmd):
     multiarray_deps = [
             join('src', 'multiarray', 'abstractdtypes.h'),
             join('src', 'multiarray', 'arrayobject.h'),
-            join('src', 'multiarray', 'arraytypes.h'),
+            join('src', 'multiarray', 'arraytypes.h.src'),
             join('src', 'multiarray', 'arrayfunction_override.h'),
             join('src', 'multiarray', 'array_coercion.h'),
             join('src', 'multiarray', 'array_method.h'),
@@ -860,6 +903,7 @@ def gl_if_msvc(build_cmd):
             join('src', 'multiarray', 'typeinfo.h'),
             join('src', 'multiarray', 'usertypes.h'),
             join('src', 'multiarray', 'vdot.h'),
+            join('src', 'multiarray', 'textreading', 'readtext.h'),
             join('include', 'numpy', 'arrayobject.h'),
             join('include', 'numpy', '_neighborhood_iterator_imp.h'),
             join('include', 'numpy', 'npy_endian.h'),
@@ -885,7 +929,9 @@ def gl_if_msvc(build_cmd):
             join('src', 'multiarray', 'abstractdtypes.c'),
             join('src', 'multiarray', 'alloc.c'),
             join('src', 'multiarray', 'arrayobject.c'),
+            join('src', 'multiarray', 'arraytypes.h.src'),
             join('src', 'multiarray', 'arraytypes.c.src'),
+            join('src', 'multiarray', 'argfunc.dispatch.c.src'),
             join('src', 'multiarray', 'array_coercion.c'),
             join('src', 'multiarray', 'array_method.c'),
             join('src', 'multiarray', 'array_assign_scalar.c'),
@@ -938,15 +984,28 @@ def gl_if_msvc(build_cmd):
             join('src', 'multiarray', 'usertypes.c'),
             join('src', 'multiarray', 'vdot.c'),
             join('src', 'common', 'npy_sort.h.src'),
-            join('src', 'npysort', 'quicksort.c.src'),
-            join('src', 'npysort', 'mergesort.c.src'),
-            join('src', 'npysort', 'timsort.c.src'),
-            join('src', 'npysort', 'heapsort.c.src'),
+            join('src', 'npysort', 'x86-qsort.dispatch.cpp'),
+            join('src', 'npysort', 'quicksort.cpp'),
+            join('src', 'npysort', 'mergesort.cpp'),
+            join('src', 'npysort', 'timsort.cpp'),
+            join('src', 'npysort', 'heapsort.cpp'),
             join('src', 'npysort', 'radixsort.cpp'),
-            join('src', 'common', 'npy_partition.h.src'),
-            join('src', 'npysort', 'selection.c.src'),
-            join('src', 'common', 'npy_binsearch.h.src'),
-            join('src', 'npysort', 'binsearch.c.src'),
+            join('src', 'common', 'npy_partition.h'),
+            join('src', 'npysort', 'selection.cpp'),
+            join('src', 'common', 'npy_binsearch.h'),
+            join('src', 'npysort', 'binsearch.cpp'),
+            join('src', 'multiarray', 'textreading', 'conversions.c'),
+            join('src', 'multiarray', 'textreading', 'field_types.c'),
+            join('src', 'multiarray', 'textreading', 'growth.c'),
+            join('src', 'multiarray', 'textreading', 'readtext.c'),
+            join('src', 'multiarray', 'textreading', 'rows.c'),
+            join('src', 'multiarray', 'textreading', 'stream_pyobject.c'),
+            join('src', 'multiarray', 'textreading', 'str_to_int.c'),
+            join('src', 'multiarray', 'textreading', 'tokenize.cpp'),
+            # Remove this once scipy macos arm64 build correctly
+            # links to the arm64 npymath library,
+            # see gh-22673
+            join('src', 'npymath', 'arm64_exports.c'),
             ]
 
     #######################################################################
@@ -965,6 +1024,21 @@ def generate_umath_c(ext, build_dir):
                                                  generate_umath.__file__))
         return []
 
+    def generate_umath_doc_header(ext, build_dir):
+        from numpy.distutils.misc_util import exec_mod_from_location
+
+        target = join(build_dir, header_dir, '_umath_doc_generated.h')
+        dir = os.path.dirname(target)
+        if not os.path.exists(dir):
+            os.makedirs(dir)
+
+        generate_umath_doc_py = join(codegen_dir, 'generate_umath_doc.py')
+        if newer(generate_umath_doc_py, target):
+            n = dot_join(config.name, 'generate_umath_doc')
+            generate_umath_doc = exec_mod_from_location(
+                '_'.join(n.split('.')), generate_umath_doc_py)
+            generate_umath_doc.write_code(target)
+
     umath_src = [
             join('src', 'umath', 'umathmodule.c'),
             join('src', 'umath', 'reduction.c'),
@@ -976,20 +1050,26 @@ def generate_umath_c(ext, build_dir):
             join('src', 'umath', 'loops_unary_fp.dispatch.c.src'),
             join('src', 'umath', 'loops_arithm_fp.dispatch.c.src'),
             join('src', 'umath', 'loops_arithmetic.dispatch.c.src'),
+            join('src', 'umath', 'loops_minmax.dispatch.c.src'),
             join('src', 'umath', 'loops_trigonometric.dispatch.c.src'),
             join('src', 'umath', 'loops_umath_fp.dispatch.c.src'),
             join('src', 'umath', 'loops_exponent_log.dispatch.c.src'),
+            join('src', 'umath', 'loops_hyperbolic.dispatch.c.src'),
+            join('src', 'umath', 'loops_modulo.dispatch.c.src'),
+            join('src', 'umath', 'loops_comparison.dispatch.c.src'),
             join('src', 'umath', 'matmul.h.src'),
             join('src', 'umath', 'matmul.c.src'),
             join('src', 'umath', 'clip.h'),
             join('src', 'umath', 'clip.cpp'),
             join('src', 'umath', 'dispatching.c'),
             join('src', 'umath', 'legacy_array_method.c'),
+            join('src', 'umath', 'wrapping_array_method.c'),
             join('src', 'umath', 'ufunc_object.c'),
             join('src', 'umath', 'extobj.c'),
             join('src', 'umath', 'scalarmath.c.src'),
             join('src', 'umath', 'ufunc_type_resolution.c'),
             join('src', 'umath', 'override.c'),
+            join('src', 'umath', 'string_ufuncs.cpp'),
             # For testing. Eventually, should use public API and be separate:
             join('src', 'umath', '_scaled_float_dtype.c'),
             ]
@@ -1004,12 +1084,25 @@ def generate_umath_c(ext, build_dir):
             join('src', 'umath', 'simd.inc.src'),
             join('src', 'umath', 'override.h'),
             join(codegen_dir, 'generate_ufunc_api.py'),
+            join(codegen_dir, 'ufunc_docstrings.py'),
             ]
 
     svml_path = join('numpy', 'core', 'src', 'umath', 'svml')
     svml_objs = []
+    # we have converted the following into universal intrinsics
+    # so we can bring the benefits of performance for all platforms
+    # not just for avx512 on linux without performance/accuracy regression,
+    # actually the other way around, better performance and
+    # after all maintainable code.
+    svml_filter = (
+    )
     if can_link_svml() and check_svml_submodule(svml_path):
         svml_objs = glob.glob(svml_path + '/**/*.s', recursive=True)
+        svml_objs = [o for o in svml_objs if not o.endswith(svml_filter)]
+
+        # The ordering of names returned by glob is undefined, so we sort
+        # to make builds reproducible.
+        svml_objs.sort()
 
     config.add_extension('_multiarray_umath',
                          # Forcing C language even though we have C++ sources.
@@ -1023,6 +1116,7 @@ def generate_umath_c(ext, build_dir):
                                   join(codegen_dir, 'generate_numpy_api.py'),
                                   join('*.py'),
                                   generate_umath_c,
+                                  generate_umath_doc_header,
                                   generate_ufunc_api,
                                  ],
                          depends=deps + multiarray_deps + umath_deps +
@@ -1030,10 +1124,7 @@ def generate_umath_c(ext, build_dir):
                          libraries=['npymath'],
                          extra_objects=svml_objs,
                          extra_info=extra_info,
-                         extra_cxx_compile_args=['-std=c++11',
-                                                 '-D__STDC_VERSION__=0',
-                                                 '-fno-exceptions',
-                                                 '-fno-rtti'])
+                         extra_cxx_compile_args=NPY_CXX_FLAGS)
 
     #######################################################################
     #                        umath_tests module                           #
@@ -1042,7 +1133,7 @@ def generate_umath_c(ext, build_dir):
     config.add_extension('_umath_tests', sources=[
         join('src', 'umath', '_umath_tests.c.src'),
         join('src', 'umath', '_umath_tests.dispatch.c'),
-        join('src', 'common', 'npy_cpu_features.c.src'),
+        join('src', 'common', 'npy_cpu_features.c'),
     ])
 
     #######################################################################
@@ -1050,14 +1141,14 @@ def generate_umath_c(ext, build_dir):
     #######################################################################
 
     config.add_extension('_rational_tests',
-                    sources=[join('src', 'umath', '_rational_tests.c.src')])
+                    sources=[join('src', 'umath', '_rational_tests.c')])
 
     #######################################################################
     #                        struct_ufunc_test module                     #
     #######################################################################
 
     config.add_extension('_struct_ufunc_tests',
-                    sources=[join('src', 'umath', '_struct_ufunc_tests.c.src')])
+                    sources=[join('src', 'umath', '_struct_ufunc_tests.c')])
 
 
     #######################################################################
@@ -1065,29 +1156,32 @@ def generate_umath_c(ext, build_dir):
     #######################################################################
 
     config.add_extension('_operand_flag_tests',
-                    sources=[join('src', 'umath', '_operand_flag_tests.c.src')])
+                    sources=[join('src', 'umath', '_operand_flag_tests.c')])
 
     #######################################################################
     #                        SIMD module                                  #
     #######################################################################
 
-    config.add_extension('_simd', sources=[
-        join('src', 'common', 'npy_cpu_features.c.src'),
-        join('src', '_simd', '_simd.c'),
-        join('src', '_simd', '_simd_inc.h.src'),
-        join('src', '_simd', '_simd_data.inc.src'),
-        join('src', '_simd', '_simd.dispatch.c.src'),
-    ], depends=[
-        join('src', 'common', 'npy_cpu_dispatch.h'),
-        join('src', 'common', 'simd', 'simd.h'),
-        join('src', '_simd', '_simd.h'),
-        join('src', '_simd', '_simd_inc.h.src'),
-        join('src', '_simd', '_simd_data.inc.src'),
-        join('src', '_simd', '_simd_arg.inc'),
-        join('src', '_simd', '_simd_convert.inc'),
-        join('src', '_simd', '_simd_easyintrin.inc'),
-        join('src', '_simd', '_simd_vector.inc'),
-    ])
+    config.add_extension('_simd',
+        sources=[
+            join('src', 'common', 'npy_cpu_features.c'),
+            join('src', '_simd', '_simd.c'),
+            join('src', '_simd', '_simd_inc.h.src'),
+            join('src', '_simd', '_simd_data.inc.src'),
+            join('src', '_simd', '_simd.dispatch.c.src'),
+        ], depends=[
+            join('src', 'common', 'npy_cpu_dispatch.h'),
+            join('src', 'common', 'simd', 'simd.h'),
+            join('src', '_simd', '_simd.h'),
+            join('src', '_simd', '_simd_inc.h.src'),
+            join('src', '_simd', '_simd_data.inc.src'),
+            join('src', '_simd', '_simd_arg.inc'),
+            join('src', '_simd', '_simd_convert.inc'),
+            join('src', '_simd', '_simd_easyintrin.inc'),
+            join('src', '_simd', '_simd_vector.inc'),
+        ],
+        libraries=['npymath']
+    )
 
     config.add_subpackage('tests')
     config.add_data_dir('tests/data')
diff --git a/numpy/core/setup_common.py b/numpy/core/setup_common.py
index 70e8fc89705a..0512457f4869 100644
--- a/numpy/core/setup_common.py
+++ b/numpy/core/setup_common.py
@@ -1,7 +1,7 @@
 # Code common to build tools
-import sys
-import warnings
 import copy
+import pathlib
+import sys
 import textwrap
 
 from numpy.distutils.misc_util import mingw32
@@ -30,6 +30,8 @@
 # (*not* C_ABI_VERSION) would be increased.  Whenever binary compatibility is
 # broken, both C_API_VERSION and C_ABI_VERSION should be increased.
 #
+# The version needs to be kept in sync with that in cversions.txt.
+#
 # 0x00000008 - 1.7.x
 # 0x00000009 - 1.8.x
 # 0x00000009 - 1.9.x
@@ -44,22 +46,13 @@
 # 0x0000000e - 1.20.x
 # 0x0000000e - 1.21.x
 # 0x0000000f - 1.22.x
-C_API_VERSION = 0x0000000f
+# 0x00000010 - 1.23.x
+# 0x00000010 - 1.24.x
+C_API_VERSION = 0x00000010
 
-class MismatchCAPIWarning(Warning):
+class MismatchCAPIError(ValueError):
     pass
 
-def is_released(config):
-    """Return True if a released version of numpy is detected."""
-    from distutils.version import LooseVersion
-
-    v = config.get_version('../_version.py')
-    if v is None:
-        raise ValueError("Could not get version")
-    pv = LooseVersion(vstring=v).version
-    if len(pv) > 3:
-        return False
-    return True
 
 def get_api_versions(apiversion, codegen_dir):
     """
@@ -93,27 +86,77 @@ def check_api_version(apiversion, codegen_dir):
     # To compute the checksum of the current API, use numpy/core/cversions.py
     if not curapi_hash == api_hash:
         msg = ("API mismatch detected, the C API version "
-               "numbers have to be updated. Current C api version is %d, "
-               "with checksum %s, but recorded checksum for C API version %d "
-               "in core/codegen_dir/cversions.txt is %s. If functions were "
-               "added in the C API, you have to update C_API_VERSION in %s."
+               "numbers have to be updated. Current C api version is "
+               f"{apiversion}, with checksum {curapi_hash}, but recorded "
+               f"checksum in core/codegen_dir/cversions.txt is {api_hash}. If "
+               "functions were added in the C API, you have to update "
+               f"C_API_VERSION in {__file__}."
                )
-        warnings.warn(msg % (apiversion, curapi_hash, apiversion, api_hash,
-                             __file__),
-                      MismatchCAPIWarning, stacklevel=2)
+        raise MismatchCAPIError(msg)
+
+
+FUNC_CALL_ARGS = {}
+
+def set_sig(sig):
+    prefix, _, args = sig.partition("(")
+    args = args.rpartition(")")[0]
+    funcname = prefix.rpartition(" ")[-1]
+    args = [arg.strip() for arg in args.split(",")]
+    # We use {0} because 0 alone cannot be cast to complex on MSVC in C:
+    FUNC_CALL_ARGS[funcname] = ", ".join("(%s){0}" % arg for arg in args)
+
+
+for file in [
+    "feature_detection_locale.h",
+    "feature_detection_math.h",
+    "feature_detection_cmath.h",
+    "feature_detection_misc.h",
+    "feature_detection_stdio.h",
+]:
+    with open(pathlib.Path(__file__).parent / file) as f:
+        for line in f:
+            if line.startswith("#"):
+                continue
+            if not line.strip():
+                continue
+            set_sig(line)
+
 # Mandatory functions: if not found, fail the build
-MANDATORY_FUNCS = ["sin", "cos", "tan", "sinh", "cosh", "tanh", "fabs",
-        "floor", "ceil", "sqrt", "log10", "log", "exp", "asin",
-        "acos", "atan", "fmod", 'modf', 'frexp', 'ldexp']
+# Some of these can still be blocklisted if the C99 implementation
+# is buggy, see numpy/core/src/common/npy_config.h
+MANDATORY_FUNCS = [
+    "sin", "cos", "tan", "sinh", "cosh", "tanh", "fabs",
+    "floor", "ceil", "sqrt", "log10", "log", "exp", "asin",
+    "acos", "atan", "fmod", 'modf', 'frexp', 'ldexp',
+    "expm1", "log1p", "acosh", "asinh", "atanh",
+    "rint", "trunc", "exp2",
+    "copysign", "nextafter", "strtoll", "strtoull", "cbrt",
+    "log2", "pow", "hypot", "atan2",
+    "creal", "cimag", "conj"
+]
 
-# Standard functions which may not be available and for which we have a
-# replacement implementation. Note that some of these are C99 functions.
-OPTIONAL_STDFUNCS = ["expm1", "log1p", "acosh", "asinh", "atanh",
-        "rint", "trunc", "exp2", "log2", "hypot", "atan2", "pow",
-        "copysign", "nextafter", "ftello", "fseeko",
-        "strtoll", "strtoull", "cbrt", "strtold_l", "fallocate",
-        "backtrace", "madvise"]
+OPTIONAL_LOCALE_FUNCS = ["strtold_l"]
+OPTIONAL_FILE_FUNCS = ["ftello", "fseeko", "fallocate"]
+OPTIONAL_MISC_FUNCS = ["backtrace", "madvise"]
+
+# variable attributes tested via "int %s a" % attribute
+OPTIONAL_VARIABLE_ATTRIBUTES = ["__thread", "__declspec(thread)"]
 
+# Subset of OPTIONAL_*_FUNCS which may already have HAVE_* defined by Python.h
+OPTIONAL_FUNCS_MAYBE = [
+    "ftello", "fseeko"
+    ]
+
+C99_COMPLEX_TYPES = [
+    'complex double', 'complex float', 'complex long double'
+    ]
+C99_COMPLEX_FUNCS = [
+    "cabs", "cacos", "cacosh", "carg", "casin", "casinh", "catan",
+    "catanh", "cexp", "clog", "cpow", "csqrt",
+    # The long double variants (like csinl)  should be mandatory on C11,
+    # but are missing in FreeBSD. Issue gh-22850
+    "csin", "csinh", "ccos", "ccosh", "ctan", "ctanh",
+    ]
 
 OPTIONAL_HEADERS = [
 # sse headers only enabled automatically on amd64/x32 builds
@@ -122,7 +165,9 @@ def check_api_version(apiversion, codegen_dir):
                 "immintrin.h",  # AVX
                 "features.h",  # for glibc version linux
                 "xlocale.h",  # see GH#8367
-                "dlfcn.h", # dladdr
+                "dlfcn.h",  # dladdr
+                "execinfo.h",  # backtrace
+                "libunwind.h",  # backtrace for LLVM/Clang using libunwind
                 "sys/mman.h", #madvise
 ]
 
@@ -135,7 +180,9 @@ def check_api_version(apiversion, codegen_dir):
                        ("__builtin_bswap32", '5u'),
                        ("__builtin_bswap64", '5u'),
                        ("__builtin_expect", '5, 0'),
-                       ("__builtin_mul_overflow", '5, 5, (int*)5'),
+                       # Test `long long` for arm+clang 13 (gh-22811,
+                       # but we use all versions of __builtin_mul_overflow):
+                       ("__builtin_mul_overflow", '(long long)5, 5, (int*)5'),
                        # MMX only needed for icc, but some clangs don't have it
                        ("_m_from_int64", '0', "emmintrin.h"),
                        ("_mm_load_ps", '(float*)0', "xmmintrin.h"),  # SSE
@@ -164,18 +211,22 @@ def check_api_version(apiversion, codegen_dir):
                                 'attribute_optimize_unroll_loops'),
                                 ('__attribute__((optimize("O3")))',
                                  'attribute_optimize_opt_3'),
+                                ('__attribute__((optimize("O2")))',
+                                 'attribute_optimize_opt_2'),
                                 ('__attribute__((nonnull (1)))',
                                  'attribute_nonnull'),
-                                ('__attribute__((target ("avx")))',
-                                 'attribute_target_avx'),
-                                ('__attribute__((target ("avx2")))',
-                                 'attribute_target_avx2'),
-                                ('__attribute__((target ("avx512f")))',
-                                 'attribute_target_avx512f'),
-                                ('__attribute__((target ("avx512f,avx512dq,avx512bw,avx512vl,avx512cd")))',
-                                 'attribute_target_avx512_skx'),
                                 ]
 
+OPTIONAL_FUNCTION_ATTRIBUTES_AVX = [('__attribute__((target ("avx")))',
+    'attribute_target_avx'),
+    ('__attribute__((target ("avx2")))',
+    'attribute_target_avx2'),
+    ('__attribute__((target ("avx512f")))',
+    'attribute_target_avx512f'),
+    ('__attribute__((target ("avx512f,avx512dq,avx512bw,avx512vl,avx512cd")))',
+    'attribute_target_avx512_skx'),
+    ]
+
 # function attributes with intrinsics
 # To ensure your compiler can compile avx intrinsics with just the attributes
 # gcc 4.8.4 support attributes but not with intrisics
@@ -184,50 +235,23 @@ def check_api_version(apiversion, codegen_dir):
 # The _mm512_castps_si512 instruction is specific check for AVX-512F support
 # in gcc-4.9 which is missing a subset of intrinsics. See
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61878
-OPTIONAL_FUNCTION_ATTRIBUTES_WITH_INTRINSICS = [('__attribute__((target("avx2,fma")))',
-                                'attribute_target_avx2_with_intrinsics',
-                                '__m256 temp = _mm256_set1_ps(1.0); temp = \
-                                _mm256_fmadd_ps(temp, temp, temp)',
-                                'immintrin.h'),
-                                ('__attribute__((target("avx512f")))',
-                                'attribute_target_avx512f_with_intrinsics',
-                                '__m512i temp = _mm512_castps_si512(_mm512_set1_ps(1.0))',
-                                'immintrin.h'),
-                                ('__attribute__((target ("avx512f,avx512dq,avx512bw,avx512vl,avx512cd")))',
-                                'attribute_target_avx512_skx_with_intrinsics',
-                                '__mmask8 temp = _mm512_fpclass_pd_mask(_mm512_set1_pd(1.0), 0x01);\
-                                __m512i unused_temp = \
-                                    _mm512_castps_si512(_mm512_set1_ps(1.0));\
-                                _mm_mask_storeu_epi8(NULL, 0xFF, _mm_broadcastmb_epi64(temp))',
-                                'immintrin.h'),
-                                ]
-
-# variable attributes tested via "int %s a" % attribute
-OPTIONAL_VARIABLE_ATTRIBUTES = ["__thread", "__declspec(thread)"]
-
-# Subset of OPTIONAL_STDFUNCS which may already have HAVE_* defined by Python.h
-OPTIONAL_STDFUNCS_MAYBE = [
-    "expm1", "log1p", "acosh", "atanh", "asinh", "hypot", "copysign",
-    "ftello", "fseeko"
-    ]
-
-# C99 functions: float and long double versions
-C99_FUNCS = [
-    "sin", "cos", "tan", "sinh", "cosh", "tanh", "fabs", "floor", "ceil",
-    "rint", "trunc", "sqrt", "log10", "log", "log1p", "exp", "expm1",
-    "asin", "acos", "atan", "asinh", "acosh", "atanh", "hypot", "atan2",
-    "pow", "fmod", "modf", 'frexp', 'ldexp', "exp2", "log2", "copysign",
-    "nextafter", "cbrt"
-    ]
-C99_FUNCS_SINGLE = [f + 'f' for f in C99_FUNCS]
-C99_FUNCS_EXTENDED = [f + 'l' for f in C99_FUNCS]
-C99_COMPLEX_TYPES = [
-    'complex double', 'complex float', 'complex long double'
-    ]
-C99_COMPLEX_FUNCS = [
-    "cabs", "cacos", "cacosh", "carg", "casin", "casinh", "catan",
-    "catanh", "ccos", "ccosh", "cexp", "cimag", "clog", "conj", "cpow",
-    "cproj", "creal", "csin", "csinh", "csqrt", "ctan", "ctanh"
+OPTIONAL_FUNCTION_ATTRIBUTES_WITH_INTRINSICS_AVX = [
+    ('__attribute__((target("avx2,fma")))',
+    'attribute_target_avx2_with_intrinsics',
+    '__m256 temp = _mm256_set1_ps(1.0); temp = \
+    _mm256_fmadd_ps(temp, temp, temp)',
+    'immintrin.h'),
+    ('__attribute__((target("avx512f")))',
+    'attribute_target_avx512f_with_intrinsics',
+    '__m512i temp = _mm512_castps_si512(_mm512_set1_ps(1.0))',
+    'immintrin.h'),
+    ('__attribute__((target ("avx512f,avx512dq,avx512bw,avx512vl,avx512cd")))',
+    'attribute_target_avx512_skx_with_intrinsics',
+    '__mmask8 temp = _mm512_fpclass_pd_mask(_mm512_set1_pd(1.0), 0x01);\
+    __m512i unused_temp = \
+        _mm512_castps_si512(_mm512_set1_ps(1.0));\
+    _mm_mask_storeu_epi8(NULL, 0xFF, _mm_broadcastmb_epi64(temp))',
+    'immintrin.h'),
     ]
 
 def fname2def(name):
diff --git a/numpy/core/shape_base.py b/numpy/core/shape_base.py
index a81a04f7ff0e..84a6bd671de9 100644
--- a/numpy/core/shape_base.py
+++ b/numpy/core/shape_base.py
@@ -215,12 +215,13 @@ def _arrays_for_stack_dispatcher(arrays, stacklevel=4):
     return arrays
 
 
-def _vhstack_dispatcher(tup):
+def _vhstack_dispatcher(tup, *, 
+                        dtype=None, casting=None):
     return _arrays_for_stack_dispatcher(tup)
 
 
 @array_function_dispatch(_vhstack_dispatcher)
-def vstack(tup):
+def vstack(tup, *, dtype=None, casting="same_kind"):
     """
     Stack arrays in sequence vertically (row wise).
 
@@ -233,12 +234,25 @@ def vstack(tup):
     and r/g/b channels (third axis). The functions `concatenate`, `stack` and
     `block` provide more general stacking and concatenation operations.
 
+    ``np.row_stack`` is an alias for `vstack`. They are the same function.
+
     Parameters
     ----------
     tup : sequence of ndarrays
         The arrays must have the same shape along all but the first axis.
         1-D arrays must have the same length.
 
+    dtype : str or dtype
+        If provided, the destination array will have this dtype. Cannot be
+        provided together with `out`.
+
+    .. versionadded:: 1.24
+
+    casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
+        Controls what kind of data casting may occur. Defaults to 'same_kind'.
+
+    .. versionadded:: 1.24
+
     Returns
     -------
     stacked : ndarray
@@ -279,11 +293,11 @@ def vstack(tup):
     arrs = atleast_2d(*tup)
     if not isinstance(arrs, list):
         arrs = [arrs]
-    return _nx.concatenate(arrs, 0)
+    return _nx.concatenate(arrs, 0, dtype=dtype, casting=casting)
 
 
 @array_function_dispatch(_vhstack_dispatcher)
-def hstack(tup):
+def hstack(tup, *, dtype=None, casting="same_kind"):
     """
     Stack arrays in sequence horizontally (column wise).
 
@@ -302,6 +316,17 @@ def hstack(tup):
         The arrays must have the same shape along all but the second axis,
         except 1-D arrays which can be any length.
 
+    dtype : str or dtype
+        If provided, the destination array will have this dtype. Cannot be
+        provided together with `out`.
+
+    .. versionadded:: 1.24
+
+    casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
+        Controls what kind of data casting may occur. Defaults to 'same_kind'.
+
+    .. versionadded:: 1.24
+
     Returns
     -------
     stacked : ndarray
@@ -340,12 +365,13 @@ def hstack(tup):
         arrs = [arrs]
     # As a special case, dimension 0 of 1-dimensional arrays is "horizontal"
     if arrs and arrs[0].ndim == 1:
-        return _nx.concatenate(arrs, 0)
+        return _nx.concatenate(arrs, 0, dtype=dtype, casting=casting)
     else:
-        return _nx.concatenate(arrs, 1)
+        return _nx.concatenate(arrs, 1, dtype=dtype, casting=casting)
 
 
-def _stack_dispatcher(arrays, axis=None, out=None):
+def _stack_dispatcher(arrays, axis=None, out=None, *,
+                      dtype=None, casting=None):
     arrays = _arrays_for_stack_dispatcher(arrays, stacklevel=6)
     if out is not None:
         # optimize for the typical case where only arrays is provided
@@ -355,7 +381,7 @@ def _stack_dispatcher(arrays, axis=None, out=None):
 
 
 @array_function_dispatch(_stack_dispatcher)
-def stack(arrays, axis=0, out=None):
+def stack(arrays, axis=0, out=None, *, dtype=None, casting="same_kind"):
     """
     Join a sequence of arrays along a new axis.
 
@@ -378,6 +404,18 @@ def stack(arrays, axis=0, out=None):
         correct, matching that of what stack would have returned if no
         out argument were specified.
 
+    dtype : str or dtype
+        If provided, the destination array will have this dtype. Cannot be
+        provided together with `out`.
+
+        .. versionadded:: 1.24
+
+    casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
+        Controls what kind of data casting may occur. Defaults to 'same_kind'.
+
+        .. versionadded:: 1.24
+
+
     Returns
     -------
     stacked : ndarray
@@ -430,7 +468,8 @@ def stack(arrays, axis=0, out=None):
 
     sl = (slice(None),) * axis + (_nx.newaxis,)
     expanded_arrays = [arr[sl] for arr in arrays]
-    return _nx.concatenate(expanded_arrays, axis=axis, out=out)
+    return _nx.concatenate(expanded_arrays, axis=axis, out=out,
+                           dtype=dtype, casting=casting)
 
 
 # Internal functions to eliminate the overhead of repeated dispatch in one of
@@ -438,7 +477,8 @@ def stack(arrays, axis=0, out=None):
 # Use getattr to protect against __array_function__ being disabled.
 _size = getattr(_from_nx.size, '__wrapped__', _from_nx.size)
 _ndim = getattr(_from_nx.ndim, '__wrapped__', _from_nx.ndim)
-_concatenate = getattr(_from_nx.concatenate, '__wrapped__', _from_nx.concatenate)
+_concatenate = getattr(_from_nx.concatenate,
+                       '__wrapped__', _from_nx.concatenate)
 
 
 def _block_format_index(index):
@@ -539,29 +579,27 @@ def _concatenate_shapes(shapes, axis):
     """Given array shapes, return the resulting shape and slices prefixes.
 
     These help in nested concatenation.
-    
+
     Returns
     -------
     shape: tuple of int
-        This tuple satisfies:
-        ```
-        shape, _ = _concatenate_shapes([arr.shape for shape in arrs], axis)
-        shape == concatenate(arrs, axis).shape
-        ```
+        This tuple satisfies::
+
+            shape, _ = _concatenate_shapes([arr.shape for shape in arrs], axis)
+            shape == concatenate(arrs, axis).shape
 
     slice_prefixes: tuple of (slice(start, end), )
         For a list of arrays being concatenated, this returns the slice
         in the larger array at axis that needs to be sliced into.
 
-        For example, the following holds:
-        ```
-        ret = concatenate([a, b, c], axis)
-        _, (sl_a, sl_b, sl_c) = concatenate_slices([a, b, c], axis)
+        For example, the following holds::
+
+            ret = concatenate([a, b, c], axis)
+            _, (sl_a, sl_b, sl_c) = concatenate_slices([a, b, c], axis)
 
-        ret[(slice(None),) * axis + sl_a] == a
-        ret[(slice(None),) * axis + sl_b] == b
-        ret[(slice(None),) * axis + sl_c] == c
-        ```
+            ret[(slice(None),) * axis + sl_a] == a
+            ret[(slice(None),) * axis + sl_b] == b
+            ret[(slice(None),) * axis + sl_c] == c
 
         These are called slice prefixes since they are used in the recursive
         blocking algorithm to compute the left-most slices during the
diff --git a/numpy/core/shape_base.pyi b/numpy/core/shape_base.pyi
index 159ad2781c05..10116f1ee9e7 100644
--- a/numpy/core/shape_base.pyi
+++ b/numpy/core/shape_base.pyi
@@ -1,63 +1,120 @@
-from typing import TypeVar, overload, List, Sequence, Any, SupportsIndex
+from collections.abc import Sequence
+from typing import TypeVar, overload, Any, SupportsIndex
 
-from numpy import generic, dtype
-from numpy.typing import ArrayLike, NDArray, _FiniteNestedSequence, _SupportsArray
+from numpy import generic, _CastingKind
+from numpy._typing import (
+    NDArray,
+    ArrayLike,
+    DTypeLike,
+    _ArrayLike,
+    _DTypeLike,
+)
 
 _SCT = TypeVar("_SCT", bound=generic)
 _ArrayType = TypeVar("_ArrayType", bound=NDArray[Any])
 
-_ArrayLike = _FiniteNestedSequence[_SupportsArray[dtype[_SCT]]]
-
-__all__: List[str]
+__all__: list[str]
 
 @overload
 def atleast_1d(arys: _ArrayLike[_SCT], /) -> NDArray[_SCT]: ...
 @overload
 def atleast_1d(arys: ArrayLike, /) -> NDArray[Any]: ...
 @overload
-def atleast_1d(*arys: ArrayLike) -> List[NDArray[Any]]: ...
+def atleast_1d(*arys: ArrayLike) -> list[NDArray[Any]]: ...
 
 @overload
 def atleast_2d(arys: _ArrayLike[_SCT], /) -> NDArray[_SCT]: ...
 @overload
 def atleast_2d(arys: ArrayLike, /) -> NDArray[Any]: ...
 @overload
-def atleast_2d(*arys: ArrayLike) -> List[NDArray[Any]]: ...
+def atleast_2d(*arys: ArrayLike) -> list[NDArray[Any]]: ...
 
 @overload
 def atleast_3d(arys: _ArrayLike[_SCT], /) -> NDArray[_SCT]: ...
 @overload
 def atleast_3d(arys: ArrayLike, /) -> NDArray[Any]: ...
 @overload
-def atleast_3d(*arys: ArrayLike) -> List[NDArray[Any]]: ...
+def atleast_3d(*arys: ArrayLike) -> list[NDArray[Any]]: ...
 
 @overload
-def vstack(tup: Sequence[_ArrayLike[_SCT]]) -> NDArray[_SCT]: ...
+def vstack(
+    tup: Sequence[_ArrayLike[_SCT]],
+    *,
+    dtype: None = ...,
+    casting: _CastingKind = ...
+) -> NDArray[_SCT]: ...
+@overload
+def vstack(
+    tup: Sequence[ArrayLike],
+    *,
+    dtype: _DTypeLike[_SCT],
+    casting: _CastingKind = ...
+) -> NDArray[_SCT]: ...
 @overload
-def vstack(tup: Sequence[ArrayLike]) -> NDArray[Any]: ...
+def vstack(
+    tup: Sequence[ArrayLike],
+    *,
+    dtype: DTypeLike = ...,
+    casting: _CastingKind = ...
+) -> NDArray[Any]: ...
 
 @overload
-def hstack(tup: Sequence[_ArrayLike[_SCT]]) -> NDArray[_SCT]: ...
+def hstack(
+    tup: Sequence[_ArrayLike[_SCT]],
+    *,
+    dtype: None = ...,
+    casting: _CastingKind = ...
+) -> NDArray[_SCT]: ...
+@overload
+def hstack(
+    tup: Sequence[ArrayLike],
+    *,
+    dtype: _DTypeLike[_SCT],
+    casting: _CastingKind = ...
+) -> NDArray[_SCT]: ...
 @overload
-def hstack(tup: Sequence[ArrayLike]) -> NDArray[Any]: ...
+def hstack(
+    tup: Sequence[ArrayLike],
+    *,
+    dtype: DTypeLike = ...,
+    casting: _CastingKind = ...
+) -> NDArray[Any]: ...
 
 @overload
 def stack(
     arrays: Sequence[_ArrayLike[_SCT]],
     axis: SupportsIndex = ...,
     out: None = ...,
+    *,
+    dtype: None = ...,
+    casting: _CastingKind = ...
+) -> NDArray[_SCT]: ...
+@overload
+def stack(
+    arrays: Sequence[ArrayLike],
+    axis: SupportsIndex = ...,
+    out: None = ...,
+    *,
+    dtype: _DTypeLike[_SCT],
+    casting: _CastingKind = ...
 ) -> NDArray[_SCT]: ...
 @overload
 def stack(
     arrays: Sequence[ArrayLike],
     axis: SupportsIndex = ...,
     out: None = ...,
+    *,
+    dtype: DTypeLike = ...,
+    casting: _CastingKind = ...
 ) -> NDArray[Any]: ...
 @overload
 def stack(
     arrays: Sequence[ArrayLike],
     axis: SupportsIndex = ...,
     out: _ArrayType = ...,
+    *,
+    dtype: DTypeLike = ...,
+    casting: _CastingKind = ...
 ) -> _ArrayType: ...
 
 @overload
diff --git a/numpy/core/src/_simd/_simd.c b/numpy/core/src/_simd/_simd.c
index b1fdd4478d9d..52b66e7652a8 100644
--- a/numpy/core/src/_simd/_simd.c
+++ b/numpy/core/src/_simd/_simd.c
@@ -1,11 +1,33 @@
 #include "_simd.h"
 
+#include "numpy/npy_math.h"
+
+static PyObject *
+get_floatstatus(PyObject* NPY_UNUSED(self), PyObject *NPY_UNUSED(args))
+{
+    return PyLong_FromLong(npy_get_floatstatus());
+}
+
+static PyObject *
+clear_floatstatus(PyObject* NPY_UNUSED(self), PyObject *NPY_UNUSED(args))
+{
+    npy_clear_floatstatus();
+    Py_RETURN_NONE;
+}
+
+static PyMethodDef _simd_methods[] = {
+    {"get_floatstatus", get_floatstatus, METH_NOARGS, NULL},
+    {"clear_floatstatus", clear_floatstatus, METH_NOARGS, NULL},
+    {NULL, NULL, 0, NULL}
+};
+
 PyMODINIT_FUNC PyInit__simd(void)
 {
     static struct PyModuleDef defs = {
         .m_base = PyModuleDef_HEAD_INIT,
         .m_name = "numpy.core._simd",
-        .m_size = -1
+        .m_size = -1,
+        .m_methods = _simd_methods
     };
     if (npy_cpu_init() < 0) {
         return NULL;
diff --git a/numpy/core/src/_simd/_simd.dispatch.c.src b/numpy/core/src/_simd/_simd.dispatch.c.src
index 84de9a059fc8..48023af801d7 100644
--- a/numpy/core/src/_simd/_simd.dispatch.c.src
+++ b/numpy/core/src/_simd/_simd.dispatch.c.src
@@ -15,9 +15,10 @@
 /**begin repeat
  * #sfx       = u8, s8, u16, s16, u32, s32, u64, s64, f32, f64#
  * #bsfx      = b8, b8, b16, b16, b32, b32, b64, b64, b32, b64#
- * #esfx      = u16, s8, u32,s16, u32, s32, u64, s64, f32, f64#
+ * #esfx      = u16,s8, u32, s16, u32, s32, u64, s64, f32, f64#
+ * #size      = 8,  8,  16,  16,  32,  32,  64,  64,  32,  64#
  * #expand_sup= 1,  0,  1,   0,   0,   0,   0,   0,   0,   0#
- * #simd_sup  = 1,  1,  1,   1,   1,   1,   1,   1,   1,   NPY_SIMD_F64#
+ * #simd_sup  = 1,  1,  1,   1,   1,   1,   1,   1,   NPY_SIMD_F32, NPY_SIMD_F64#
  * #fp_only   = 0,  0,  0,   0,   0,   0,   0,   0,   1,   1#
  * #sat_sup   = 1,  1,  1,   1,   0,   0,   0,   0,   0,   0#
  * #mul_sup   = 1,  1,  1,   1,   1,   1,   0,   0,   1,   1#
@@ -30,6 +31,7 @@
  * #intdiv_sup= 1,  1,  1,   1,   1,   1,   1,   1,   0,   0#
  * #shl_imm   = 0,  0,  15,  15,  31,  31,  63,  63,  0,   0#
  * #shr_imm   = 0,  0,  16,  16,  32,  32,  64,  64,  0,   0#
+ * #bitw8b_sup= 1,  0,  0,   0,   0,   0,   0,   0,   0,   0#
  */
 #if @simd_sup@
 /***************************
@@ -232,16 +234,26 @@ err:
 /**end repeat1**/
 #endif // @ncont_sup@
 
+/****************************
+ * Lookup tables
+ ****************************/
+#if @size@ == 32
+SIMD_IMPL_INTRIN_2(lut32_@sfx@, v@sfx@, q@sfx@, vu@size@)
+#endif
+#if @size@ == 64
+SIMD_IMPL_INTRIN_2(lut16_@sfx@, v@sfx@, q@sfx@, vu@size@)
+#endif
 /***************************
  * Misc
  ***************************/
 SIMD_IMPL_INTRIN_0(zero_@sfx@, v@sfx@)
+SIMD_IMPL_INTRIN_1(extract0_@sfx@, @sfx@, v@sfx@)
 SIMD_IMPL_INTRIN_1(setall_@sfx@, v@sfx@, @sfx@)
 SIMD_IMPL_INTRIN_3(select_@sfx@, v@sfx@, v@bsfx@, v@sfx@, v@sfx@)
 
 /**begin repeat1
  * #sfx_to     = u8, s8, u16, s16, u32, s32, u64, s64, f32, f64#
- * #simd_sup2  = 1,  1,  1,   1,   1,   1,   1,   1,   1,   NPY_SIMD_F64#
+ * #simd_sup2  = 1,  1,  1,   1,   1,   1,   1,   1,   NPY_SIMD_F32, NPY_SIMD_F64#
  */
 #if @simd_sup2@
 SIMD_IMPL_INTRIN_1(reinterpret_@sfx_to@_@sfx@, v@sfx_to@, v@sfx@)
@@ -322,6 +334,19 @@ SIMD_IMPL_INTRIN_1(not_@sfx@, v@sfx@, v@sfx@)
 SIMD_IMPL_INTRIN_2(@intrin@_@sfx@, v@bsfx@, v@sfx@, v@sfx@)
 /**end repeat1**/
 
+#if @bitw8b_sup@
+SIMD_IMPL_INTRIN_2(andc_@sfx@, v@sfx@, v@sfx@, v@sfx@)
+SIMD_IMPL_INTRIN_2(andc_@bsfx@, v@bsfx@, v@bsfx@, v@bsfx@)
+SIMD_IMPL_INTRIN_2(orc_@bsfx@, v@bsfx@, v@bsfx@, v@bsfx@)
+SIMD_IMPL_INTRIN_2(xnor_@bsfx@, v@bsfx@, v@bsfx@, v@bsfx@)
+#endif
+
+// test cross all vector lanes
+/**begin repeat1
+ * #intrin = any, all#
+ */
+SIMD_IMPL_INTRIN_1(@intrin@_@sfx@, u8, v@sfx@)
+/**end repeat1**/
 /***************************
  * Conversion
  ***************************/
@@ -381,7 +406,7 @@ SIMD_IMPL_INTRIN_1(sumup_@sfx@, @esfx@, v@sfx@)
  ***************************/
 #if @fp_only@
 /**begin repeat1
- * #intrin = sqrt, recip, abs, square, ceil, trunc#
+ * #intrin = sqrt, recip, abs, square, rint, ceil, trunc, floor#
  */
 SIMD_IMPL_INTRIN_1(@intrin@_@sfx@, v@sfx@, v@sfx@)
 /**end repeat1**/
@@ -391,13 +416,16 @@ SIMD_IMPL_INTRIN_1(@intrin@_@sfx@, v@sfx@, v@sfx@)
  * #intrin = max, min#
  */
 SIMD_IMPL_INTRIN_2(@intrin@_@sfx@, v@sfx@, v@sfx@, v@sfx@)
+SIMD_IMPL_INTRIN_1(reduce_@intrin@_@sfx@, @sfx@, v@sfx@)
 /**end repeat1**/
 
 #if @fp_only@
 /**begin repeat1
- * #intrin = maxp, minp#
+ * #intrin = maxp, minp, maxn, minn#
  */
 SIMD_IMPL_INTRIN_2(@intrin@_@sfx@, v@sfx@, v@sfx@, v@sfx@)
+SIMD_IMPL_INTRIN_1(reduce_@intrin@_@sfx@, @sfx@, v@sfx@)
+/**end repeat1**/
 /**end repeat1**/
 #endif
 
@@ -424,7 +452,9 @@ SIMD_IMPL_INTRIN_0N(cleanup)
  * Operators
  ***************************/
 // check special cases
-SIMD_IMPL_INTRIN_1(notnan_f32, vb32, vf32)
+#if NPY_SIMD_F32
+    SIMD_IMPL_INTRIN_1(notnan_f32, vb32, vf32)
+#endif
 #if NPY_SIMD_F64
     SIMD_IMPL_INTRIN_1(notnan_f64, vb64, vf64)
 #endif
@@ -432,7 +462,9 @@ SIMD_IMPL_INTRIN_1(notnan_f32, vb32, vf32)
  * Conversions
  ***************************/
 // round to nearest integer (assume even)
-SIMD_IMPL_INTRIN_1(round_s32_f32, vs32, vf32)
+#if NPY_SIMD_F32
+    SIMD_IMPL_INTRIN_1(round_s32_f32, vs32, vf32)
+#endif
 #if NPY_SIMD_F64
     SIMD_IMPL_INTRIN_2(round_s32_f64, vs32, vf64, vf64)
 #endif
@@ -443,14 +475,20 @@ SIMD_IMPL_INTRIN_1(round_s32_f32, vs32, vf32)
 /***************************
  * Operators
  ***************************/
-// Logical
 /**begin repeat
  * #bsfx = b8, b16, b32, b64#
  */
+// Logical
 SIMD_IMPL_INTRIN_2(and_@bsfx@, v@bsfx@, v@bsfx@, v@bsfx@)
 SIMD_IMPL_INTRIN_2(or_@bsfx@,  v@bsfx@, v@bsfx@, v@bsfx@)
 SIMD_IMPL_INTRIN_2(xor_@bsfx@, v@bsfx@, v@bsfx@, v@bsfx@)
 SIMD_IMPL_INTRIN_1(not_@bsfx@, v@bsfx@, v@bsfx@)
+// test cross vector's lanes
+/**begin repeat1
+ * #intrin = any, all#
+ */
+SIMD_IMPL_INTRIN_1(@intrin@_@bsfx@, u8, v@bsfx@)
+/**end repeat1**/
 /**end repeat**/
 /***************************
  * Conversions
@@ -462,6 +500,10 @@ SIMD_IMPL_INTRIN_1(not_@bsfx@, v@bsfx@, v@bsfx@)
 SIMD_IMPL_INTRIN_1(tobits_@bsfx@, u64, v@bsfx@)
 /**end repeat**/
 
+SIMD_IMPL_INTRIN_2(pack_b8_b16, vb8, vb16, vb16)
+SIMD_IMPL_INTRIN_4(pack_b8_b32, vb8, vb32, vb32, vb32, vb32)
+SIMD_IMPL_INTRIN_8(pack_b8_b64, vb8, vb64, vb64, vb64, vb64,
+                                     vb64, vb64, vb64, vb64)
 
 //#########################################################################
 //## Attach module functions
@@ -470,9 +512,10 @@ static PyMethodDef simd__intrinsics_methods[] = {
 /**begin repeat
  * #sfx       = u8, s8, u16, s16, u32, s32, u64, s64, f32, f64#
  * #bsfx      = b8, b8, b16, b16, b32, b32, b64, b64, b32, b64#
+ * #size      = 8,  8,  16,  16,  32,  32,  64,  64,  32,  64#
  * #esfx      = u16, s8, u32,s16, u32, s32, u64, s64, f32, f64#
- * #expand_sup =1,  0,  1,   0,   0,   0,   0,   0,   0,   0#
- * #simd_sup  = 1,  1,  1,   1,   1,   1,   1,   1,   1,   NPY_SIMD_F64#
+ * #expand_sup= 1,  0,  1,   0,   0,   0,   0,   0,   0,   0#
+ * #simd_sup  = 1,  1,  1,   1,   1,   1,   1,   1,   NPY_SIMD_F32, NPY_SIMD_F64#
  * #fp_only   = 0,  0,  0,   0,   0,   0,   0,   0,   1,   1#
  * #sat_sup   = 1,  1,  1,   1,   0,   0,   0,   0,   0,   0#
  * #mul_sup   = 1,  1,  1,   1,   1,   1,   0,   0,   1,   1#
@@ -485,6 +528,7 @@ static PyMethodDef simd__intrinsics_methods[] = {
  * #intdiv_sup= 1,  1,  1,   1,   1,   1,   1,   1,   0,   0#
  * #shl_imm   = 0,  0,  15,  15,  31,  31,  63,  63,  0,   0#
  * #shr_imm   = 0,  0,  16,  16,  32,  32,  64,  64,  0,   0#
+ * #bitw8b_sup= 1,  0,  0,   0,   0,   0,   0,   0,   0,   0#
  */
 #if @simd_sup@
 
@@ -509,12 +553,21 @@ SIMD_INTRIN_DEF(@intrin@_@sfx@)
 /**end repeat1**/
 #endif // ncont_sup
 
+/****************************
+ * Lookup tables
+ ****************************/
+#if @size@ == 32
+SIMD_INTRIN_DEF(lut32_@sfx@)
+#endif
+#if @size@ == 64
+SIMD_INTRIN_DEF(lut16_@sfx@)
+#endif
 /***************************
  * Misc
  ***************************/
 /**begin repeat1
  * #sfx_to     = u8, s8, u16, s16, u32, s32, u64, s64, f32, f64#
- * #simd_sup2  = 1,  1,  1,   1,   1,   1,   1,   1,   1,   NPY_SIMD_F64#
+ * #simd_sup2  = 1,  1,  1,   1,   1,   1,   1,   1,   NPY_SIMD_F32, NPY_SIMD_F64#
  */
 #if @simd_sup2@
 SIMD_INTRIN_DEF(reinterpret_@sfx_to@_@sfx@)
@@ -522,7 +575,7 @@ SIMD_INTRIN_DEF(reinterpret_@sfx_to@_@sfx@)
 /**end repeat1**/
 
 /**begin repeat1
- * # intrin = set, setf, setall, zero, select#
+ * # intrin = set, setf, setall, zero, select, extract0#
  */
 SIMD_INTRIN_DEF(@intrin@_@sfx@)
 /**end repeat1**/
@@ -552,11 +605,19 @@ SIMD_INTRIN_DEF(@intrin@_@sfx@)
 #endif // shl_imm
 
 /**begin repeat1
- * #intrin = and, or, xor, not, cmpeq, cmpneq, cmpgt, cmpge, cmplt, cmple#
+ * #intrin = and, or, xor, not, cmpeq, cmpneq, cmpgt, cmpge, cmplt, cmple,
+ *           any, all#
  */
 SIMD_INTRIN_DEF(@intrin@_@sfx@)
 /**end repeat1**/
 
+#if @bitw8b_sup@
+SIMD_INTRIN_DEF(andc_@sfx@)
+SIMD_INTRIN_DEF(andc_@bsfx@)
+SIMD_INTRIN_DEF(orc_@bsfx@)
+SIMD_INTRIN_DEF(xnor_@bsfx@)
+#endif
+
 /***************************
  * Conversion
  ***************************/
@@ -615,7 +676,7 @@ SIMD_INTRIN_DEF(sumup_@sfx@)
  ***************************/
 #if @fp_only@
 /**begin repeat1
- * #intrin = sqrt, recip, abs, square, ceil, trunc#
+ * #intrin = sqrt, recip, abs, square, rint, ceil, trunc, floor#
  */
 SIMD_INTRIN_DEF(@intrin@_@sfx@)
 /**end repeat1**/
@@ -625,13 +686,16 @@ SIMD_INTRIN_DEF(@intrin@_@sfx@)
  * #intrin = max, min#
  */
 SIMD_INTRIN_DEF(@intrin@_@sfx@)
+SIMD_INTRIN_DEF(reduce_@intrin@_@sfx@)
 /**end repeat1**/
 
 #if @fp_only@
 /**begin repeat1
- * #intrin = maxp, minp#
+ * #intrin = maxp, minp, maxn, minn#
  */
 SIMD_INTRIN_DEF(@intrin@_@sfx@)
+SIMD_INTRIN_DEF(reduce_@intrin@_@sfx@)
+/**end repeat1**/
 /**end repeat1**/
 #endif
 
@@ -658,7 +722,9 @@ SIMD_INTRIN_DEF(cleanup)
  * Operators
  ***************************/
 // check special cases
-SIMD_INTRIN_DEF(notnan_f32)
+#if NPY_SIMD_F32
+    SIMD_INTRIN_DEF(notnan_f32)
+#endif
 #if NPY_SIMD_F64
     SIMD_INTRIN_DEF(notnan_f64)
 #endif
@@ -666,7 +732,9 @@ SIMD_INTRIN_DEF(notnan_f32)
  * Conversions
  ***************************/
 // round to nearest integer (assume even)
-SIMD_INTRIN_DEF(round_s32_f32)
+#if NPY_SIMD_F32
+    SIMD_INTRIN_DEF(round_s32_f32)
+#endif
 #if NPY_SIMD_F64
     SIMD_INTRIN_DEF(round_s32_f64)
 #endif
@@ -677,14 +745,20 @@ SIMD_INTRIN_DEF(round_s32_f32)
 /***************************
  * Operators
  ***************************/
-// Logical
 /**begin repeat
  * #bsfx = b8, b16, b32, b64#
  */
+// Logical
 SIMD_INTRIN_DEF(and_@bsfx@)
 SIMD_INTRIN_DEF(or_@bsfx@)
 SIMD_INTRIN_DEF(xor_@bsfx@)
 SIMD_INTRIN_DEF(not_@bsfx@)
+// test cross vector's lanes
+/**begin repeat1
+ * #intrin = any, all#
+ */
+SIMD_INTRIN_DEF(@intrin@_@bsfx@)
+/**end repeat1**/
 /**end repeat**/
 /***************************
  * Conversions
@@ -696,6 +770,11 @@ SIMD_INTRIN_DEF(not_@bsfx@)
 SIMD_INTRIN_DEF(tobits_@bsfx@)
 /**end repeat**/
 
+// Pack multiple vectors into one
+SIMD_INTRIN_DEF(pack_b8_b16)
+SIMD_INTRIN_DEF(pack_b8_b32)
+SIMD_INTRIN_DEF(pack_b8_b64)
+
 /************************************************************************/
 {NULL, NULL, 0, NULL}
 }; // PyMethodDef
@@ -710,12 +789,12 @@ NPY_CPU_DISPATCH_CURFX(simd_create_module)(void)
 {
     static struct PyModuleDef defs = {
         .m_base = PyModuleDef_HEAD_INIT,
-        .m_size = -1,
     #ifdef NPY__CPU_TARGET_CURRENT
         .m_name = "numpy.core._simd." NPY_TOSTRING(NPY__CPU_TARGET_CURRENT),
     #else
         .m_name = "numpy.core._simd.baseline",
     #endif
+        .m_size = -1,
     #if NPY_SIMD
         .m_methods = simd__intrinsics_methods
     #else
@@ -732,12 +811,18 @@ NPY_CPU_DISPATCH_CURFX(simd_create_module)(void)
     if (PyModule_AddIntConstant(m, "simd_f64", NPY_SIMD_F64)) {
         goto err;
     }
+    if (PyModule_AddIntConstant(m, "simd_f32", NPY_SIMD_F32)) {
+        goto err;
+    }
     if (PyModule_AddIntConstant(m, "simd_fma3", NPY_SIMD_FMA3)) {
         goto err;
     }
     if (PyModule_AddIntConstant(m, "simd_width", NPY_SIMD_WIDTH)) {
         goto err;
     }
+    if (PyModule_AddIntConstant(m, "simd_bigendian", NPY_SIMD_BIGENDIAN)) {
+        goto err;
+    }
 #if NPY_SIMD
     if (PySIMDVectorType_Init(m)) {
         goto err;
diff --git a/numpy/core/src/_simd/_simd.h b/numpy/core/src/_simd/_simd.h
index d9905c80127c..f3b0a8ccdda9 100644
--- a/numpy/core/src/_simd/_simd.h
+++ b/numpy/core/src/_simd/_simd.h
@@ -14,6 +14,9 @@
 
 #include 
 #include "numpy/npy_common.h"
+#include "npy_cpu_features.h"
+#include "npy_cpu_dispatch.h"
+#include "numpy/npy_cpu.h"
 
 #ifndef NPY_DISABLE_OPTIMIZATION
 // autogenerated, required for CPU dispatch macros
diff --git a/numpy/core/src/_simd/_simd_convert.inc b/numpy/core/src/_simd/_simd_convert.inc
index 73869ef1f7bb..58eb90d691ac 100644
--- a/numpy/core/src/_simd/_simd_convert.inc
+++ b/numpy/core/src/_simd/_simd_convert.inc
@@ -20,6 +20,10 @@ simd_scalar_from_number(PyObject *obj, simd_data_type dtype)
         }
     } else {
         data.u64 = PyLong_AsUnsignedLongLongMask(obj);
+    #if NPY_SIMD_BIGENDIAN
+        int leftb = (sizeof(npyv_lanetype_u64) - info->lane_size) * 8;
+        data.u64 <<= leftb;
+    #endif
     }
     return data;
 }
@@ -36,7 +40,9 @@ simd_scalar_to_number(simd_data data, simd_data_type dtype)
         return PyFloat_FromDouble(data.f64);
     }
     int leftb = (sizeof(npyv_lanetype_u64) - info->lane_size) * 8;
+#if !NPY_SIMD_BIGENDIAN
     data.u64 <<= leftb;
+#endif
     if (info->is_signed) {
         return PyLong_FromLongLong(data.s64 >> leftb);
     }
@@ -94,6 +100,7 @@ simd_sequence_from_iterable(PyObject *obj, simd_data_type dtype, Py_ssize_t min_
             "minimum acceptable size of the required sequence is %d, given(%d)",
             min_size, seq_size
         );
+        Py_DECREF(seq_obj);
         return NULL;
     }
     npyv_lanetype_u8 *dst = simd_sequence_new(seq_size, dtype);
diff --git a/numpy/core/src/_simd/_simd_easyintrin.inc b/numpy/core/src/_simd/_simd_easyintrin.inc
index 4521b2d87f07..f2e0da26ecef 100644
--- a/numpy/core/src/_simd/_simd_easyintrin.inc
+++ b/numpy/core/src/_simd/_simd_easyintrin.inc
@@ -153,6 +153,50 @@
         return simd_arg_to_obj(&ret);                     \
     }
 
+#define SIMD_IMPL_INTRIN_8(NAME, RET, IN0, IN1, IN2, IN3, \
+                                      IN4, IN5, IN6, IN7) \
+    static PyObject *simd__intrin_##NAME                  \
+    (PyObject* NPY_UNUSED(self), PyObject *args)          \
+    {                                                     \
+        simd_arg arg1 = {.dtype = simd_data_##IN0};       \
+        simd_arg arg2 = {.dtype = simd_data_##IN1};       \
+        simd_arg arg3 = {.dtype = simd_data_##IN2};       \
+        simd_arg arg4 = {.dtype = simd_data_##IN3};       \
+        simd_arg arg5 = {.dtype = simd_data_##IN4};       \
+        simd_arg arg6 = {.dtype = simd_data_##IN5};       \
+        simd_arg arg7 = {.dtype = simd_data_##IN6};       \
+        simd_arg arg8 = {.dtype = simd_data_##IN7};       \
+        if (!PyArg_ParseTuple(                            \
+            args, "O&O&O&O&O&O&O&O&:"NPY_TOSTRING(NAME),  \
+            simd_arg_converter, &arg1,                    \
+            simd_arg_converter, &arg2,                    \
+            simd_arg_converter, &arg3,                    \
+            simd_arg_converter, &arg4,                    \
+            simd_arg_converter, &arg5,                    \
+            simd_arg_converter, &arg6,                    \
+            simd_arg_converter, &arg7,                    \
+            simd_arg_converter, &arg8                     \
+        )) return NULL;                                   \
+        simd_data data = {.RET = npyv_##NAME(             \
+            arg1.data.IN0, arg2.data.IN1,                 \
+            arg3.data.IN2, arg4.data.IN3,                 \
+            arg5.data.IN4, arg6.data.IN5,                 \
+            arg7.data.IN6, arg8.data.IN7                  \
+        )};                                               \
+        simd_arg_free(&arg1);                             \
+        simd_arg_free(&arg2);                             \
+        simd_arg_free(&arg3);                             \
+        simd_arg_free(&arg4);                             \
+        simd_arg_free(&arg5);                             \
+        simd_arg_free(&arg6);                             \
+        simd_arg_free(&arg7);                             \
+        simd_arg_free(&arg8);                             \
+        simd_arg ret = {                                  \
+            .data = data, .dtype = simd_data_##RET        \
+        };                                                \
+        return simd_arg_to_obj(&ret);                     \
+    }
+
 /**
  * Helper macros for repeating and expand a certain macro.
  * Mainly used for converting a scalar to an immediate constant.
diff --git a/numpy/core/src/_simd/_simd_inc.h.src b/numpy/core/src/_simd/_simd_inc.h.src
index fbdf982c2984..887545414b9b 100644
--- a/numpy/core/src/_simd/_simd_inc.h.src
+++ b/numpy/core/src/_simd/_simd_inc.h.src
@@ -27,22 +27,27 @@ typedef union
     /**end repeat**/
     // vectors
     /**begin repeat
-     * #sfx  = u8, u16, u32, u64, s8, s16, s32, s64, f32, b8, b16, b32, b64#
+     * #sfx  = u8, u16, u32, u64, s8, s16, s32, s64, b8, b16, b32, b64#
      */
     npyv_@sfx@ v@sfx@;
     /**end repeat**/
     // multi-vectors x2
     /**begin repeat
-     * #sfx = u8, u16, u32, u64, s8, s16, s32, s64, f32#
+     * #sfx = u8, u16, u32, u64, s8, s16, s32, s64#
      */
     npyv_@sfx@x2 v@sfx@x2;
     /**end repeat**/
     // multi-vectors x3
     /**begin repeat
-     * #sfx = u8, u16, u32, u64, s8, s16, s32, s64, f32#
+     * #sfx = u8, u16, u32, u64, s8, s16, s32, s64#
      */
     npyv_@sfx@x3 v@sfx@x3;
     /**end repeat**/
+#if NPY_SIMD_F32
+    npyv_f32    vf32;
+    npyv_f32x2  vf32x2;
+    npyv_f32x3  vf32x3;
+#endif
 #if NPY_SIMD_F64
     npyv_f64    vf64;
     npyv_f64x2  vf64x2;
diff --git a/numpy/core/src/common/array_assign.c b/numpy/core/src/common/array_assign.c
index b7495fc09930..956e55d3067d 100644
--- a/numpy/core/src/common/array_assign.c
+++ b/numpy/core/src/common/array_assign.c
@@ -110,7 +110,6 @@ raw_array_is_aligned(int ndim, npy_intp const *shape,
         int i;
 
         for (i = 0; i < ndim; i++) {
-#if NPY_RELAXED_STRIDES_CHECKING
             /* skip dim == 1 as it is not required to have stride 0 */
             if (shape[i] > 1) {
                 /* if shape[i] == 1, the stride is never used */
@@ -120,9 +119,6 @@ raw_array_is_aligned(int ndim, npy_intp const *shape,
                 /* an array with zero elements is always aligned */
                 return 1;
             }
-#else /* not NPY_RELAXED_STRIDES_CHECKING */
-            align_check |= (npy_uintp)strides[i];
-#endif /* not NPY_RELAXED_STRIDES_CHECKING */
         }
 
         return npy_is_aligned((void *)align_check, alignment);
diff --git a/numpy/core/src/common/binop_override.h b/numpy/core/src/common/binop_override.h
index 61bc05ef3719..ec3d046796ab 100644
--- a/numpy/core/src/common/binop_override.h
+++ b/numpy/core/src/common/binop_override.h
@@ -128,7 +128,7 @@ binop_should_defer(PyObject *self, PyObject *other, int inplace)
      * Classes with __array_ufunc__ are living in the future, and only need to
      * check whether __array_ufunc__ equals None.
      */
-    attr = PyArray_LookupSpecial(other, "__array_ufunc__");
+    attr = PyArray_LookupSpecial(other, npy_um_str_array_ufunc);
     if (attr != NULL) {
         defer = !inplace && (attr == Py_None);
         Py_DECREF(attr);
diff --git a/numpy/core/src/common/get_attr_string.h b/numpy/core/src/common/get_attr_string.h
index 3b23b2e6619b..90eca5ee65c9 100644
--- a/numpy/core/src/common/get_attr_string.h
+++ b/numpy/core/src/common/get_attr_string.h
@@ -1,6 +1,9 @@
 #ifndef NUMPY_CORE_SRC_COMMON_GET_ATTR_STRING_H_
 #define NUMPY_CORE_SRC_COMMON_GET_ATTR_STRING_H_
 
+#include 
+#include "ufunc_object.h"
+
 static NPY_INLINE npy_bool
 _is_basic_python_type(PyTypeObject *tp)
 {
@@ -33,55 +36,18 @@ _is_basic_python_type(PyTypeObject *tp)
     );
 }
 
-/*
- * Stripped down version of PyObject_GetAttrString(obj, name) that does not
- * raise PyExc_AttributeError.
- *
- * This allows it to avoid creating then discarding exception objects when
- * performing lookups on objects without any attributes.
- *
- * Returns attribute value on success, NULL without an exception set if
- * there is no such attribute, and NULL with an exception on failure.
- */
-static NPY_INLINE PyObject *
-maybe_get_attr(PyObject *obj, char const *name)
-{
-    PyTypeObject *tp = Py_TYPE(obj);
-    PyObject *res = (PyObject *)NULL;
-
-    /* Attribute referenced by (char *)name */
-    if (tp->tp_getattr != NULL) {
-        res = (*tp->tp_getattr)(obj, (char *)name);
-        if (res == NULL && PyErr_ExceptionMatches(PyExc_AttributeError)) {
-            PyErr_Clear();
-        }
-    }
-    /* Attribute referenced by (PyObject *)name */
-    else if (tp->tp_getattro != NULL) {
-        PyObject *w = PyUnicode_InternFromString(name);
-        if (w == NULL) {
-            return (PyObject *)NULL;
-        }
-        res = (*tp->tp_getattro)(obj, w);
-        Py_DECREF(w);
-        if (res == NULL && PyErr_ExceptionMatches(PyExc_AttributeError)) {
-            PyErr_Clear();
-        }
-    }
-    return res;
-}
 
 /*
  * Lookup a special method, following the python approach of looking up
  * on the type object, rather than on the instance itself.
  *
  * Assumes that the special method is a numpy-specific one, so does not look
- * at builtin types, nor does it look at a base ndarray.
+ * at builtin types. It does check base ndarray and numpy scalar types.
  *
  * In future, could be made more like _Py_LookupSpecial
  */
 static NPY_INLINE PyObject *
-PyArray_LookupSpecial(PyObject *obj, char const *name)
+PyArray_LookupSpecial(PyObject *obj, PyObject *name_unicode)
 {
     PyTypeObject *tp = Py_TYPE(obj);
 
@@ -89,9 +55,16 @@ PyArray_LookupSpecial(PyObject *obj, char const *name)
     if (_is_basic_python_type(tp)) {
         return NULL;
     }
-    return maybe_get_attr((PyObject *)tp, name);
+    PyObject *res = PyObject_GetAttr((PyObject *)tp, name_unicode);
+
+    if (res == NULL && PyErr_ExceptionMatches(PyExc_AttributeError)) {
+        PyErr_Clear();
+    }
+
+    return res;
 }
 
+
 /*
  * PyArray_LookupSpecial_OnInstance:
  *
@@ -101,7 +74,7 @@ PyArray_LookupSpecial(PyObject *obj, char const *name)
  * Kept for backwards compatibility. In future, we should deprecate this.
  */
 static NPY_INLINE PyObject *
-PyArray_LookupSpecial_OnInstance(PyObject *obj, char const *name)
+PyArray_LookupSpecial_OnInstance(PyObject *obj, PyObject *name_unicode)
 {
     PyTypeObject *tp = Py_TYPE(obj);
 
@@ -110,7 +83,13 @@ PyArray_LookupSpecial_OnInstance(PyObject *obj, char const *name)
         return NULL;
     }
 
-    return maybe_get_attr(obj, name);
+    PyObject *res = PyObject_GetAttr(obj, name_unicode);
+
+    if (res == NULL && PyErr_ExceptionMatches(PyExc_AttributeError)) {
+        PyErr_Clear();
+    }
+
+    return res;
 }
 
 #endif  /* NUMPY_CORE_SRC_COMMON_GET_ATTR_STRING_H_ */
diff --git a/numpy/core/src/common/lowlevel_strided_loops.h b/numpy/core/src/common/lowlevel_strided_loops.h
index ad86c04895a9..924a34db5ee3 100644
--- a/numpy/core/src/common/lowlevel_strided_loops.h
+++ b/numpy/core/src/common/lowlevel_strided_loops.h
@@ -196,7 +196,7 @@ PyArray_GetDTypeTransferFunction(int aligned,
                             PyArray_Descr *src_dtype, PyArray_Descr *dst_dtype,
                             int move_references,
                             NPY_cast_info *cast_info,
-                            int *out_needs_api);
+                            NPY_ARRAYMETHOD_FLAGS *out_flags);
 
 NPY_NO_EXPORT int
 get_fields_transfer_function(int aligned,
@@ -205,7 +205,7 @@ get_fields_transfer_function(int aligned,
         int move_references,
         PyArrayMethod_StridedLoop **out_stransfer,
         NpyAuxData **out_transferdata,
-        int *out_needs_api);
+        NPY_ARRAYMETHOD_FLAGS *out_flags);
 
 NPY_NO_EXPORT int
 get_subarray_transfer_function(int aligned,
@@ -214,7 +214,7 @@ get_subarray_transfer_function(int aligned,
         int move_references,
         PyArrayMethod_StridedLoop **out_stransfer,
         NpyAuxData **out_transferdata,
-        int *out_needs_api);
+        NPY_ARRAYMETHOD_FLAGS *out_flags);
 
 /*
  * This is identical to PyArray_GetDTypeTransferFunction, but returns a
@@ -241,7 +241,7 @@ PyArray_GetMaskedDTypeTransferFunction(int aligned,
                             PyArray_Descr *mask_dtype,
                             int move_references,
                             NPY_cast_info *cast_info,
-                            int *out_needs_api);
+                            NPY_ARRAYMETHOD_FLAGS *out_flags);
 
 /*
  * Casts the specified number of elements from 'src' with data type
@@ -336,10 +336,14 @@ mapiter_trivial_set(PyArrayObject *self, PyArrayObject *ind,
                        PyArrayObject *result);
 
 NPY_NO_EXPORT int
-mapiter_get(PyArrayMapIterObject *mit);
+mapiter_get(
+        PyArrayMapIterObject *mit, NPY_cast_info *cast_info,
+        NPY_ARRAYMETHOD_FLAGS flags, int is_aligned);
 
 NPY_NO_EXPORT int
-mapiter_set(PyArrayMapIterObject *mit);
+mapiter_set(
+        PyArrayMapIterObject *mit, NPY_cast_info *cast_info,
+        NPY_ARRAYMETHOD_FLAGS flags, int is_aligned);
 
 /*
  * Prepares shape and strides for a simple raw array iteration.
@@ -692,6 +696,19 @@ PyArray_EQUIVALENTLY_ITERABLE_OVERLAP_OK(PyArrayObject *arr1, PyArrayObject *arr
         return 1;
     }
 
+    size1 = PyArray_SIZE(arr1);
+    stride1 = PyArray_TRIVIAL_PAIR_ITERATION_STRIDE(size1, arr1);
+
+    /*
+     * arr1 == arr2 is common for in-place operations, so we fast-path it here.
+     * TODO: The stride1 != 0 check rejects broadcast arrays.  This may affect
+     *       self-overlapping arrays, but seems only necessary due to
+     *       `try_trivial_single_output_loop` not rejecting broadcast outputs.
+     */
+    if (arr1 == arr2 && stride1 != 0) {
+        return 1;
+    }
+
     if (solve_may_share_memory(arr1, arr2, 1) == 0) {
         return 1;
     }
@@ -701,10 +718,7 @@ PyArray_EQUIVALENTLY_ITERABLE_OVERLAP_OK(PyArrayObject *arr1, PyArrayObject *arr
      * arrays stride ahead faster than output arrays.
      */
 
-    size1 = PyArray_SIZE(arr1);
     size2 = PyArray_SIZE(arr2);
-
-    stride1 = PyArray_TRIVIAL_PAIR_ITERATION_STRIDE(size1, arr1);
     stride2 = PyArray_TRIVIAL_PAIR_ITERATION_STRIDE(size2, arr2);
 
     /*
diff --git a/numpy/core/src/common/npy_binsearch.h b/numpy/core/src/common/npy_binsearch.h
new file mode 100644
index 000000000000..8d2f0714df8c
--- /dev/null
+++ b/numpy/core/src/common/npy_binsearch.h
@@ -0,0 +1,31 @@
+#ifndef __NPY_BINSEARCH_H__
+#define __NPY_BINSEARCH_H__
+
+#include "npy_sort.h"
+#include 
+#include 
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void (PyArray_BinSearchFunc)(const char*, const char*, char*,
+                                     npy_intp, npy_intp,
+                                     npy_intp, npy_intp, npy_intp,
+                                     PyArrayObject*);
+
+typedef int (PyArray_ArgBinSearchFunc)(const char*, const char*,
+                                       const char*, char*,
+                                       npy_intp, npy_intp, npy_intp,
+                                       npy_intp, npy_intp, npy_intp,
+                                       PyArrayObject*);
+
+NPY_NO_EXPORT PyArray_BinSearchFunc* get_binsearch_func(PyArray_Descr *dtype, NPY_SEARCHSIDE side);
+NPY_NO_EXPORT PyArray_ArgBinSearchFunc* get_argbinsearch_func(PyArray_Descr *dtype, NPY_SEARCHSIDE side);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/numpy/core/src/common/npy_binsearch.h.src b/numpy/core/src/common/npy_binsearch.h.src
deleted file mode 100644
index 052c444828c3..000000000000
--- a/numpy/core/src/common/npy_binsearch.h.src
+++ /dev/null
@@ -1,144 +0,0 @@
-#ifndef __NPY_BINSEARCH_H__
-#define __NPY_BINSEARCH_H__
-
-#include "npy_sort.h"
-#include 
-#include 
-
-#define ARRAY_SIZE(a) (sizeof(a)/sizeof(a[0]))
-
-typedef void (PyArray_BinSearchFunc)(const char*, const char*, char*,
-                                     npy_intp, npy_intp,
-                                     npy_intp, npy_intp, npy_intp,
-                                     PyArrayObject*);
-
-typedef int (PyArray_ArgBinSearchFunc)(const char*, const char*,
-                                       const char*, char*,
-                                       npy_intp, npy_intp, npy_intp,
-                                       npy_intp, npy_intp, npy_intp,
-                                       PyArrayObject*);
-
-typedef struct {
-    int typenum;
-    PyArray_BinSearchFunc *binsearch[NPY_NSEARCHSIDES];
-} binsearch_map;
-
-typedef struct {
-    int typenum;
-    PyArray_ArgBinSearchFunc *argbinsearch[NPY_NSEARCHSIDES];
-} argbinsearch_map;
-
-/**begin repeat
- *
- * #side = left, right#
- */
-
-/**begin repeat1
- *
- * #suff = bool, byte, ubyte, short, ushort, int, uint, long, ulong,
- *         longlong, ulonglong, half, float, double, longdouble,
- *         cfloat, cdouble, clongdouble, datetime, timedelta#
- */
-
-NPY_NO_EXPORT void
-binsearch_@side@_@suff@(const char *arr, const char *key, char *ret,
-                        npy_intp arr_len, npy_intp key_len,
-                        npy_intp arr_str, npy_intp key_str, npy_intp ret_str,
-                        PyArrayObject *unused);
-NPY_NO_EXPORT int
-argbinsearch_@side@_@suff@(const char *arr, const char *key,
-                           const char *sort, char *ret,
-                           npy_intp arr_len, npy_intp key_len,
-                           npy_intp arr_str, npy_intp key_str,
-                           npy_intp sort_str, npy_intp ret_str,
-                           PyArrayObject *unused);
-/**end repeat1**/
-
-NPY_NO_EXPORT void
-npy_binsearch_@side@(const char *arr, const char *key, char *ret,
-                     npy_intp arr_len, npy_intp key_len,
-                     npy_intp arr_str, npy_intp key_str,
-                     npy_intp ret_str, PyArrayObject *cmp);
-NPY_NO_EXPORT int
-npy_argbinsearch_@side@(const char *arr, const char *key,
-                        const char *sort, char *ret,
-                        npy_intp arr_len, npy_intp key_len,
-                        npy_intp arr_str, npy_intp key_str,
-                        npy_intp sort_str, npy_intp ret_str,
-                        PyArrayObject *cmp);
-/**end repeat**/
-
-/**begin repeat
- *
- * #arg = , arg#
- * #Arg = , Arg#
- */
-
-static @arg@binsearch_map _@arg@binsearch_map[] = {
-    /* If adding new types, make sure to keep them ordered by type num */
-    /**begin repeat1
-     *
-     * #TYPE = BOOL, BYTE, UBYTE, SHORT, USHORT, INT, UINT, LONG, ULONG,
-     *         LONGLONG, ULONGLONG, FLOAT, DOUBLE, LONGDOUBLE,
-     *         CFLOAT, CDOUBLE, CLONGDOUBLE, DATETIME, TIMEDELTA, HALF#
-     * #suff = bool, byte, ubyte, short, ushort, int, uint, long, ulong,
-     *         longlong, ulonglong, float, double, longdouble,
-     *         cfloat, cdouble, clongdouble, datetime, timedelta, half#
-     */
-    {NPY_@TYPE@,
-        {
-            &@arg@binsearch_left_@suff@,
-            &@arg@binsearch_right_@suff@,
-        },
-    },
-    /**end repeat1**/
-};
-
-static PyArray_@Arg@BinSearchFunc *gen@arg@binsearch_map[] = {
-    &npy_@arg@binsearch_left,
-    &npy_@arg@binsearch_right,
-};
-
-static NPY_INLINE PyArray_@Arg@BinSearchFunc*
-get_@arg@binsearch_func(PyArray_Descr *dtype, NPY_SEARCHSIDE side)
-{
-    npy_intp nfuncs = ARRAY_SIZE(_@arg@binsearch_map);
-    npy_intp min_idx = 0;
-    npy_intp max_idx = nfuncs;
-    int type = dtype->type_num;
-
-    if (side >= NPY_NSEARCHSIDES) {
-        return NULL;
-    }
-
-    /*
-     * It seems only fair that a binary search function be searched for
-     * using a binary search...
-     */
-    while (min_idx < max_idx) {
-        npy_intp mid_idx = min_idx + ((max_idx - min_idx) >> 1);
-
-        if (_@arg@binsearch_map[mid_idx].typenum < type) {
-            min_idx = mid_idx + 1;
-        }
-        else {
-            max_idx = mid_idx;
-        }
-    }
-
-    if (min_idx < nfuncs &&
-            _@arg@binsearch_map[min_idx].typenum == type) {
-        return _@arg@binsearch_map[min_idx].@arg@binsearch[side];
-    }
-
-    if (dtype->f->compare) {
-        return gen@arg@binsearch_map[side];
-    }
-
-    return NULL;
-}
-/**end repeat**/
-
-#undef ARRAY_SIZE
-
-#endif
diff --git a/numpy/core/src/common/npy_config.h b/numpy/core/src/common/npy_config.h
index fd0f1855c8d3..d6886c5ea90a 100644
--- a/numpy/core/src/common/npy_config.h
+++ b/numpy/core/src/common/npy_config.h
@@ -2,46 +2,35 @@
 #define NUMPY_CORE_SRC_COMMON_NPY_CONFIG_H_
 
 #include "config.h"
-#include "npy_cpu_features.h"
-#include "npy_cpu_dispatch.h"
 #include "numpy/numpyconfig.h"
-#include "numpy/npy_cpu.h"
+#include "numpy/utils.h"
 #include "numpy/npy_os.h"
 
 /* blocklist */
 
-/* Disable broken Sun Workshop Pro math functions */
-#ifdef __SUNPRO_C
-
-#undef HAVE_ATAN2
-#undef HAVE_ATAN2F
-#undef HAVE_ATAN2L
-
-#endif
-
 /* Disable broken functions on z/OS */
 #if defined (__MVS__)
 
-#undef HAVE_POWF
-#undef HAVE_EXPF
+#define NPY_BLOCK_POWF
+#define NPY_BLOCK_EXPF
 #undef HAVE___THREAD
 
 #endif
 
 /* Disable broken MS math functions */
-#if (defined(_MSC_VER) && (_MSC_VER < 1900)) || defined(__MINGW32_VERSION)
+#if defined(__MINGW32_VERSION)
 
-#undef HAVE_ATAN2
-#undef HAVE_ATAN2F
-#undef HAVE_ATAN2L
+#define NPY_BLOCK_ATAN2
+#define NPY_BLOCK_ATAN2F
+#define NPY_BLOCK_ATAN2L
 
-#undef HAVE_HYPOT
-#undef HAVE_HYPOTF
-#undef HAVE_HYPOTL
+#define NPY_BLOCK_HYPOT
+#define NPY_BLOCK_HYPOTF
+#define NPY_BLOCK_HYPOTL
 
 #endif
 
-#if defined(_MSC_VER) && (_MSC_VER >= 1900)
+#if defined(_MSC_VER)
 
 #undef HAVE_CASIN
 #undef HAVE_CASINF
@@ -71,29 +60,29 @@
 #endif
 
 /* MSVC _hypot messes with fp precision mode on 32-bit, see gh-9567 */
-#if defined(_MSC_VER) && (_MSC_VER >= 1900) && !defined(_WIN64)
+#if defined(_MSC_VER) && !defined(_WIN64)
 
 #undef HAVE_CABS
 #undef HAVE_CABSF
 #undef HAVE_CABSL
 
-#undef HAVE_HYPOT
-#undef HAVE_HYPOTF
-#undef HAVE_HYPOTL
+#define NPY_BLOCK_HYPOT
+#define NPY_BLOCK_HYPOTF
+#define NPY_BLOCK_HYPOTL
 
 #endif
 
 
 /* Intel C for Windows uses POW for 64 bits longdouble*/
 #if defined(_MSC_VER) && defined(__INTEL_COMPILER)
-#if defined(HAVE_POWL) && (NPY_SIZEOF_LONGDOUBLE == 8)
-#undef HAVE_POWL
+#if NPY_SIZEOF_LONGDOUBLE == 8
+#define NPY_BLOCK_POWL
 #endif
 #endif /* defined(_MSC_VER) && defined(__INTEL_COMPILER) */
 
 /* powl gives zero division warning on OS X, see gh-8307 */
-#if defined(HAVE_POWL) && defined(NPY_OS_DARWIN)
-#undef HAVE_POWL
+#if defined(NPY_OS_DARWIN)
+#define NPY_BLOCK_POWL
 #endif
 
 #ifdef __CYGWIN__
@@ -130,15 +119,17 @@
 #undef HAVE_CACOS
 
 /* log2(exp2(i)) off by a few eps */
-#undef HAVE_LOG2
+#define NPY_BLOCK_LOG2
 
 /* np.power(..., dtype=np.complex256) doesn't report overflow */
 #undef HAVE_CPOWL
 #undef HAVE_CEXPL
 
-/* Builtin abs reports overflow */
-#undef HAVE_CABSL
-#undef HAVE_HYPOTL
+#include 
+#if CYGWIN_VERSION_DLL_MAJOR < 3003
+// rather than blocklist cabsl, hypotl, modfl, sqrtl, error out
+#error cygwin < 3.3 not supported, please update
+#endif
 #endif
 
 /* Disable broken gnu trig functions */
diff --git a/numpy/core/src/common/npy_cpu_dispatch.h b/numpy/core/src/common/npy_cpu_dispatch.h
index e814cd425e83..4d5addec809e 100644
--- a/numpy/core/src/common/npy_cpu_dispatch.h
+++ b/numpy/core/src/common/npy_cpu_dispatch.h
@@ -22,7 +22,7 @@
  * which is explicitly disabling the module ccompiler_opt.
  */
 #ifndef NPY_DISABLE_OPTIMIZATION
-    #if defined(__powerpc64__) && !defined(__cplusplus) && defined(bool)
+    #if (defined(__s390x__) || defined(__powerpc64__)) && !defined(__cplusplus) && defined(bool)
         /**
          * "altivec.h" header contains the definitions(bool, vector, pixel),
          * usually in c++ we undefine them after including the header.
@@ -34,7 +34,7 @@
         typedef bool npy__dispatch_bkbool;
     #endif
     #include "npy_cpu_dispatch_config.h"
-    #ifdef NPY_HAVE_VSX
+    #if defined(NPY_HAVE_VSX) || defined(NPY_HAVE_VX)
         #undef bool
         #undef vector
         #undef pixel
diff --git a/numpy/core/src/common/npy_cpu_features.c.src b/numpy/core/src/common/npy_cpu_features.c
similarity index 82%
rename from numpy/core/src/common/npy_cpu_features.c.src
rename to numpy/core/src/common/npy_cpu_features.c
index a2383c45f61d..5842471e47a4 100644
--- a/numpy/core/src/common/npy_cpu_features.c.src
+++ b/numpy/core/src/common/npy_cpu_features.c
@@ -49,27 +49,72 @@ npy_cpu_init(void)
     return 0;
 }
 
+static struct {
+  enum npy_cpu_features feature;
+  char const *string;
+} features[] = {{NPY_CPU_FEATURE_MMX, "MMX"},
+                {NPY_CPU_FEATURE_SSE, "SSE"},
+                {NPY_CPU_FEATURE_SSE2, "SSE2"},
+                {NPY_CPU_FEATURE_SSE3, "SSE3"},
+                {NPY_CPU_FEATURE_SSSE3, "SSSE3"},
+                {NPY_CPU_FEATURE_SSE41, "SSE41"},
+                {NPY_CPU_FEATURE_POPCNT, "POPCNT"},
+                {NPY_CPU_FEATURE_SSE42, "SSE42"},
+                {NPY_CPU_FEATURE_AVX, "AVX"},
+                {NPY_CPU_FEATURE_F16C, "F16C"},
+                {NPY_CPU_FEATURE_XOP, "XOP"},
+                {NPY_CPU_FEATURE_FMA4, "FMA4"},
+                {NPY_CPU_FEATURE_FMA3, "FMA3"},
+                {NPY_CPU_FEATURE_AVX2, "AVX2"},
+                {NPY_CPU_FEATURE_AVX512F, "AVX512F"},
+                {NPY_CPU_FEATURE_AVX512CD, "AVX512CD"},
+                {NPY_CPU_FEATURE_AVX512ER, "AVX512ER"},
+                {NPY_CPU_FEATURE_AVX512PF, "AVX512PF"},
+                {NPY_CPU_FEATURE_AVX5124FMAPS, "AVX5124FMAPS"},
+                {NPY_CPU_FEATURE_AVX5124VNNIW, "AVX5124VNNIW"},
+                {NPY_CPU_FEATURE_AVX512VPOPCNTDQ, "AVX512VPOPCNTDQ"},
+                {NPY_CPU_FEATURE_AVX512VL, "AVX512VL"},
+                {NPY_CPU_FEATURE_AVX512BW, "AVX512BW"},
+                {NPY_CPU_FEATURE_AVX512DQ, "AVX512DQ"},
+                {NPY_CPU_FEATURE_AVX512VNNI, "AVX512VNNI"},
+                {NPY_CPU_FEATURE_AVX512IFMA, "AVX512IFMA"},
+                {NPY_CPU_FEATURE_AVX512VBMI, "AVX512VBMI"},
+                {NPY_CPU_FEATURE_AVX512VBMI2, "AVX512VBMI2"},
+                {NPY_CPU_FEATURE_AVX512BITALG, "AVX512BITALG"},
+                {NPY_CPU_FEATURE_AVX512_KNL, "AVX512_KNL"},
+                {NPY_CPU_FEATURE_AVX512_KNM, "AVX512_KNM"},
+                {NPY_CPU_FEATURE_AVX512_SKX, "AVX512_SKX"},
+                {NPY_CPU_FEATURE_AVX512_CLX, "AVX512_CLX"},
+                {NPY_CPU_FEATURE_AVX512_CNL, "AVX512_CNL"},
+                {NPY_CPU_FEATURE_AVX512_ICL, "AVX512_ICL"},
+                {NPY_CPU_FEATURE_VSX, "VSX"},
+                {NPY_CPU_FEATURE_VSX2, "VSX2"},
+                {NPY_CPU_FEATURE_VSX3, "VSX3"},
+                {NPY_CPU_FEATURE_VSX4, "VSX4"},
+                {NPY_CPU_FEATURE_VX, "VX"},
+                {NPY_CPU_FEATURE_VXE, "VXE"},
+                {NPY_CPU_FEATURE_VXE2, "VXE2"},
+                {NPY_CPU_FEATURE_NEON, "NEON"},
+                {NPY_CPU_FEATURE_NEON_FP16, "NEON_FP16"},
+                {NPY_CPU_FEATURE_NEON_VFPV4, "NEON_VFPV4"},
+                {NPY_CPU_FEATURE_ASIMD, "ASIMD"},
+                {NPY_CPU_FEATURE_FPHP, "FPHP"},
+                {NPY_CPU_FEATURE_ASIMDHP, "ASIMDHP"},
+                {NPY_CPU_FEATURE_ASIMDDP, "ASIMDDP"},
+                {NPY_CPU_FEATURE_ASIMDFHM, "ASIMDFHM"}};
+
+
 NPY_VISIBILITY_HIDDEN PyObject *
 npy_cpu_features_dict(void)
 {
     PyObject *dict = PyDict_New();
     if (dict) {
-    /**begin repeat
-     * #feature = MMX, SSE, SSE2, SSE3, SSSE3, SSE41, POPCNT, SSE42,
-     *            AVX, F16C, XOP, FMA4, FMA3, AVX2, AVX512F,
-     *            AVX512CD, AVX512ER, AVX512PF, AVX5124FMAPS, AVX5124VNNIW,
-     *            AVX512VPOPCNTDQ, AVX512VL, AVX512BW, AVX512DQ, AVX512VNNI,
-     *            AVX512IFMA, AVX512VBMI, AVX512VBMI2, AVX512BITALG,
-     *            AVX512_KNL, AVX512_KNM, AVX512_SKX, AVX512_CLX, AVX512_CNL, AVX512_ICL,
-     *            VSX, VSX2, VSX3,
-     *            NEON, NEON_FP16, NEON_VFPV4, ASIMD, FPHP, ASIMDHP, ASIMDDP, ASIMDFHM#
-    */
-        if (PyDict_SetItemString(dict, "@feature@",
-            npy__cpu_have[NPY_CPU_FEATURE_@feature@] ? Py_True : Py_False) < 0) {
-            Py_DECREF(dict);
-            return NULL;
-        }
-    /**end repeat**/
+        for(unsigned i = 0; i < sizeof(features)/sizeof(features[0]); ++i)
+            if (PyDict_SetItemString(dict, features[i].string,
+                npy__cpu_have[features[i].feature] ? Py_True : Py_False) < 0) {
+                Py_DECREF(dict);
+                return NULL;
+            }
     }
     return dict;
 }
@@ -468,36 +513,57 @@ npy__cpu_init_features(void)
 
 #elif defined(NPY_CPU_PPC64) || defined(NPY_CPU_PPC64LE)
 
-#ifdef __linux__
+#if defined(__linux__) || defined(__FreeBSD__)
+    #ifdef __FreeBSD__
+        #include  // defines PPC_FEATURE_HAS_VSX
+    #endif
     #include 
     #ifndef AT_HWCAP2
         #define AT_HWCAP2 26
     #endif
+    #ifndef PPC_FEATURE2_ARCH_2_07
+        #define PPC_FEATURE2_ARCH_2_07 0x80000000
+    #endif
     #ifndef PPC_FEATURE2_ARCH_3_00
         #define PPC_FEATURE2_ARCH_3_00 0x00800000
     #endif
+    #ifndef PPC_FEATURE2_ARCH_3_1
+        #define PPC_FEATURE2_ARCH_3_1  0x00040000
+    #endif
 #endif
 
 static void
 npy__cpu_init_features(void)
 {
     memset(npy__cpu_have, 0, sizeof(npy__cpu_have[0]) * NPY_CPU_FEATURE_MAX);
+#if defined(__linux__) || defined(__FreeBSD__)
 #ifdef __linux__
     unsigned int hwcap = getauxval(AT_HWCAP);
     if ((hwcap & PPC_FEATURE_HAS_VSX) == 0)
         return;
 
     hwcap = getauxval(AT_HWCAP2);
-    if (hwcap & PPC_FEATURE2_ARCH_3_00)
+#else
+    unsigned long hwcap;
+    elf_aux_info(AT_HWCAP, &hwcap, sizeof(hwcap));
+    if ((hwcap & PPC_FEATURE_HAS_VSX) == 0)
+        return;
+
+    elf_aux_info(AT_HWCAP2, &hwcap, sizeof(hwcap));
+#endif // __linux__
+    if (hwcap & PPC_FEATURE2_ARCH_3_1)
     {
         npy__cpu_have[NPY_CPU_FEATURE_VSX]  =
         npy__cpu_have[NPY_CPU_FEATURE_VSX2] =
-        npy__cpu_have[NPY_CPU_FEATURE_VSX3] = 1;
+        npy__cpu_have[NPY_CPU_FEATURE_VSX3] =
+        npy__cpu_have[NPY_CPU_FEATURE_VSX4] = 1;
         return;
     }
-    npy__cpu_have[NPY_CPU_FEATURE_VSX2] = (hwcap & PPC_FEATURE2_ARCH_2_07) != 0;
     npy__cpu_have[NPY_CPU_FEATURE_VSX]  = 1;
-// TODO: AIX, FreeBSD
+    npy__cpu_have[NPY_CPU_FEATURE_VSX2] = (hwcap & PPC_FEATURE2_ARCH_2_07) != 0;
+    npy__cpu_have[NPY_CPU_FEATURE_VSX3] = (hwcap & PPC_FEATURE2_ARCH_3_00) != 0;
+    npy__cpu_have[NPY_CPU_FEATURE_VSX4] = (hwcap & PPC_FEATURE2_ARCH_3_1) != 0;
+// TODO: AIX, OpenBSD
 #else
     npy__cpu_have[NPY_CPU_FEATURE_VSX]  = 1;
     #if defined(NPY_CPU_PPC64LE) || defined(NPY_HAVE_VSX2)
@@ -506,9 +572,48 @@ npy__cpu_init_features(void)
     #ifdef NPY_HAVE_VSX3
     npy__cpu_have[NPY_CPU_FEATURE_VSX3] = 1;
     #endif
+    #ifdef NPY_HAVE_VSX4
+    npy__cpu_have[NPY_CPU_FEATURE_VSX4] = 1;
+    #endif
 #endif
 }
 
+/***************** ZARCH ******************/
+
+#elif defined(__s390x__)
+
+#include 
+#ifndef HWCAP_S390_VXE
+    #define HWCAP_S390_VXE 8192
+#endif
+
+#ifndef HWCAP_S390_VXRS_EXT2
+    #define HWCAP_S390_VXRS_EXT2 32768
+#endif
+
+static void
+npy__cpu_init_features(void)
+{
+    memset(npy__cpu_have, 0, sizeof(npy__cpu_have[0]) * NPY_CPU_FEATURE_MAX);
+    
+    unsigned int hwcap = getauxval(AT_HWCAP);
+    if ((hwcap & HWCAP_S390_VX) == 0) {
+        return;
+    }
+
+    if (hwcap & HWCAP_S390_VXRS_EXT2) {
+       npy__cpu_have[NPY_CPU_FEATURE_VX]  =
+       npy__cpu_have[NPY_CPU_FEATURE_VXE] =
+       npy__cpu_have[NPY_CPU_FEATURE_VXE2] = 1;
+       return;
+    }
+    
+    npy__cpu_have[NPY_CPU_FEATURE_VXE] = (hwcap & HWCAP_S390_VXE) != 0;
+
+    npy__cpu_have[NPY_CPU_FEATURE_VX]  = 1;
+}
+
+
 /***************** ARM ******************/
 
 #elif defined(__arm__) || defined(__aarch64__)
@@ -530,7 +635,9 @@ npy__cpu_init_features_arm8(void)
 #include 
 #include "npy_cpuinfo_parser.h"
 
+#if defined(__linux__)
 __attribute__((weak)) unsigned long getauxval(unsigned long); // linker should handle it
+#endif
 #ifdef __FreeBSD__
 __attribute__((weak)) int elf_aux_info(int, void *, int); // linker should handle it
 
diff --git a/numpy/core/src/common/npy_cpu_features.h b/numpy/core/src/common/npy_cpu_features.h
index ce1fc822ac03..96c543e70105 100644
--- a/numpy/core/src/common/npy_cpu_features.h
+++ b/numpy/core/src/common/npy_cpu_features.h
@@ -65,6 +65,8 @@ enum npy_cpu_features
     NPY_CPU_FEATURE_VSX2              = 201,
     // POWER9
     NPY_CPU_FEATURE_VSX3              = 202,
+    // POWER10
+    NPY_CPU_FEATURE_VSX4              = 203,
 
     // ARM
     NPY_CPU_FEATURE_NEON              = 300,
@@ -82,6 +84,15 @@ enum npy_cpu_features
     // ARMv8.2 single&half-precision multiply
     NPY_CPU_FEATURE_ASIMDFHM          = 307,
 
+    // IBM/ZARCH
+    NPY_CPU_FEATURE_VX                = 350,
+ 
+    // Vector-Enhancements Facility 1
+    NPY_CPU_FEATURE_VXE               = 351,
+
+    // Vector-Enhancements Facility 2
+    NPY_CPU_FEATURE_VXE2              = 352,
+
     NPY_CPU_FEATURE_MAX
 };
 
@@ -126,7 +137,7 @@ npy_cpu_features_dict(void);
  * that supported by the compiler and platform according to the specified
  * values to command argument '--cpu-baseline'.
  *
- * This function is mainly used to implement umath's attrbute '__cpu_baseline__',
+ * This function is mainly used to implement umath's attribute '__cpu_baseline__',
  * and the items are sorted from the lowest to highest interest.
  *
  * For example, according to the default build configuration and by assuming the compiler
@@ -138,6 +149,7 @@ npy_cpu_features_dict(void);
  * On aarch64: ['NEON', 'NEON_FP16', 'NEON_VPFV4', 'ASIMD']
  * On ppc64: []
  * On ppc64le: ['VSX', 'VSX2']
+ * On s390x: []
  * On any other arch or if the optimization is disabled: []
  */
 NPY_VISIBILITY_HIDDEN PyObject *
@@ -147,7 +159,7 @@ npy_cpu_baseline_list(void);
  * that supported by the compiler and platform according to the specified
  * values to command argument '--cpu-dispatch'.
  *
- * This function is mainly used to implement umath's attrbute '__cpu_dispatch__',
+ * This function is mainly used to implement umath's attribute '__cpu_dispatch__',
  * and the items are sorted from the lowest to highest interest.
  *
  * For example, according to the default build configuration and by assuming the compiler
@@ -157,8 +169,9 @@ npy_cpu_baseline_list(void);
  * On x64: ['SSSE3', 'SSE41', 'POPCNT', 'SSE42', 'AVX', 'F16C', 'FMA3', 'AVX2', 'AVX512F', ...]
  * On armhf: ['NEON', 'NEON_FP16', 'NEON_VPFV4', 'ASIMD', 'ASIMDHP', 'ASIMDDP', 'ASIMDFHM']
  * On aarch64: ['ASIMDHP', 'ASIMDDP', 'ASIMDFHM']
- * On ppc64:  ['VSX', 'VSX2', 'VSX3']
- * On ppc64le: ['VSX3']
+ * On ppc64:  ['VSX', 'VSX2', 'VSX3', 'VSX4']
+ * On ppc64le: ['VSX3', 'VSX4']
+ * On s390x: ['VX', 'VXE', VXE2]
  * On any other arch or if the optimization is disabled: []
  */
 NPY_VISIBILITY_HIDDEN PyObject *
diff --git a/numpy/core/src/common/npy_dlpack.h b/numpy/core/src/common/npy_dlpack.h
index 14ca352c01a7..cb926a26271d 100644
--- a/numpy/core/src/common/npy_dlpack.h
+++ b/numpy/core/src/common/npy_dlpack.h
@@ -23,6 +23,6 @@ array_dlpack_device(PyArrayObject *self, PyObject *NPY_UNUSED(args));
 
 
 NPY_NO_EXPORT PyObject *
-_from_dlpack(PyObject *NPY_UNUSED(self), PyObject *obj);
+from_dlpack(PyObject *NPY_UNUSED(self), PyObject *obj);
 
 #endif
diff --git a/numpy/core/src/common/npy_hashtable.c b/numpy/core/src/common/npy_hashtable.c
index af9e2df432a1..af82c0f85b2e 100644
--- a/numpy/core/src/common/npy_hashtable.c
+++ b/numpy/core/src/common/npy_hashtable.c
@@ -146,7 +146,7 @@ _resize_if_necessary(PyArrayIdentityHash *tb)
     }
 
     npy_intp alloc_size;
-    if (npy_mul_with_overflow_intp(&alloc_size, new_size, tb->key_len + 1)) {
+    if (npy_mul_sizes_with_overflow(&alloc_size, new_size, tb->key_len + 1)) {
         return -1;
     }
     tb->buckets = PyMem_Calloc(alloc_size, sizeof(PyObject *));
diff --git a/numpy/core/src/common/npy_partition.h b/numpy/core/src/common/npy_partition.h
new file mode 100644
index 000000000000..85a0727c58d4
--- /dev/null
+++ b/numpy/core/src/common/npy_partition.h
@@ -0,0 +1,27 @@
+#ifndef NUMPY_CORE_SRC_COMMON_PARTITION_H_
+#define NUMPY_CORE_SRC_COMMON_PARTITION_H_
+
+#include "npy_sort.h"
+
+/* Python include is for future object sorts */
+#include 
+
+#include 
+#include 
+
+#define NPY_MAX_PIVOT_STACK 50
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+NPY_NO_EXPORT PyArray_PartitionFunc *
+get_partition_func(int type, NPY_SELECTKIND which);
+NPY_NO_EXPORT PyArray_ArgPartitionFunc *
+get_argpartition_func(int type, NPY_SELECTKIND which);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/numpy/core/src/common/npy_partition.h.src b/numpy/core/src/common/npy_partition.h.src
deleted file mode 100644
index 72c2095f11cc..000000000000
--- a/numpy/core/src/common/npy_partition.h.src
+++ /dev/null
@@ -1,126 +0,0 @@
-/*
- *****************************************************************************
- **               IMPORTANT NOTE for npy_partition.h.src -> npy_partition.h **
- *****************************************************************************
- *  The template file loops.h.src is not automatically converted into
- *  loops.h by the build system.  If you edit this file, you must manually
- *  do the conversion using numpy/distutils/conv_template.py from the
- *  command line as follows:
- *
- *  $ cd 
- *  $ python  numpy/distutils/conv_template.py numpy/core/src/private/npy_partition.h.src
- *  $
- */
-
-
-#ifndef __NPY_PARTITION_H__
-#define __NPY_PARTITION_H__
-
-
-#include "npy_sort.h"
-
-/* Python include is for future object sorts */
-#include 
-#include 
-#include 
-
-#define ARRAY_SIZE(a) (sizeof(a)/sizeof(a[0]))
-
-#define NPY_MAX_PIVOT_STACK 50
-
-/**begin repeat
- *
- * #TYPE = BOOL, BYTE, UBYTE, SHORT, USHORT, INT, UINT, LONG, ULONG,
- *         LONGLONG, ULONGLONG, HALF, FLOAT, DOUBLE, LONGDOUBLE,
- *         CFLOAT, CDOUBLE, CLONGDOUBLE#
- * #suff = bool, byte, ubyte, short, ushort, int, uint, long, ulong,
- *         longlong, ulonglong, half, float, double, longdouble,
- *         cfloat, cdouble, clongdouble#
- * #type = npy_bool, npy_byte, npy_ubyte, npy_short, npy_ushort, npy_int,
- *         npy_uint, npy_long, npy_ulong, npy_longlong, npy_ulonglong,
- *         npy_ushort, npy_float, npy_double, npy_longdouble, npy_cfloat,
- *         npy_cdouble, npy_clongdouble#
- */
-
-NPY_NO_EXPORT int introselect_@suff@(@type@ *v, npy_intp num,
-                                             npy_intp kth,
-                                             npy_intp * pivots,
-                                             npy_intp * npiv,
-                                             void *NOT_USED);
-NPY_NO_EXPORT int aintroselect_@suff@(@type@ *v, npy_intp* tosort, npy_intp num,
-                                              npy_intp kth,
-                                              npy_intp * pivots,
-                                              npy_intp * npiv,
-                                              void *NOT_USED);
-
-
-/**end repeat**/
-
-typedef struct {
-    int typenum;
-    PyArray_PartitionFunc * part[NPY_NSELECTS];
-    PyArray_ArgPartitionFunc * argpart[NPY_NSELECTS];
-} part_map;
-
-static part_map _part_map[] = {
-/**begin repeat
- *
- * #TYPE = BOOL, BYTE, UBYTE, SHORT, USHORT, INT, UINT, LONG, ULONG,
- *         LONGLONG, ULONGLONG, HALF, FLOAT, DOUBLE, LONGDOUBLE,
- *         CFLOAT, CDOUBLE, CLONGDOUBLE#
- * #suff = bool, byte, ubyte, short, ushort, int, uint, long, ulong,
- *         longlong, ulonglong, half, float, double, longdouble,
- *         cfloat, cdouble, clongdouble#
- * #type = npy_bool, npy_byte, npy_ubyte, npy_short, npy_ushort, npy_int,
- *         npy_uint, npy_long, npy_ulong, npy_longlong, npy_ulonglong,
- *         npy_ushort, npy_float, npy_double, npy_longdouble, npy_cfloat,
- *         npy_cdouble, npy_clongdouble#
- */
-    {
-        NPY_@TYPE@,
-        {
-            (PyArray_PartitionFunc *)&introselect_@suff@,
-        },
-        {
-            (PyArray_ArgPartitionFunc *)&aintroselect_@suff@,
-        }
-    },
-/**end repeat**/
-};
-
-
-static NPY_INLINE PyArray_PartitionFunc *
-get_partition_func(int type, NPY_SELECTKIND which)
-{
-    npy_intp i;
-    npy_intp ntypes = ARRAY_SIZE(_part_map);
-
-    if (which >= NPY_NSELECTS) {
-        return NULL;
-    }
-    for (i = 0; i < ntypes; i++) {
-        if (type == _part_map[i].typenum) {
-            return _part_map[i].part[which];
-        }
-    }
-    return NULL;
-}
-
-
-static NPY_INLINE PyArray_ArgPartitionFunc *
-get_argpartition_func(int type, NPY_SELECTKIND which)
-{
-    npy_intp i;
-    npy_intp ntypes = ARRAY_SIZE(_part_map);
-
-    for (i = 0; i < ntypes; i++) {
-        if (type == _part_map[i].typenum) {
-            return _part_map[i].argpart[which];
-        }
-    }
-    return NULL;
-}
-
-#undef ARRAY_SIZE
-
-#endif
diff --git a/numpy/core/src/common/npy_sort.h.src b/numpy/core/src/common/npy_sort.h.src
index b4a1e9b0cad9..a3f556f56a9c 100644
--- a/numpy/core/src/common/npy_sort.h.src
+++ b/numpy/core/src/common/npy_sort.h.src
@@ -18,6 +18,11 @@ static NPY_INLINE int npy_get_msb(npy_uintp unum)
     return depth_limit;
 }
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
 
 /*
  *****************************************************************************
@@ -102,4 +107,8 @@ NPY_NO_EXPORT int npy_aheapsort(void *vec, npy_intp *ind, npy_intp cnt, void *ar
 NPY_NO_EXPORT int npy_amergesort(void *vec, npy_intp *ind, npy_intp cnt, void *arr);
 NPY_NO_EXPORT int npy_atimsort(void *vec, npy_intp *ind, npy_intp cnt, void *arr);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif
diff --git a/numpy/core/src/common/npy_svml.h b/numpy/core/src/common/npy_svml.h
index 4292f7090333..77e1e1edcd70 100644
--- a/numpy/core/src/common/npy_svml.h
+++ b/numpy/core/src/common/npy_svml.h
@@ -1,5 +1,7 @@
 #if NPY_SIMD && defined(NPY_HAVE_AVX512_SKX) && defined(NPY_CAN_LINK_SVML)
+extern __m512 __svml_expf16(__m512 x);
 extern __m512 __svml_exp2f16(__m512 x);
+extern __m512 __svml_logf16(__m512 x);
 extern __m512 __svml_log2f16(__m512 x);
 extern __m512 __svml_log10f16(__m512 x);
 extern __m512 __svml_expm1f16(__m512 x);
@@ -11,15 +13,18 @@ extern __m512 __svml_tanf16(__m512 x);
 extern __m512 __svml_asinf16(__m512 x);
 extern __m512 __svml_acosf16(__m512 x);
 extern __m512 __svml_atanf16(__m512 x);
-extern __m512 __svml_atan2f16(__m512 x);
+extern __m512 __svml_atan2f16(__m512 x, __m512 y);
 extern __m512 __svml_sinhf16(__m512 x);
 extern __m512 __svml_coshf16(__m512 x);
 extern __m512 __svml_tanhf16(__m512 x);
 extern __m512 __svml_asinhf16(__m512 x);
 extern __m512 __svml_acoshf16(__m512 x);
 extern __m512 __svml_atanhf16(__m512 x);
+extern __m512 __svml_powf16(__m512 x, __m512 y);
 
+extern __m512d __svml_exp8(__m512d x);
 extern __m512d __svml_exp28(__m512d x);
+extern __m512d __svml_log8(__m512d x);
 extern __m512d __svml_log28(__m512d x);
 extern __m512d __svml_log108(__m512d x);
 extern __m512d __svml_expm18(__m512d x);
@@ -31,11 +36,12 @@ extern __m512d __svml_tan8(__m512d x);
 extern __m512d __svml_asin8(__m512d x);
 extern __m512d __svml_acos8(__m512d x);
 extern __m512d __svml_atan8(__m512d x);
-extern __m512d __svml_atan28(__m512d x);
+extern __m512d __svml_atan28(__m512d x, __m512d y);
 extern __m512d __svml_sinh8(__m512d x);
 extern __m512d __svml_cosh8(__m512d x);
 extern __m512d __svml_tanh8(__m512d x);
 extern __m512d __svml_asinh8(__m512d x);
 extern __m512d __svml_acosh8(__m512d x);
 extern __m512d __svml_atanh8(__m512d x);
+extern __m512d __svml_pow8(__m512d x, __m512d y);
 #endif
diff --git a/numpy/core/src/common/numpy_tag.h b/numpy/core/src/common/numpy_tag.h
index dc8d5286b07d..ee0c36cacd73 100644
--- a/numpy/core/src/common/numpy_tag.h
+++ b/numpy/core/src/common/numpy_tag.h
@@ -1,8 +1,15 @@
 #ifndef _NPY_COMMON_TAG_H_
 #define _NPY_COMMON_TAG_H_
 
+#include "../npysort/npysort_common.h"
+
 namespace npy {
 
+template
+struct taglist {
+  static constexpr unsigned size = sizeof...(tags);
+};
+
 struct integral_tag {
 };
 struct floating_point_tag {
@@ -14,63 +21,237 @@ struct date_tag {
 
 struct bool_tag : integral_tag {
     using type = npy_bool;
+    static constexpr NPY_TYPES type_value = NPY_BOOL;
+    static int less(type const& a, type const& b) {
+      return BOOL_LT(a, b);
+    }
+    static int less_equal(type const& a, type const& b) {
+      return !less(b, a);
+    }
 };
 struct byte_tag : integral_tag {
     using type = npy_byte;
+    static constexpr NPY_TYPES type_value = NPY_BYTE;
+    static int less(type const& a, type const& b) {
+      return BYTE_LT(a, b);
+    }
+    static int less_equal(type const& a, type const& b) {
+      return !less(b, a);
+    }
 };
 struct ubyte_tag : integral_tag {
     using type = npy_ubyte;
+    static constexpr NPY_TYPES type_value = NPY_UBYTE;
+    static int less(type const& a, type const& b) {
+      return UBYTE_LT(a, b);
+    }
+    static int less_equal(type const& a, type const& b) {
+      return !less(b, a);
+    }
 };
 struct short_tag : integral_tag {
     using type = npy_short;
+    static constexpr NPY_TYPES type_value = NPY_SHORT;
+    static int less(type const& a, type const& b) {
+      return SHORT_LT(a, b);
+    }
+    static int less_equal(type const& a, type const& b) {
+      return !less(b, a);
+    }
 };
 struct ushort_tag : integral_tag {
     using type = npy_ushort;
+    static constexpr NPY_TYPES type_value = NPY_USHORT;
+    static int less(type const& a, type const& b) {
+      return USHORT_LT(a, b);
+    }
+    static int less_equal(type const& a, type const& b) {
+      return !less(b, a);
+    }
 };
 struct int_tag : integral_tag {
     using type = npy_int;
+    static constexpr NPY_TYPES type_value = NPY_INT;
+    static int less(type const& a, type const& b) {
+      return INT_LT(a, b);
+    }
+    static int less_equal(type const& a, type const& b) {
+      return !less(b, a);
+    }
 };
 struct uint_tag : integral_tag {
     using type = npy_uint;
+    static constexpr NPY_TYPES type_value = NPY_UINT;
+    static int less(type const& a, type const& b) {
+      return UINT_LT(a, b);
+    }
+    static int less_equal(type const& a, type const& b) {
+      return !less(b, a);
+    }
 };
 struct long_tag : integral_tag {
     using type = npy_long;
+    static constexpr NPY_TYPES type_value = NPY_LONG;
+    static int less(type const& a, type const& b) {
+      return LONG_LT(a, b);
+    }
+    static int less_equal(type const& a, type const& b) {
+      return !less(b, a);
+    }
 };
 struct ulong_tag : integral_tag {
     using type = npy_ulong;
+    static constexpr NPY_TYPES type_value = NPY_ULONG;
+    static int less(type const& a, type const& b) {
+      return ULONG_LT(a, b);
+    }
+    static int less_equal(type const& a, type const& b) {
+      return !less(b, a);
+    }
 };
 struct longlong_tag : integral_tag {
     using type = npy_longlong;
+    static constexpr NPY_TYPES type_value = NPY_LONGLONG;
+    static int less(type const& a, type const& b) {
+      return LONGLONG_LT(a, b);
+    }
+    static int less_equal(type const& a, type const& b) {
+      return !less(b, a);
+    }
 };
 struct ulonglong_tag : integral_tag {
     using type = npy_ulonglong;
+    static constexpr NPY_TYPES type_value = NPY_ULONGLONG;
+    static int less(type const& a, type const& b) {
+      return ULONGLONG_LT(a, b);
+    }
+    static int less_equal(type const& a, type const& b) {
+      return !less(b, a);
+    }
 };
 struct half_tag {
     using type = npy_half;
+    static constexpr NPY_TYPES type_value = NPY_HALF;
+    static int less(type const& a, type const& b) {
+      return HALF_LT(a, b);
+    }
+    static int less_equal(type const& a, type const& b) {
+      return !less(b, a);
+    }
 };
 struct float_tag : floating_point_tag {
     using type = npy_float;
+    static constexpr NPY_TYPES type_value = NPY_FLOAT;
+    static int less(type const& a, type const& b) {
+      return FLOAT_LT(a, b);
+    }
+    static int less_equal(type const& a, type const& b) {
+      return !less(b, a);
+    }
 };
 struct double_tag : floating_point_tag {
     using type = npy_double;
+    static constexpr NPY_TYPES type_value = NPY_DOUBLE;
+    static int less(type const& a, type const& b) {
+      return DOUBLE_LT(a, b);
+    }
+    static int less_equal(type const& a, type const& b) {
+      return !less(b, a);
+    }
 };
 struct longdouble_tag : floating_point_tag {
     using type = npy_longdouble;
+    static constexpr NPY_TYPES type_value = NPY_LONGDOUBLE;
+    static int less(type const& a, type const& b) {
+      return LONGDOUBLE_LT(a, b);
+    }
+    static int less_equal(type const& a, type const& b) {
+      return !less(b, a);
+    }
 };
 struct cfloat_tag : complex_tag {
     using type = npy_cfloat;
+    static constexpr NPY_TYPES type_value = NPY_CFLOAT;
+    static int less(type const& a, type const& b) {
+      return CFLOAT_LT(a, b);
+    }
+    static int less_equal(type const& a, type const& b) {
+      return !less(b, a);
+    }
 };
 struct cdouble_tag : complex_tag {
     using type = npy_cdouble;
+    static constexpr NPY_TYPES type_value = NPY_CDOUBLE;
+    static int less(type const& a, type const& b) {
+      return CDOUBLE_LT(a, b);
+    }
+    static int less_equal(type const& a, type const& b) {
+      return !less(b, a);
+    }
 };
 struct clongdouble_tag : complex_tag {
     using type = npy_clongdouble;
+    static constexpr NPY_TYPES type_value = NPY_CLONGDOUBLE;
+    static int less(type const& a, type const& b) {
+      return CLONGDOUBLE_LT(a, b);
+    }
+    static int less_equal(type const& a, type const& b) {
+      return !less(b, a);
+    }
 };
 struct datetime_tag : date_tag {
     using type = npy_datetime;
+    static constexpr NPY_TYPES type_value = NPY_DATETIME;
+    static int less(type const& a, type const& b) {
+      return DATETIME_LT(a, b);
+    }
+    static int less_equal(type const& a, type const& b) {
+      return !less(b, a);
+    }
 };
 struct timedelta_tag : date_tag {
     using type = npy_timedelta;
+    static constexpr NPY_TYPES type_value = NPY_TIMEDELTA;
+    static int less(type const& a, type const& b) {
+      return TIMEDELTA_LT(a, b);
+    }
+    static int less_equal(type const& a, type const& b) {
+      return !less(b, a);
+    }
+};
+
+struct string_tag {
+    using type = npy_char;
+    static constexpr NPY_TYPES type_value = NPY_STRING;
+    static int less(type const* a, type const* b, size_t len) {
+      return STRING_LT(a, b, len);
+    }
+    static int less_equal(type const* a, type const* b, size_t len) {
+      return !less(b, a, len);
+    }
+    static void swap(type* a, type* b, size_t len) {
+      STRING_SWAP(a, b, len);
+    }
+    static void copy(type * a, type const* b, size_t len) {
+      STRING_COPY(a, b, len);
+    }
+};
+
+struct unicode_tag {
+    using type = npy_ucs4;
+    static constexpr NPY_TYPES type_value = NPY_UNICODE;
+    static int less(type const* a, type const* b, size_t len) {
+      return UNICODE_LT(a, b, len);
+    }
+    static int less_equal(type const* a, type const* b, size_t len) {
+      return !less(b, a, len);
+    }
+    static void swap(type* a, type* b, size_t len) {
+      UNICODE_SWAP(a, b, len);
+    }
+    static void copy(type * a, type const* b, size_t len) {
+      UNICODE_COPY(a, b, len);
+    }
 };
 
 }  // namespace npy
diff --git a/numpy/core/src/common/numpyos.c b/numpy/core/src/common/numpyos.c
index 4551a06a2ba1..5ee95191dabd 100644
--- a/numpy/core/src/common/numpyos.c
+++ b/numpy/core/src/common/numpyos.c
@@ -770,27 +770,12 @@ NumPyOS_ascii_ftoLf(FILE *fp, long double *value)
 NPY_NO_EXPORT npy_longlong
 NumPyOS_strtoll(const char *str, char **endptr, int base)
 {
-#if defined HAVE_STRTOLL
     return strtoll(str, endptr, base);
-#elif defined _MSC_VER
-    return _strtoi64(str, endptr, base);
-#else
-    /* ok on 64 bit posix */
-    return PyOS_strtol(str, endptr, base);
-#endif
 }
 
 NPY_NO_EXPORT npy_ulonglong
 NumPyOS_strtoull(const char *str, char **endptr, int base)
 {
-#if defined HAVE_STRTOULL
     return strtoull(str, endptr, base);
-#elif defined _MSC_VER
-    return _strtoui64(str, endptr, base);
-#else
-    /* ok on 64 bit posix */
-    return PyOS_strtoul(str, endptr, base);
-#endif
 }
 
-
diff --git a/numpy/core/src/common/numpyos.h b/numpy/core/src/common/numpyos.h
index ce49cbea7f6e..6e526af17899 100644
--- a/numpy/core/src/common/numpyos.h
+++ b/numpy/core/src/common/numpyos.h
@@ -1,6 +1,10 @@
 #ifndef NUMPY_CORE_SRC_COMMON_NPY_NUMPYOS_H_
 #define NUMPY_CORE_SRC_COMMON_NPY_NUMPYOS_H_
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 NPY_NO_EXPORT char*
 NumPyOS_ascii_formatd(char *buffer, size_t buf_size,
                       const char *format,
@@ -39,4 +43,8 @@ NumPyOS_strtoll(const char *str, char **endptr, int base);
 NPY_NO_EXPORT npy_ulonglong
 NumPyOS_strtoull(const char *str, char **endptr, int base);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif  /* NUMPY_CORE_SRC_COMMON_NPY_NUMPYOS_H_ */
diff --git a/numpy/core/src/common/simd/avx2/avx2.h b/numpy/core/src/common/simd/avx2/avx2.h
index 02ff536fb15e..d64f3c6d652f 100644
--- a/numpy/core/src/common/simd/avx2/avx2.h
+++ b/numpy/core/src/common/simd/avx2/avx2.h
@@ -3,12 +3,15 @@
 #endif
 #define NPY_SIMD 256
 #define NPY_SIMD_WIDTH 32
+#define NPY_SIMD_F32 1
 #define NPY_SIMD_F64 1
 #ifdef NPY_HAVE_FMA3
     #define NPY_SIMD_FMA3 1 // native support
 #else
     #define NPY_SIMD_FMA3 0 // fast emulated
 #endif
+#define NPY_SIMD_BIGENDIAN 0
+#define NPY_SIMD_CMPSIGNAL 0
 // Enough limit to allow us to use _mm256_i32gather_*
 #define NPY_SIMD_MAXLOAD_STRIDE32 (0x7fffffff / 8)
 
diff --git a/numpy/core/src/common/simd/avx2/conversion.h b/numpy/core/src/common/simd/avx2/conversion.h
index 64e051686794..00ac0d38a31a 100644
--- a/numpy/core/src/common/simd/avx2/conversion.h
+++ b/numpy/core/src/common/simd/avx2/conversion.h
@@ -58,6 +58,36 @@ NPY_FINLINE npyv_u32x2 npyv_expand_u32_u16(npyv_u16 data) {
     return r;
 }
 
+// pack two 16-bit boolean into one 8-bit boolean vector
+NPY_FINLINE npyv_b8 npyv_pack_b8_b16(npyv_b16 a, npyv_b16 b) {
+    __m256i ab = _mm256_packs_epi16(a, b);
+    return npyv256_shuffle_odd(ab);
+}
+
+// pack four 32-bit boolean vectors into one 8-bit boolean vector
+NPY_FINLINE npyv_b8
+npyv_pack_b8_b32(npyv_b32 a, npyv_b32 b, npyv_b32 c, npyv_b32 d) {
+    __m256i ab = _mm256_packs_epi32(a, b);
+    __m256i cd = _mm256_packs_epi32(c, d);
+    __m256i abcd = npyv_pack_b8_b16(ab, cd);
+    return _mm256_shuffle_epi32(abcd, _MM_SHUFFLE(3, 1, 2, 0));
+}
+
+// pack eight 64-bit boolean vectors into one 8-bit boolean vector
+NPY_FINLINE npyv_b8
+npyv_pack_b8_b64(npyv_b64 a, npyv_b64 b, npyv_b64 c, npyv_b64 d,
+                 npyv_b64 e, npyv_b64 f, npyv_b64 g, npyv_b64 h) {
+    __m256i ab = _mm256_packs_epi32(a, b);
+    __m256i cd = _mm256_packs_epi32(c, d);
+    __m256i ef = _mm256_packs_epi32(e, f);
+    __m256i gh = _mm256_packs_epi32(g, h);
+    __m256i abcd = _mm256_packs_epi32(ab, cd);
+    __m256i efgh = _mm256_packs_epi32(ef, gh);
+    __m256i all  = npyv256_shuffle_odd(_mm256_packs_epi16(abcd, efgh));
+    __m256i rev128 = _mm256_alignr_epi8(all, all, 8);
+    return _mm256_unpacklo_epi16(all, rev128);
+}
+
 // round to nearest integer (assuming even)
 #define npyv_round_s32_f32 _mm256_cvtps_epi32
 NPY_FINLINE npyv_s32 npyv_round_s32_f64(npyv_f64 a, npyv_f64 b)
diff --git a/numpy/core/src/common/simd/avx2/math.h b/numpy/core/src/common/simd/avx2/math.h
index ec15e50e1fdb..1ef9cd36a36d 100644
--- a/numpy/core/src/common/simd/avx2/math.h
+++ b/numpy/core/src/common/simd/avx2/math.h
@@ -42,7 +42,7 @@ NPY_FINLINE npyv_f64 npyv_square_f64(npyv_f64 a)
 #define npyv_max_f64 _mm256_max_pd
 // Maximum, supports IEEE floating-point arithmetic (IEC 60559),
 // - If one of the two vectors contains NaN, the equivalent element of the other vector is set
-// - Only if both corresponded elements are NaN, NaN is set. 
+// - Only if both corresponded elements are NaN, NaN is set.
 NPY_FINLINE npyv_f32 npyv_maxp_f32(npyv_f32 a, npyv_f32 b)
 {
     __m256 nn  = _mm256_cmp_ps(b, b, _CMP_ORD_Q);
@@ -55,6 +55,21 @@ NPY_FINLINE npyv_f64 npyv_maxp_f64(npyv_f64 a, npyv_f64 b)
     __m256d max = _mm256_max_pd(a, b);
     return _mm256_blendv_pd(a, max, nn);
 }
+// Maximum, propagates NaNs
+// If any of corresponded elements is NaN, NaN is set.
+NPY_FINLINE npyv_f32 npyv_maxn_f32(npyv_f32 a, npyv_f32 b)
+{
+    __m256 nn  = _mm256_cmp_ps(a, a, _CMP_ORD_Q);
+    __m256 max = _mm256_max_ps(a, b);
+    return _mm256_blendv_ps(a, max, nn);
+}
+NPY_FINLINE npyv_f64 npyv_maxn_f64(npyv_f64 a, npyv_f64 b)
+{
+    __m256d nn  = _mm256_cmp_pd(a, a, _CMP_ORD_Q);
+    __m256d max = _mm256_max_pd(a, b);
+    return _mm256_blendv_pd(a, max, nn);
+}
+
 // Maximum, integer operations
 #define npyv_max_u8 _mm256_max_epu8
 #define npyv_max_s8 _mm256_max_epi8
@@ -76,7 +91,7 @@ NPY_FINLINE npyv_s64 npyv_max_s64(npyv_s64 a, npyv_s64 b)
 #define npyv_min_f64 _mm256_min_pd
 // Minimum, supports IEEE floating-point arithmetic (IEC 60559),
 // - If one of the two vectors contains NaN, the equivalent element of the other vector is set
-// - Only if both corresponded elements are NaN, NaN is set. 
+// - Only if both corresponded elements are NaN, NaN is set.
 NPY_FINLINE npyv_f32 npyv_minp_f32(npyv_f32 a, npyv_f32 b)
 {
     __m256 nn  = _mm256_cmp_ps(b, b, _CMP_ORD_Q);
@@ -89,6 +104,20 @@ NPY_FINLINE npyv_f64 npyv_minp_f64(npyv_f64 a, npyv_f64 b)
     __m256d min = _mm256_min_pd(a, b);
     return _mm256_blendv_pd(a, min, nn);
 }
+// Minimum, propagates NaNs
+// If any of corresponded element is NaN, NaN is set.
+NPY_FINLINE npyv_f32 npyv_minn_f32(npyv_f32 a, npyv_f32 b)
+{
+    __m256 nn  = _mm256_cmp_ps(a, a, _CMP_ORD_Q);
+    __m256 min = _mm256_min_ps(a, b);
+    return _mm256_blendv_ps(a, min, nn);
+}
+NPY_FINLINE npyv_f64 npyv_minn_f64(npyv_f64 a, npyv_f64 b)
+{
+    __m256d nn  = _mm256_cmp_pd(a, a, _CMP_ORD_Q);
+    __m256d min = _mm256_min_pd(a, b);
+    return _mm256_blendv_pd(a, min, nn);
+}
 // Minimum, integer operations
 #define npyv_min_u8 _mm256_min_epu8
 #define npyv_min_s8 _mm256_min_epi8
@@ -104,6 +133,110 @@ NPY_FINLINE npyv_s64 npyv_min_s64(npyv_s64 a, npyv_s64 b)
 {
     return _mm256_blendv_epi8(a, b, _mm256_cmpgt_epi64(a, b));
 }
+// reduce min&max for 32&64-bits
+#define NPY_IMPL_AVX2_REDUCE_MINMAX(STYPE, INTRIN, VINTRIN)                                              \
+    NPY_FINLINE STYPE##32 npyv_reduce_##INTRIN##32(__m256i a)                                            \
+    {                                                                                                    \
+        __m128i v128 = _mm_##VINTRIN##32(_mm256_castsi256_si128(a), _mm256_extracti128_si256(a, 1));     \
+        __m128i v64 =  _mm_##VINTRIN##32(v128, _mm_shuffle_epi32(v128, _MM_SHUFFLE(0, 0, 3, 2)));        \
+        __m128i v32 = _mm_##VINTRIN##32(v64, _mm_shuffle_epi32(v64, _MM_SHUFFLE(0, 0, 0, 1)));           \
+        return (STYPE##32)_mm_cvtsi128_si32(v32);                                                        \
+    }                                                                                                    \
+    NPY_FINLINE STYPE##64 npyv_reduce_##INTRIN##64(__m256i a)                                            \
+    {                                                                                                    \
+        __m256i v128 = npyv_##INTRIN##64(a, _mm256_permute2f128_si256(a, a, _MM_SHUFFLE(0, 0, 0, 1)));   \
+        __m256i v64  = npyv_##INTRIN##64(v128, _mm256_shuffle_epi32(v128, _MM_SHUFFLE(0, 0, 3, 2)));     \
+        return (STYPE##64)npyv_extract0_u64(v64);                                                        \
+    }
+NPY_IMPL_AVX2_REDUCE_MINMAX(npy_uint, min_u, min_epu)
+NPY_IMPL_AVX2_REDUCE_MINMAX(npy_int,  min_s, min_epi)
+NPY_IMPL_AVX2_REDUCE_MINMAX(npy_uint, max_u, max_epu)
+NPY_IMPL_AVX2_REDUCE_MINMAX(npy_int,  max_s, max_epi)
+#undef NPY_IMPL_AVX2_REDUCE_MINMAX
+
+// reduce min&max for ps & pd
+#define NPY_IMPL_AVX2_REDUCE_MINMAX(INTRIN, INF, INF64)                                              \
+    NPY_FINLINE float npyv_reduce_##INTRIN##_f32(npyv_f32 a)                                         \
+    {                                                                                                \
+        __m128 v128 = _mm_##INTRIN##_ps(_mm256_castps256_ps128(a), _mm256_extractf128_ps(a, 1));     \
+        __m128 v64 =  _mm_##INTRIN##_ps(v128, _mm_shuffle_ps(v128, v128, _MM_SHUFFLE(0, 0, 3, 2)));  \
+        __m128 v32 = _mm_##INTRIN##_ps(v64, _mm_shuffle_ps(v64, v64, _MM_SHUFFLE(0, 0, 0, 1)));      \
+        return _mm_cvtss_f32(v32);                                                                   \
+    }                                                                                                \
+    NPY_FINLINE double npyv_reduce_##INTRIN##_f64(npyv_f64 a)                                        \
+    {                                                                                                \
+        __m128d v128 = _mm_##INTRIN##_pd(_mm256_castpd256_pd128(a), _mm256_extractf128_pd(a, 1));    \
+        __m128d v64 =  _mm_##INTRIN##_pd(v128, _mm_shuffle_pd(v128, v128, _MM_SHUFFLE(0, 0, 0, 1))); \
+        return _mm_cvtsd_f64(v64);                                                                   \
+    }                                                                                                \
+    NPY_FINLINE float npyv_reduce_##INTRIN##p_f32(npyv_f32 a)                                        \
+    {                                                                                                \
+        npyv_b32 notnan = npyv_notnan_f32(a);                                                        \
+        if (NPY_UNLIKELY(!npyv_any_b32(notnan))) {                                                   \
+            return _mm_cvtss_f32(_mm256_castps256_ps128(a));                                         \
+        }                                                                                            \
+        a = npyv_select_f32(notnan, a, npyv_reinterpret_f32_u32(npyv_setall_u32(INF)));              \
+        return npyv_reduce_##INTRIN##_f32(a);                                                        \
+    }                                                                                                \
+    NPY_FINLINE double npyv_reduce_##INTRIN##p_f64(npyv_f64 a)                                       \
+    {                                                                                                \
+        npyv_b64 notnan = npyv_notnan_f64(a);                                                        \
+        if (NPY_UNLIKELY(!npyv_any_b64(notnan))) {                                                   \
+            return _mm_cvtsd_f64(_mm256_castpd256_pd128(a));                                         \
+        }                                                                                            \
+        a = npyv_select_f64(notnan, a, npyv_reinterpret_f64_u64(npyv_setall_u64(INF64)));            \
+        return npyv_reduce_##INTRIN##_f64(a);                                                        \
+    }                                                                                                \
+    NPY_FINLINE float npyv_reduce_##INTRIN##n_f32(npyv_f32 a)                                        \
+    {                                                                                                \
+        npyv_b32 notnan = npyv_notnan_f32(a);                                                        \
+        if (NPY_UNLIKELY(!npyv_all_b32(notnan))) {                                                   \
+            const union { npy_uint32 i; float f;} pnan = {0x7fc00000UL};                             \
+            return pnan.f;                                                                           \
+        }                                                                                            \
+        return npyv_reduce_##INTRIN##_f32(a);                                                        \
+    }                                                                                                \
+    NPY_FINLINE double npyv_reduce_##INTRIN##n_f64(npyv_f64 a)                                       \
+    {                                                                                                \
+        npyv_b64 notnan = npyv_notnan_f64(a);                                                        \
+        if (NPY_UNLIKELY(!npyv_all_b64(notnan))) {                                                   \
+            const union { npy_uint64 i; double d;} pnan = {0x7ff8000000000000ull};                   \
+            return pnan.d;                                                                           \
+        }                                                                                            \
+        return npyv_reduce_##INTRIN##_f64(a);                                                        \
+    }
+NPY_IMPL_AVX2_REDUCE_MINMAX(min, 0x7f800000, 0x7ff0000000000000)
+NPY_IMPL_AVX2_REDUCE_MINMAX(max, 0xff800000, 0xfff0000000000000)
+#undef NPY_IMPL_AVX2_REDUCE_MINMAX
+
+// reduce min&max for 8&16-bits
+#define NPY_IMPL_AVX256_REDUCE_MINMAX(STYPE, INTRIN, VINTRIN)                                        \
+    NPY_FINLINE STYPE##16 npyv_reduce_##INTRIN##16(__m256i a)                                        \
+    {                                                                                                \
+        __m128i v128 = _mm_##VINTRIN##16(_mm256_castsi256_si128(a), _mm256_extracti128_si256(a, 1)); \
+        __m128i v64 =  _mm_##VINTRIN##16(v128, _mm_shuffle_epi32(v128, _MM_SHUFFLE(0, 0, 3, 2)));    \
+        __m128i v32 = _mm_##VINTRIN##16(v64, _mm_shuffle_epi32(v64, _MM_SHUFFLE(0, 0, 0, 1)));       \
+        __m128i v16 = _mm_##VINTRIN##16(v32, _mm_shufflelo_epi16(v32, _MM_SHUFFLE(0, 0, 0, 1)));     \
+        return (STYPE##16)_mm_cvtsi128_si32(v16);                                                    \
+    }                                                                                                \
+    NPY_FINLINE STYPE##8 npyv_reduce_##INTRIN##8(__m256i a)                                          \
+    {                                                                                                \
+        __m128i v128 = _mm_##VINTRIN##8(_mm256_castsi256_si128(a), _mm256_extracti128_si256(a, 1));  \
+        __m128i v64 =  _mm_##VINTRIN##8(v128, _mm_shuffle_epi32(v128, _MM_SHUFFLE(0, 0, 3, 2)));     \
+        __m128i v32 = _mm_##VINTRIN##8(v64, _mm_shuffle_epi32(v64, _MM_SHUFFLE(0, 0, 0, 1)));        \
+        __m128i v16 = _mm_##VINTRIN##8(v32, _mm_shufflelo_epi16(v32, _MM_SHUFFLE(0, 0, 0, 1)));      \
+        __m128i v8 = _mm_##VINTRIN##8(v16, _mm_srli_epi16(v16, 8));                                  \
+        return (STYPE##16)_mm_cvtsi128_si32(v8);                                                     \
+    }
+NPY_IMPL_AVX256_REDUCE_MINMAX(npy_uint, min_u, min_epu)
+NPY_IMPL_AVX256_REDUCE_MINMAX(npy_int,  min_s, min_epi)
+NPY_IMPL_AVX256_REDUCE_MINMAX(npy_uint, max_u, max_epu)
+NPY_IMPL_AVX256_REDUCE_MINMAX(npy_int,  max_s, max_epi)
+#undef NPY_IMPL_AVX256_REDUCE_MINMAX
+
+// round to nearest integer even
+#define npyv_rint_f32(A) _mm256_round_ps(A, _MM_FROUND_TO_NEAREST_INT)
+#define npyv_rint_f64(A) _mm256_round_pd(A, _MM_FROUND_TO_NEAREST_INT)
 
 // ceil
 #define npyv_ceil_f32 _mm256_ceil_ps
@@ -113,4 +246,8 @@ NPY_FINLINE npyv_s64 npyv_min_s64(npyv_s64 a, npyv_s64 b)
 #define npyv_trunc_f32(A) _mm256_round_ps(A, _MM_FROUND_TO_ZERO)
 #define npyv_trunc_f64(A) _mm256_round_pd(A, _MM_FROUND_TO_ZERO)
 
+// floor
+#define npyv_floor_f32 _mm256_floor_ps
+#define npyv_floor_f64 _mm256_floor_pd
+
 #endif // _NPY_SIMD_AVX2_MATH_H
diff --git a/numpy/core/src/common/simd/avx2/memory.h b/numpy/core/src/common/simd/avx2/memory.h
index 5891a270aa18..410c35dc8873 100644
--- a/numpy/core/src/common/simd/avx2/memory.h
+++ b/numpy/core/src/common/simd/avx2/memory.h
@@ -353,4 +353,25 @@ NPYV_IMPL_AVX2_REST_PARTIAL_TYPES(f32, s32)
 NPYV_IMPL_AVX2_REST_PARTIAL_TYPES(u64, s64)
 NPYV_IMPL_AVX2_REST_PARTIAL_TYPES(f64, s64)
 
+/*********************************
+ * Lookup tables
+ *********************************/
+// uses vector as indexes into a table
+// that contains 32 elements of float32.
+NPY_FINLINE npyv_f32 npyv_lut32_f32(const float *table, npyv_u32 idx)
+{ return _mm256_i32gather_ps(table, idx, 4); }
+NPY_FINLINE npyv_u32 npyv_lut32_u32(const npy_uint32 *table, npyv_u32 idx)
+{ return npyv_reinterpret_u32_f32(npyv_lut32_f32((const float*)table, idx)); }
+NPY_FINLINE npyv_s32 npyv_lut32_s32(const npy_int32 *table, npyv_u32 idx)
+{ return npyv_reinterpret_s32_f32(npyv_lut32_f32((const float*)table, idx)); }
+
+// uses vector as indexes into a table
+// that contains 16 elements of float64.
+NPY_FINLINE npyv_f64 npyv_lut16_f64(const double *table, npyv_u64 idx)
+{ return _mm256_i64gather_pd(table, idx, 8); }
+NPY_FINLINE npyv_u64 npyv_lut16_u64(const npy_uint64 *table, npyv_u64 idx)
+{ return npyv_reinterpret_u64_f64(npyv_lut16_f64((const double*)table, idx)); }
+NPY_FINLINE npyv_s64 npyv_lut16_s64(const npy_int64 *table, npyv_u64 idx)
+{ return npyv_reinterpret_s64_f64(npyv_lut16_f64((const double*)table, idx)); }
+
 #endif // _NPY_SIMD_AVX2_MEMORY_H
diff --git a/numpy/core/src/common/simd/avx2/misc.h b/numpy/core/src/common/simd/avx2/misc.h
index 5e91e91b3d0f..41e788c75a36 100644
--- a/numpy/core/src/common/simd/avx2/misc.h
+++ b/numpy/core/src/common/simd/avx2/misc.h
@@ -31,7 +31,7 @@ NPY_FINLINE __m256i npyv__setr_epi64(npy_int64, npy_int64, npy_int64, npy_int64)
 NPY_FINLINE npyv_u64 npyv_setall_u64(npy_uint64 a)
 {
     npy_int64 ai = (npy_int64)a;
-#if defined(_MSC_VER) && defined(_M_IX86) 
+#if defined(_MSC_VER) && defined(_M_IX86)
     return npyv__setr_epi64(ai, ai, ai, ai);
 #else
     return _mm256_set1_epi64x(ai);
@@ -130,6 +130,18 @@ NPY_FINLINE __m256d npyv__setr_pd(double i0, double i1, double i2, double i3)
 #define npyv_select_f32(MASK, A, B) _mm256_blendv_ps(B, A, _mm256_castsi256_ps(MASK))
 #define npyv_select_f64(MASK, A, B) _mm256_blendv_pd(B, A, _mm256_castsi256_pd(MASK))
 
+// extract the first vector's lane
+#define npyv_extract0_u8(A) ((npy_uint8)_mm_cvtsi128_si32(_mm256_castsi256_si128(A)))
+#define npyv_extract0_s8(A) ((npy_int8)_mm_cvtsi128_si32(_mm256_castsi256_si128(A)))
+#define npyv_extract0_u16(A) ((npy_uint16)_mm_cvtsi128_si32(_mm256_castsi256_si128(A)))
+#define npyv_extract0_s16(A) ((npy_int16)_mm_cvtsi128_si32(_mm256_castsi256_si128(A)))
+#define npyv_extract0_u32(A) ((npy_uint32)_mm_cvtsi128_si32(_mm256_castsi256_si128(A)))
+#define npyv_extract0_s32(A) ((npy_int32)_mm_cvtsi128_si32(_mm256_castsi256_si128(A)))
+#define npyv_extract0_u64(A) ((npy_uint64)npyv128_cvtsi128_si64(_mm256_castsi256_si128(A)))
+#define npyv_extract0_s64(A) ((npy_int64)npyv128_cvtsi128_si64(_mm256_castsi256_si128(A)))
+#define npyv_extract0_f32(A) _mm_cvtss_f32(_mm256_castps256_ps128(A))
+#define npyv_extract0_f64(A) _mm_cvtsd_f64(_mm256_castpd256_pd128(A))
+
 // Reinterpret
 #define npyv_reinterpret_u8_u8(X)  X
 #define npyv_reinterpret_u8_s8(X)  X
diff --git a/numpy/core/src/common/simd/avx2/operators.h b/numpy/core/src/common/simd/avx2/operators.h
index 5fc7719e916d..86e0038d9953 100644
--- a/numpy/core/src/common/simd/avx2/operators.h
+++ b/numpy/core/src/common/simd/avx2/operators.h
@@ -114,6 +114,12 @@ NPY_FINLINE __m256i npyv_shr_s64(__m256i a, int c)
 #define npyv_not_b32 npyv_not_u8
 #define npyv_not_b64 npyv_not_u8
 
+// ANDC, ORC and XNOR
+#define npyv_andc_u8(A, B) _mm256_andnot_si256(B, A)
+#define npyv_andc_b8(A, B) _mm256_andnot_si256(B, A)
+#define npyv_orc_b8(A, B) npyv_or_b8(npyv_not_b8(B), A)
+#define npyv_xnor_b8 _mm256_cmpeq_epi8
+
 /***************************
  * Comparison
  ***************************/
@@ -199,11 +205,11 @@ NPY_FINLINE __m256i npyv_cmpge_u32(__m256i a, __m256i b)
 #define npyv_cmple_u64(A, B) npyv_cmpge_u64(B, A)
 #define npyv_cmple_s64(A, B) npyv_cmpge_s64(B, A)
 
-// precision comparison
+// precision comparison (orderd)
 #define npyv_cmpeq_f32(A, B)  _mm256_castps_si256(_mm256_cmp_ps(A, B, _CMP_EQ_OQ))
 #define npyv_cmpeq_f64(A, B)  _mm256_castpd_si256(_mm256_cmp_pd(A, B, _CMP_EQ_OQ))
-#define npyv_cmpneq_f32(A, B) _mm256_castps_si256(_mm256_cmp_ps(A, B, _CMP_NEQ_OQ))
-#define npyv_cmpneq_f64(A, B) _mm256_castpd_si256(_mm256_cmp_pd(A, B, _CMP_NEQ_OQ))
+#define npyv_cmpneq_f32(A, B) _mm256_castps_si256(_mm256_cmp_ps(A, B, _CMP_NEQ_UQ))
+#define npyv_cmpneq_f64(A, B) _mm256_castpd_si256(_mm256_cmp_pd(A, B, _CMP_NEQ_UQ))
 #define npyv_cmplt_f32(A, B)  _mm256_castps_si256(_mm256_cmp_ps(A, B, _CMP_LT_OQ))
 #define npyv_cmplt_f64(A, B)  _mm256_castpd_si256(_mm256_cmp_pd(A, B, _CMP_LT_OQ))
 #define npyv_cmple_f32(A, B)  _mm256_castps_si256(_mm256_cmp_ps(A, B, _CMP_LE_OQ))
@@ -219,4 +225,58 @@ NPY_FINLINE npyv_b32 npyv_notnan_f32(npyv_f32 a)
 NPY_FINLINE npyv_b64 npyv_notnan_f64(npyv_f64 a)
 { return _mm256_castpd_si256(_mm256_cmp_pd(a, a, _CMP_ORD_Q)); }
 
+// Test cross all vector lanes
+// any: returns true if any of the elements is not equal to zero
+// all: returns true if all elements are not equal to zero
+#define NPYV_IMPL_AVX2_ANYALL(SFX)                \
+    NPY_FINLINE bool npyv_any_##SFX(npyv_##SFX a) \
+    { return _mm256_movemask_epi8(a) != 0; }      \
+    NPY_FINLINE bool npyv_all_##SFX(npyv_##SFX a) \
+    { return _mm256_movemask_epi8(a) == -1; }
+NPYV_IMPL_AVX2_ANYALL(b8)
+NPYV_IMPL_AVX2_ANYALL(b16)
+NPYV_IMPL_AVX2_ANYALL(b32)
+NPYV_IMPL_AVX2_ANYALL(b64)
+#undef NPYV_IMPL_AVX2_ANYALL
+
+#define NPYV_IMPL_AVX2_ANYALL(SFX)                     \
+    NPY_FINLINE bool npyv_any_##SFX(npyv_##SFX a)      \
+    {                                                  \
+        return _mm256_movemask_epi8(                   \
+            npyv_cmpeq_##SFX(a, npyv_zero_##SFX())     \
+        ) != -1;                                       \
+    }                                                  \
+    NPY_FINLINE bool npyv_all_##SFX(npyv_##SFX a)      \
+    {                                                  \
+        return _mm256_movemask_epi8(                   \
+            npyv_cmpeq_##SFX(a, npyv_zero_##SFX())     \
+        ) == 0;                                        \
+    }
+NPYV_IMPL_AVX2_ANYALL(u8)
+NPYV_IMPL_AVX2_ANYALL(s8)
+NPYV_IMPL_AVX2_ANYALL(u16)
+NPYV_IMPL_AVX2_ANYALL(s16)
+NPYV_IMPL_AVX2_ANYALL(u32)
+NPYV_IMPL_AVX2_ANYALL(s32)
+NPYV_IMPL_AVX2_ANYALL(u64)
+NPYV_IMPL_AVX2_ANYALL(s64)
+#undef NPYV_IMPL_AVX2_ANYALL
+
+#define NPYV_IMPL_AVX2_ANYALL(SFX, XSFX, MASK)                   \
+    NPY_FINLINE bool npyv_any_##SFX(npyv_##SFX a)                \
+    {                                                            \
+        return _mm256_movemask_##XSFX(                           \
+            _mm256_cmp_##XSFX(a, npyv_zero_##SFX(), _CMP_EQ_OQ)  \
+        ) != MASK;                                               \
+    }                                                            \
+    NPY_FINLINE bool npyv_all_##SFX(npyv_##SFX a)                \
+    {                                                            \
+        return _mm256_movemask_##XSFX(                           \
+            _mm256_cmp_##XSFX(a, npyv_zero_##SFX(), _CMP_EQ_OQ)  \
+        ) == 0;                                                  \
+    }
+NPYV_IMPL_AVX2_ANYALL(f32, ps, 0xff)
+NPYV_IMPL_AVX2_ANYALL(f64, pd, 0xf)
+#undef NPYV_IMPL_AVX2_ANYALL
+
 #endif // _NPY_SIMD_AVX2_OPERATORS_H
diff --git a/numpy/core/src/common/simd/avx512/arithmetic.h b/numpy/core/src/common/simd/avx512/arithmetic.h
index f8632e701790..1290dc0ade2d 100644
--- a/numpy/core/src/common/simd/avx512/arithmetic.h
+++ b/numpy/core/src/common/simd/avx512/arithmetic.h
@@ -411,6 +411,7 @@ NPY_FINLINE npyv_s64 npyv_divc_s64(npyv_s64 a, const npyv_s64x3 divisor)
         __m512d sum8  = _mm512_add_pd(sum16, h16);
         return _mm_cvtsd_f64(_mm512_castpd512_pd128(sum8));
     }
+
 #endif
 
 // expand the source vector and performs sum reduce
diff --git a/numpy/core/src/common/simd/avx512/avx512.h b/numpy/core/src/common/simd/avx512/avx512.h
index f38686834cfb..aa6abe256424 100644
--- a/numpy/core/src/common/simd/avx512/avx512.h
+++ b/numpy/core/src/common/simd/avx512/avx512.h
@@ -3,8 +3,11 @@
 #endif
 #define NPY_SIMD 512
 #define NPY_SIMD_WIDTH 64
+#define NPY_SIMD_F32 1
 #define NPY_SIMD_F64 1
 #define NPY_SIMD_FMA3 1 // native support
+#define NPY_SIMD_BIGENDIAN 0
+#define NPY_SIMD_CMPSIGNAL 0
 // Enough limit to allow us to use _mm512_i32gather_* and _mm512_i32scatter_*
 #define NPY_SIMD_MAXLOAD_STRIDE32  (0x7fffffff / 16)
 #define NPY_SIMD_MAXSTORE_STRIDE32 (0x7fffffff / 16)
diff --git a/numpy/core/src/common/simd/avx512/conversion.h b/numpy/core/src/common/simd/avx512/conversion.h
index 0bd44179b332..474aee446b6a 100644
--- a/numpy/core/src/common/simd/avx512/conversion.h
+++ b/numpy/core/src/common/simd/avx512/conversion.h
@@ -90,6 +90,48 @@ NPY_FINLINE npyv_u32x2 npyv_expand_u32_u16(npyv_u16 data)
     return r;
 }
 
+// pack two 16-bit boolean into one 8-bit boolean vector
+NPY_FINLINE npyv_b8 npyv_pack_b8_b16(npyv_b16 a, npyv_b16 b) {
+#ifdef NPY_HAVE_AVX512BW
+    return _mm512_kunpackd((__mmask64)b, (__mmask64)a);
+#else
+    const __m512i idx = _mm512_setr_epi64(0, 2, 4, 6, 1, 3, 5, 7);
+    return _mm512_permutexvar_epi64(idx, npyv512_packs_epi16(a, b));
+#endif
+}
+
+// pack four 32-bit boolean vectors into one 8-bit boolean vector
+NPY_FINLINE npyv_b8
+npyv_pack_b8_b32(npyv_b32 a, npyv_b32 b, npyv_b32 c, npyv_b32 d) {
+#ifdef NPY_HAVE_AVX512BW
+    __mmask32 ab = _mm512_kunpackw((__mmask32)b, (__mmask32)a);
+    __mmask32 cd = _mm512_kunpackw((__mmask32)d, (__mmask32)c);
+    return npyv_pack_b8_b16(ab, cd);
+#else
+    const __m512i idx = _mm512_setr_epi32(
+        0, 4, 1, 5, 2, 6, 3, 7, 8, 12, 9, 13, 10, 14, 11, 15);
+    __m256i ta = npyv512_pack_lo_hi(npyv_cvt_u32_b32(a));
+    __m256i tb = npyv512_pack_lo_hi(npyv_cvt_u32_b32(b));
+    __m256i tc = npyv512_pack_lo_hi(npyv_cvt_u32_b32(c));
+    __m256i td = npyv512_pack_lo_hi(npyv_cvt_u32_b32(d));
+    __m256i ab = _mm256_packs_epi16(ta, tb);
+    __m256i cd = _mm256_packs_epi16(tc, td);
+    __m512i abcd = npyv512_combine_si256(ab, cd);
+    return _mm512_permutexvar_epi32(idx, abcd);
+#endif
+}
+
+// pack eight 64-bit boolean vectors into one 8-bit boolean vector
+NPY_FINLINE npyv_b8
+npyv_pack_b8_b64(npyv_b64 a, npyv_b64 b, npyv_b64 c, npyv_b64 d,
+                 npyv_b64 e, npyv_b64 f, npyv_b64 g, npyv_b64 h) {
+    __mmask16 ab = _mm512_kunpackb((__mmask16)b, (__mmask16)a);
+    __mmask16 cd = _mm512_kunpackb((__mmask16)d, (__mmask16)c);
+    __mmask16 ef = _mm512_kunpackb((__mmask16)f, (__mmask16)e);
+    __mmask16 gh = _mm512_kunpackb((__mmask16)h, (__mmask16)g);
+    return npyv_pack_b8_b32(ab, cd, ef, gh);
+}
+
 // convert boolean vectors to integer bitfield
 NPY_FINLINE npy_uint64 npyv_tobits_b8(npyv_b8 a)
 {
diff --git a/numpy/core/src/common/simd/avx512/math.h b/numpy/core/src/common/simd/avx512/math.h
index f30e50ad05df..97fd2d641cb7 100644
--- a/numpy/core/src/common/simd/avx512/math.h
+++ b/numpy/core/src/common/simd/avx512/math.h
@@ -51,7 +51,7 @@ NPY_FINLINE npyv_f64 npyv_square_f64(npyv_f64 a)
 #define npyv_max_f64 _mm512_max_pd
 // Maximum, supports IEEE floating-point arithmetic (IEC 60559),
 // - If one of the two vectors contains NaN, the equivalent element of the other vector is set
-// - Only if both corresponded elements are NaN, NaN is set. 
+// - Only if both corresponded elements are NaN, NaN is set.
 NPY_FINLINE npyv_f32 npyv_maxp_f32(npyv_f32 a, npyv_f32 b)
 {
     __mmask16 nn = _mm512_cmp_ps_mask(b, b, _CMP_ORD_Q);
@@ -62,6 +62,18 @@ NPY_FINLINE npyv_f64 npyv_maxp_f64(npyv_f64 a, npyv_f64 b)
     __mmask8 nn = _mm512_cmp_pd_mask(b, b, _CMP_ORD_Q);
     return _mm512_mask_max_pd(a, nn, a, b);
 }
+// Maximum, propagates NaNs
+// If any of corresponded element is NaN, NaN is set.
+NPY_FINLINE npyv_f32 npyv_maxn_f32(npyv_f32 a, npyv_f32 b)
+{
+    __mmask16 nn = _mm512_cmp_ps_mask(a, a, _CMP_ORD_Q);
+    return _mm512_mask_max_ps(a, nn, a, b);
+}
+NPY_FINLINE npyv_f64 npyv_maxn_f64(npyv_f64 a, npyv_f64 b)
+{
+    __mmask8 nn = _mm512_cmp_pd_mask(a, a, _CMP_ORD_Q);
+    return _mm512_mask_max_pd(a, nn, a, b);
+}
 // Maximum, integer operations
 #ifdef NPY_HAVE_AVX512BW
     #define npyv_max_u8 _mm512_max_epu8
@@ -84,7 +96,7 @@ NPY_FINLINE npyv_f64 npyv_maxp_f64(npyv_f64 a, npyv_f64 b)
 #define npyv_min_f64 _mm512_min_pd
 // Minimum, supports IEEE floating-point arithmetic (IEC 60559),
 // - If one of the two vectors contains NaN, the equivalent element of the other vector is set
-// - Only if both corresponded elements are NaN, NaN is set. 
+// - Only if both corresponded elements are NaN, NaN is set.
 NPY_FINLINE npyv_f32 npyv_minp_f32(npyv_f32 a, npyv_f32 b)
 {
     __mmask16 nn = _mm512_cmp_ps_mask(b, b, _CMP_ORD_Q);
@@ -95,6 +107,18 @@ NPY_FINLINE npyv_f64 npyv_minp_f64(npyv_f64 a, npyv_f64 b)
     __mmask8 nn = _mm512_cmp_pd_mask(b, b, _CMP_ORD_Q);
     return _mm512_mask_min_pd(a, nn, a, b);
 }
+// Minimum, propagates NaNs
+// If any of corresponded element is NaN, NaN is set.
+NPY_FINLINE npyv_f32 npyv_minn_f32(npyv_f32 a, npyv_f32 b)
+{
+    __mmask16 nn = _mm512_cmp_ps_mask(a, a, _CMP_ORD_Q);
+    return _mm512_mask_min_ps(a, nn, a, b);
+}
+NPY_FINLINE npyv_f64 npyv_minn_f64(npyv_f64 a, npyv_f64 b)
+{
+    __mmask8 nn = _mm512_cmp_pd_mask(a, a, _CMP_ORD_Q);
+    return _mm512_mask_min_pd(a, nn, a, b);
+}
 // Minimum, integer operations
 #ifdef NPY_HAVE_AVX512BW
     #define npyv_min_u8 _mm512_min_epu8
@@ -112,6 +136,164 @@ NPY_FINLINE npyv_f64 npyv_minp_f64(npyv_f64 a, npyv_f64 b)
 #define npyv_min_u64 _mm512_min_epu64
 #define npyv_min_s64 _mm512_min_epi64
 
+#ifdef NPY_HAVE_AVX512F_REDUCE
+    #define npyv_reduce_min_u32 _mm512_reduce_min_epu32
+    #define npyv_reduce_min_s32 _mm512_reduce_min_epi32
+    #define npyv_reduce_min_u64 _mm512_reduce_min_epu64
+    #define npyv_reduce_min_s64 _mm512_reduce_min_epi64
+    #define npyv_reduce_min_f32 _mm512_reduce_min_ps
+    #define npyv_reduce_min_f64 _mm512_reduce_min_pd
+    #define npyv_reduce_max_u32 _mm512_reduce_max_epu32
+    #define npyv_reduce_max_s32 _mm512_reduce_max_epi32
+    #define npyv_reduce_max_u64 _mm512_reduce_max_epu64
+    #define npyv_reduce_max_s64 _mm512_reduce_max_epi64
+    #define npyv_reduce_max_f32 _mm512_reduce_max_ps
+    #define npyv_reduce_max_f64 _mm512_reduce_max_pd
+#else
+    // reduce min&max for 32&64-bits
+    #define NPY_IMPL_AVX512_REDUCE_MINMAX(STYPE, INTRIN, VINTRIN)                              \
+        NPY_FINLINE STYPE##32 npyv_reduce_##INTRIN##32(__m512i a)                              \
+        {                                                                                      \
+            __m256i v256 = _mm256_##VINTRIN##32(npyv512_lower_si256(a),                        \
+                    npyv512_higher_si256(a));                                                  \
+            __m128i v128 = _mm_##VINTRIN##32(_mm256_castsi256_si128(v256),                     \
+                    _mm256_extracti128_si256(v256, 1));                                        \
+            __m128i v64 =  _mm_##VINTRIN##32(v128, _mm_shuffle_epi32(v128,                     \
+                        (_MM_PERM_ENUM)_MM_SHUFFLE(0, 0, 3, 2)));                              \
+            __m128i v32 = _mm_##VINTRIN##32(v64, _mm_shuffle_epi32(v64,                        \
+                        (_MM_PERM_ENUM)_MM_SHUFFLE(0, 0, 0, 1)));                              \
+            return (STYPE##32)_mm_cvtsi128_si32(v32);                                          \
+        }                                                                                      \
+        NPY_FINLINE STYPE##64 npyv_reduce_##INTRIN##64(__m512i a)                              \
+        {                                                                                      \
+            __m512i v256 = _mm512_##VINTRIN##64(a,                                             \
+                    _mm512_shuffle_i64x2(a, a, (_MM_PERM_ENUM)_MM_SHUFFLE(0, 0, 3, 2)));       \
+            __m512i v128 = _mm512_##VINTRIN##64(v256,                                          \
+                    _mm512_shuffle_i64x2(v256, v256, (_MM_PERM_ENUM)_MM_SHUFFLE(0, 0, 0, 1))); \
+            __m512i v64  = _mm512_##VINTRIN##64(v128,                                          \
+                    _mm512_shuffle_epi32(v128, (_MM_PERM_ENUM)_MM_SHUFFLE(0, 0, 3, 2)));       \
+            return (STYPE##64)npyv_extract0_u64(v64);                                          \
+        }
+
+    NPY_IMPL_AVX512_REDUCE_MINMAX(npy_uint, min_u, min_epu)
+    NPY_IMPL_AVX512_REDUCE_MINMAX(npy_int,  min_s, min_epi)
+    NPY_IMPL_AVX512_REDUCE_MINMAX(npy_uint, max_u, max_epu)
+    NPY_IMPL_AVX512_REDUCE_MINMAX(npy_int,  max_s, max_epi)
+    #undef NPY_IMPL_AVX512_REDUCE_MINMAX
+    // reduce min&max for ps & pd
+    #define NPY_IMPL_AVX512_REDUCE_MINMAX(INTRIN)                                         \
+        NPY_FINLINE float npyv_reduce_##INTRIN##_f32(npyv_f32 a)                          \
+        {                                                                                 \
+            __m256 v256 = _mm256_##INTRIN##_ps(                                           \
+                    npyv512_lower_ps256(a), npyv512_higher_ps256(a));                     \
+            __m128 v128 = _mm_##INTRIN##_ps(                                              \
+                    _mm256_castps256_ps128(v256), _mm256_extractf128_ps(v256, 1));        \
+            __m128 v64 =  _mm_##INTRIN##_ps(v128,                                         \
+                    _mm_shuffle_ps(v128, v128, (_MM_PERM_ENUM)_MM_SHUFFLE(0, 0, 3, 2)));  \
+            __m128 v32 = _mm_##INTRIN##_ps(v64,                                           \
+                    _mm_shuffle_ps(v64, v64, (_MM_PERM_ENUM)_MM_SHUFFLE(0, 0, 0, 1)));    \
+            return _mm_cvtss_f32(v32);                                                    \
+        }                                                                                 \
+        NPY_FINLINE double npyv_reduce_##INTRIN##_f64(npyv_f64 a)                         \
+        {                                                                                 \
+            __m256d v256 = _mm256_##INTRIN##_pd(                                          \
+                    npyv512_lower_pd256(a), npyv512_higher_pd256(a));                     \
+            __m128d v128 = _mm_##INTRIN##_pd(                                             \
+                    _mm256_castpd256_pd128(v256), _mm256_extractf128_pd(v256, 1));        \
+            __m128d v64 =  _mm_##INTRIN##_pd(v128,                                        \
+                    _mm_shuffle_pd(v128, v128, (_MM_PERM_ENUM)_MM_SHUFFLE(0, 0, 0, 1)));  \
+            return _mm_cvtsd_f64(v64);                                                    \
+        }
+
+    NPY_IMPL_AVX512_REDUCE_MINMAX(min)
+    NPY_IMPL_AVX512_REDUCE_MINMAX(max)
+    #undef NPY_IMPL_AVX512_REDUCE_MINMAX
+#endif
+#define NPY_IMPL_AVX512_REDUCE_MINMAX(INTRIN, INF, INF64)           \
+    NPY_FINLINE float npyv_reduce_##INTRIN##p_f32(npyv_f32 a)       \
+    {                                                               \
+        npyv_b32 notnan = npyv_notnan_f32(a);                       \
+        if (NPY_UNLIKELY(!npyv_any_b32(notnan))) {                  \
+            return _mm_cvtss_f32(_mm512_castps512_ps128(a));        \
+        }                                                           \
+        a = npyv_select_f32(notnan, a,                              \
+                npyv_reinterpret_f32_u32(npyv_setall_u32(INF)));    \
+        return npyv_reduce_##INTRIN##_f32(a);                       \
+    }                                                               \
+    NPY_FINLINE double npyv_reduce_##INTRIN##p_f64(npyv_f64 a)      \
+    {                                                               \
+        npyv_b64 notnan = npyv_notnan_f64(a);                       \
+        if (NPY_UNLIKELY(!npyv_any_b64(notnan))) {                  \
+            return _mm_cvtsd_f64(_mm512_castpd512_pd128(a));        \
+        }                                                           \
+        a = npyv_select_f64(notnan, a,                              \
+                npyv_reinterpret_f64_u64(npyv_setall_u64(INF64)));  \
+        return npyv_reduce_##INTRIN##_f64(a);                       \
+    }                                                               \
+    NPY_FINLINE float npyv_reduce_##INTRIN##n_f32(npyv_f32 a)       \
+    {                                                               \
+        npyv_b32 notnan = npyv_notnan_f32(a);                       \
+        if (NPY_UNLIKELY(!npyv_all_b32(notnan))) {                  \
+            const union { npy_uint32 i; float f;} pnan = {          \
+                0x7fc00000ul                                        \
+            };                                                      \
+            return pnan.f;                                          \
+        }                                                           \
+        return npyv_reduce_##INTRIN##_f32(a);                       \
+    }                                                               \
+    NPY_FINLINE double npyv_reduce_##INTRIN##n_f64(npyv_f64 a)      \
+    {                                                               \
+        npyv_b64 notnan = npyv_notnan_f64(a);                       \
+        if (NPY_UNLIKELY(!npyv_all_b64(notnan))) {                  \
+            const union { npy_uint64 i; double d;} pnan = {         \
+                0x7ff8000000000000ull                               \
+            };                                                      \
+            return pnan.d;                                          \
+        }                                                           \
+        return npyv_reduce_##INTRIN##_f64(a);                       \
+    }
+
+NPY_IMPL_AVX512_REDUCE_MINMAX(min, 0x7f800000, 0x7ff0000000000000)
+NPY_IMPL_AVX512_REDUCE_MINMAX(max, 0xff800000, 0xfff0000000000000)
+#undef NPY_IMPL_AVX512_REDUCE_MINMAX
+
+// reduce min&max for 8&16-bits
+#define NPY_IMPL_AVX512_REDUCE_MINMAX(STYPE, INTRIN, VINTRIN)                                               \
+    NPY_FINLINE STYPE##16 npyv_reduce_##INTRIN##16(__m512i a)                                               \
+    {                                                                                                       \
+        __m256i v256 = _mm256_##VINTRIN##16(npyv512_lower_si256(a), npyv512_higher_si256(a));               \
+        __m128i v128 = _mm_##VINTRIN##16(_mm256_castsi256_si128(v256), _mm256_extracti128_si256(v256, 1));  \
+        __m128i v64 =  _mm_##VINTRIN##16(v128, _mm_shuffle_epi32(v128,                                      \
+                   (_MM_PERM_ENUM)_MM_SHUFFLE(0, 0, 3, 2)));                                                \
+        __m128i v32 = _mm_##VINTRIN##16(v64, _mm_shuffle_epi32(v64,                                         \
+                   (_MM_PERM_ENUM)_MM_SHUFFLE(0, 0, 0, 1)));                                                \
+        __m128i v16 = _mm_##VINTRIN##16(v32, _mm_shufflelo_epi16(v32,                                       \
+                   (_MM_PERM_ENUM)_MM_SHUFFLE(0, 0, 0, 1)));                                                \
+        return (STYPE##16)_mm_cvtsi128_si32(v16);                                                           \
+    }                                                                                                       \
+    NPY_FINLINE STYPE##8 npyv_reduce_##INTRIN##8(__m512i a)                                                 \
+    {                                                                                                       \
+        __m256i v256 = _mm256_##VINTRIN##8(npyv512_lower_si256(a), npyv512_higher_si256(a));                \
+        __m128i v128 = _mm_##VINTRIN##8(_mm256_castsi256_si128(v256), _mm256_extracti128_si256(v256, 1));   \
+        __m128i v64 =  _mm_##VINTRIN##8(v128, _mm_shuffle_epi32(v128,                                       \
+                    (_MM_PERM_ENUM)_MM_SHUFFLE(0, 0, 3, 2)));                                               \
+        __m128i v32 = _mm_##VINTRIN##8(v64, _mm_shuffle_epi32(v64,                                          \
+                    (_MM_PERM_ENUM)_MM_SHUFFLE(0, 0, 0, 1)));                                               \
+        __m128i v16 = _mm_##VINTRIN##8(v32, _mm_shufflelo_epi16(v32,                                        \
+                    (_MM_PERM_ENUM)_MM_SHUFFLE(0, 0, 0, 1)));                                               \
+        __m128i v8 = _mm_##VINTRIN##8(v16, _mm_srli_epi16(v16, 8));                                         \
+        return (STYPE##16)_mm_cvtsi128_si32(v8);                                                            \
+    }
+NPY_IMPL_AVX512_REDUCE_MINMAX(npy_uint, min_u, min_epu)
+NPY_IMPL_AVX512_REDUCE_MINMAX(npy_int,  min_s, min_epi)
+NPY_IMPL_AVX512_REDUCE_MINMAX(npy_uint, max_u, max_epu)
+NPY_IMPL_AVX512_REDUCE_MINMAX(npy_int,  max_s, max_epi)
+#undef NPY_IMPL_AVX512_REDUCE_MINMAX
+
+// round to nearest integer even
+#define npyv_rint_f32(A) _mm512_roundscale_ps(A, _MM_FROUND_TO_NEAREST_INT)
+#define npyv_rint_f64(A) _mm512_roundscale_pd(A, _MM_FROUND_TO_NEAREST_INT)
+
 // ceil
 #define npyv_ceil_f32(A) _mm512_roundscale_ps(A, _MM_FROUND_TO_POS_INF)
 #define npyv_ceil_f64(A) _mm512_roundscale_pd(A, _MM_FROUND_TO_POS_INF)
@@ -120,4 +302,8 @@ NPY_FINLINE npyv_f64 npyv_minp_f64(npyv_f64 a, npyv_f64 b)
 #define npyv_trunc_f32(A) _mm512_roundscale_ps(A, _MM_FROUND_TO_ZERO)
 #define npyv_trunc_f64(A) _mm512_roundscale_pd(A, _MM_FROUND_TO_ZERO)
 
+// floor
+#define npyv_floor_f32(A) _mm512_roundscale_ps(A, _MM_FROUND_TO_NEG_INF)
+#define npyv_floor_f64(A) _mm512_roundscale_pd(A, _MM_FROUND_TO_NEG_INF)
+
 #endif // _NPY_SIMD_AVX512_MATH_H
diff --git a/numpy/core/src/common/simd/avx512/memory.h b/numpy/core/src/common/simd/avx512/memory.h
index 47095bf72aa1..03fcb4630cd6 100644
--- a/numpy/core/src/common/simd/avx512/memory.h
+++ b/numpy/core/src/common/simd/avx512/memory.h
@@ -276,7 +276,8 @@ NPY_FINLINE void npyv_storen_till_s64(npy_int64 *ptr, npy_intp stride, npy_uintp
         union {                                                                             \
             npyv_lanetype_##F_SFX from_##F_SFX;                                             \
             npyv_lanetype_##T_SFX to_##T_SFX;                                               \
-        } pun = {.from_##F_SFX = fill};                                                     \
+        } pun;                                                                              \
+        pun.from_##F_SFX = fill;                                                            \
         return npyv_reinterpret_##F_SFX##_##T_SFX(npyv_load_till_##T_SFX(                   \
             (const npyv_lanetype_##T_SFX *)ptr, nlane, pun.to_##T_SFX                       \
         ));                                                                                 \
@@ -288,7 +289,8 @@ NPY_FINLINE void npyv_storen_till_s64(npy_int64 *ptr, npy_intp stride, npy_uintp
         union {                                                                             \
             npyv_lanetype_##F_SFX from_##F_SFX;                                             \
             npyv_lanetype_##T_SFX to_##T_SFX;                                               \
-        } pun = {.from_##F_SFX = fill};                                                     \
+        } pun;                                                                              \
+        pun.from_##F_SFX = fill;                                                            \
         return npyv_reinterpret_##F_SFX##_##T_SFX(npyv_loadn_till_##T_SFX(                  \
             (const npyv_lanetype_##T_SFX *)ptr, stride, nlane, pun.to_##T_SFX               \
         ));                                                                                 \
@@ -329,4 +331,33 @@ NPYV_IMPL_AVX512_REST_PARTIAL_TYPES(f32, s32)
 NPYV_IMPL_AVX512_REST_PARTIAL_TYPES(u64, s64)
 NPYV_IMPL_AVX512_REST_PARTIAL_TYPES(f64, s64)
 
+/**************************************************
+ * Lookup table
+ *************************************************/
+// uses vector as indexes into a table
+// that contains 32 elements of float32.
+NPY_FINLINE npyv_f32 npyv_lut32_f32(const float *table, npyv_u32 idx)
+{
+    const npyv_f32 table0 = npyv_load_f32(table);
+    const npyv_f32 table1 = npyv_load_f32(table + 16);
+    return _mm512_permutex2var_ps(table0, idx, table1);
+}
+NPY_FINLINE npyv_u32 npyv_lut32_u32(const npy_uint32 *table, npyv_u32 idx)
+{ return npyv_reinterpret_u32_f32(npyv_lut32_f32((const float*)table, idx)); }
+NPY_FINLINE npyv_s32 npyv_lut32_s32(const npy_int32 *table, npyv_u32 idx)
+{ return npyv_reinterpret_s32_f32(npyv_lut32_f32((const float*)table, idx)); }
+
+// uses vector as indexes into a table
+// that contains 16 elements of float64.
+NPY_FINLINE npyv_f64 npyv_lut16_f64(const double *table, npyv_u64 idx)
+{
+    const npyv_f64 table0 = npyv_load_f64(table);
+    const npyv_f64 table1 = npyv_load_f64(table + 8);
+    return _mm512_permutex2var_pd(table0, idx, table1);
+}
+NPY_FINLINE npyv_u64 npyv_lut16_u64(const npy_uint64 *table, npyv_u64 idx)
+{ return npyv_reinterpret_u64_f64(npyv_lut16_f64((const double*)table, idx)); }
+NPY_FINLINE npyv_s64 npyv_lut16_s64(const npy_int64 *table, npyv_u64 idx)
+{ return npyv_reinterpret_s64_f64(npyv_lut16_f64((const double*)table, idx)); }
+
 #endif // _NPY_SIMD_AVX512_MEMORY_H
diff --git a/numpy/core/src/common/simd/avx512/misc.h b/numpy/core/src/common/simd/avx512/misc.h
index c3039ecfedcb..d9190870eb85 100644
--- a/numpy/core/src/common/simd/avx512/misc.h
+++ b/numpy/core/src/common/simd/avx512/misc.h
@@ -34,7 +34,7 @@ NPY_FINLINE __m512i npyv__setr_epi64(
 NPY_FINLINE npyv_u64 npyv_setall_u64(npy_uint64 a)
 {
     npy_int64 ai = (npy_int64)a;
-#if defined(_MSC_VER) && defined(_M_IX86) 
+#if defined(_MSC_VER) && defined(_M_IX86)
     return npyv__setr_epi64(ai, ai, ai, ai, ai, ai, ai, ai);
 #else
     return _mm512_set1_epi64(ai);
@@ -160,6 +160,18 @@ NPY_FINLINE __m512d npyv__setr_pd(double i0, double i1, double i2, double i3,
 #define npyv_select_f32(MASK, A, B) _mm512_mask_blend_ps(MASK, B, A)
 #define npyv_select_f64(MASK, A, B) _mm512_mask_blend_pd(MASK, B, A)
 
+// extract the first vector's lane
+#define npyv_extract0_u8(A) ((npy_uint8)_mm_cvtsi128_si32(_mm512_castsi512_si128(A)))
+#define npyv_extract0_s8(A) ((npy_int8)_mm_cvtsi128_si32(_mm512_castsi512_si128(A)))
+#define npyv_extract0_u16(A) ((npy_uint16)_mm_cvtsi128_si32(_mm512_castsi512_si128(A)))
+#define npyv_extract0_s16(A) ((npy_int16)_mm_cvtsi128_si32(_mm512_castsi512_si128(A)))
+#define npyv_extract0_u32(A) ((npy_uint32)_mm_cvtsi128_si32(_mm512_castsi512_si128(A)))
+#define npyv_extract0_s32(A) ((npy_int32)_mm_cvtsi128_si32(_mm512_castsi512_si128(A)))
+#define npyv_extract0_u64(A) ((npy_uint64)npyv128_cvtsi128_si64(_mm512_castsi512_si128(A)))
+#define npyv_extract0_s64(A) ((npy_int64)npyv128_cvtsi128_si64(_mm512_castsi512_si128(A)))
+#define npyv_extract0_f32(A) _mm_cvtss_f32(_mm512_castps512_ps128(A))
+#define npyv_extract0_f64(A) _mm_cvtsd_f64(_mm512_castpd512_pd128(A))
+
 // reinterpret
 #define npyv_reinterpret_u8_u8(X)  X
 #define npyv_reinterpret_u8_s8(X)  X
diff --git a/numpy/core/src/common/simd/avx512/operators.h b/numpy/core/src/common/simd/avx512/operators.h
index d53932fa8726..c70932d5f817 100644
--- a/numpy/core/src/common/simd/avx512/operators.h
+++ b/numpy/core/src/common/simd/avx512/operators.h
@@ -5,6 +5,8 @@
 #ifndef _NPY_SIMD_AVX512_OPERATORS_H
 #define _NPY_SIMD_AVX512_OPERATORS_H
 
+#include "conversion.h" // tobits
+
 /***************************
  * Shifting
  ***************************/
@@ -140,6 +142,9 @@
     #define npyv_not_f64(A) _mm512_castsi512_pd(npyv_not_u64(_mm512_castpd_si512(A)))
 #endif
 
+// ANDC
+#define npyv_andc_u8(A, B) _mm512_andnot_si512(B, A)
+
 /***************************
  * Logical (boolean)
  ***************************/
@@ -152,6 +157,9 @@
     #define npyv_xor_b16 _kxor_mask32
     #define npyv_not_b8  _knot_mask64
     #define npyv_not_b16 _knot_mask32
+    #define npyv_andc_b8(A, B) _kandn_mask64(B, A)
+    #define npyv_orc_b8(A, B) npyv_or_b8(npyv_not_b8(B), A)
+    #define npyv_xnor_b8 _kxnor_mask64
 #elif defined(NPY_HAVE_AVX512BW)
     NPY_FINLINE npyv_b8  npyv_and_b8(npyv_b8 a, npyv_b8 b)
     { return a & b; }
@@ -169,6 +177,12 @@
     { return ~a; }
     NPY_FINLINE npyv_b16 npyv_not_b16(npyv_b16 a)
     { return ~a; }
+    NPY_FINLINE npyv_b8  npyv_andc_b8(npyv_b8 a, npyv_b8 b)
+    { return a & (~b); }
+    NPY_FINLINE npyv_b8  npyv_orc_b8(npyv_b8 a, npyv_b8 b)
+    { return a | (~b); }
+    NPY_FINLINE npyv_b8  npyv_xnor_b8(npyv_b8 a, npyv_b8 b)
+    { return ~(a ^ b); }
 #else
     #define npyv_and_b8  _mm512_and_si512
     #define npyv_and_b16 _mm512_and_si512
@@ -178,6 +192,9 @@
     #define npyv_xor_b16 _mm512_xor_si512
     #define npyv_not_b8  npyv_not_u8
     #define npyv_not_b16 npyv_not_u8
+    #define npyv_andc_b8(A, B) _mm512_andnot_si512(B, A)
+    #define npyv_orc_b8(A, B) npyv_or_b8(npyv_not_b8(B), A)
+    #define npyv_xnor_b8(A, B) npyv_not_b8(npyv_xor_b8(A, B))
 #endif
 
 #define npyv_and_b32 _mm512_kand
@@ -304,8 +321,8 @@
 // precision comparison
 #define npyv_cmpeq_f32(A, B)  _mm512_cmp_ps_mask(A, B, _CMP_EQ_OQ)
 #define npyv_cmpeq_f64(A, B)  _mm512_cmp_pd_mask(A, B, _CMP_EQ_OQ)
-#define npyv_cmpneq_f32(A, B) _mm512_cmp_ps_mask(A, B, _CMP_NEQ_OQ)
-#define npyv_cmpneq_f64(A, B) _mm512_cmp_pd_mask(A, B, _CMP_NEQ_OQ)
+#define npyv_cmpneq_f32(A, B) _mm512_cmp_ps_mask(A, B, _CMP_NEQ_UQ)
+#define npyv_cmpneq_f64(A, B) _mm512_cmp_pd_mask(A, B, _CMP_NEQ_UQ)
 #define npyv_cmplt_f32(A, B)  _mm512_cmp_ps_mask(A, B, _CMP_LT_OQ)
 #define npyv_cmplt_f64(A, B)  _mm512_cmp_pd_mask(A, B, _CMP_LT_OQ)
 #define npyv_cmple_f32(A, B)  _mm512_cmp_ps_mask(A, B, _CMP_LE_OQ)
@@ -321,4 +338,43 @@ NPY_FINLINE npyv_b32 npyv_notnan_f32(npyv_f32 a)
 NPY_FINLINE npyv_b64 npyv_notnan_f64(npyv_f64 a)
 { return _mm512_cmp_pd_mask(a, a, _CMP_ORD_Q); }
 
+// Test cross all vector lanes
+// any: returns true if any of the elements is not equal to zero
+// all: returns true if all elements are not equal to zero
+#define NPYV_IMPL_AVX512_ANYALL(SFX, MASK)        \
+    NPY_FINLINE bool npyv_any_##SFX(npyv_##SFX a) \
+    { return npyv_tobits_##SFX(a) != 0; }         \
+    NPY_FINLINE bool npyv_all_##SFX(npyv_##SFX a) \
+    { return npyv_tobits_##SFX(a) == MASK; }
+NPYV_IMPL_AVX512_ANYALL(b8,  0xffffffffffffffffull)
+NPYV_IMPL_AVX512_ANYALL(b16, 0xfffffffful)
+NPYV_IMPL_AVX512_ANYALL(b32, 0xffff)
+NPYV_IMPL_AVX512_ANYALL(b64, 0xff)
+#undef NPYV_IMPL_AVX512_ANYALL
+
+#define NPYV_IMPL_AVX512_ANYALL(SFX, BSFX, MASK)   \
+    NPY_FINLINE bool npyv_any_##SFX(npyv_##SFX a)  \
+    {                                              \
+        return npyv_tobits_##BSFX(                 \
+            npyv_cmpeq_##SFX(a, npyv_zero_##SFX()) \
+        ) != MASK;                                 \
+    }                                              \
+    NPY_FINLINE bool npyv_all_##SFX(npyv_##SFX a)  \
+    {                                              \
+        return npyv_tobits_##BSFX(                 \
+            npyv_cmpeq_##SFX(a, npyv_zero_##SFX()) \
+        ) == 0;                                    \
+    }
+NPYV_IMPL_AVX512_ANYALL(u8,  b8,  0xffffffffffffffffull)
+NPYV_IMPL_AVX512_ANYALL(s8,  b8,  0xffffffffffffffffull)
+NPYV_IMPL_AVX512_ANYALL(u16, b16, 0xfffffffful)
+NPYV_IMPL_AVX512_ANYALL(s16, b16, 0xfffffffful)
+NPYV_IMPL_AVX512_ANYALL(u32, b32, 0xffff)
+NPYV_IMPL_AVX512_ANYALL(s32, b32, 0xffff)
+NPYV_IMPL_AVX512_ANYALL(u64, b64, 0xff)
+NPYV_IMPL_AVX512_ANYALL(s64, b64, 0xff)
+NPYV_IMPL_AVX512_ANYALL(f32, b32, 0xffff)
+NPYV_IMPL_AVX512_ANYALL(f64, b64, 0xff)
+#undef NPYV_IMPL_AVX512_ANYALL
+
 #endif // _NPY_SIMD_AVX512_OPERATORS_H
diff --git a/numpy/core/src/common/simd/avx512/reorder.h b/numpy/core/src/common/simd/avx512/reorder.h
index f043004ecc45..c0b2477f38b8 100644
--- a/numpy/core/src/common/simd/avx512/reorder.h
+++ b/numpy/core/src/common/simd/avx512/reorder.h
@@ -214,13 +214,13 @@ NPY_FINLINE npyv_u16 npyv_rev64_u16(npyv_u16 a)
 
 NPY_FINLINE npyv_u32 npyv_rev64_u32(npyv_u32 a)
 {
-    return _mm512_shuffle_epi32(a, _MM_SHUFFLE(2, 3, 0, 1));
+    return _mm512_shuffle_epi32(a, (_MM_PERM_ENUM)_MM_SHUFFLE(2, 3, 0, 1));
 }
 #define npyv_rev64_s32 npyv_rev64_u32
 
 NPY_FINLINE npyv_f32 npyv_rev64_f32(npyv_f32 a)
 {
-    return _mm512_shuffle_ps(a, a, _MM_SHUFFLE(2, 3, 0, 1));
+    return _mm512_shuffle_ps(a, a, (_MM_PERM_ENUM)_MM_SHUFFLE(2, 3, 0, 1));
 }
 
 #endif // _NPY_SIMD_AVX512_REORDER_H
diff --git a/numpy/core/src/common/simd/avx512/utils.h b/numpy/core/src/common/simd/avx512/utils.h
index c3079283f491..ced3bfef0ef9 100644
--- a/numpy/core/src/common/simd/avx512/utils.h
+++ b/numpy/core/src/common/simd/avx512/utils.h
@@ -87,4 +87,16 @@
         ));                                                  \
     }
 
+#ifndef NPY_HAVE_AVX512BW
+    NPYV_IMPL_AVX512_FROM_AVX2_2ARG(npyv512_packs_epi16,  _mm256_packs_epi16)
+#else
+    #define npyv512_packs_epi16 _mm512_packs_epi16
+#endif
+
+NPY_FINLINE __m256i npyv512_pack_lo_hi(__m512i a) {
+    __m256i lo = npyv512_lower_si256(a);
+    __m256i hi = npyv512_higher_si256(a);
+    return _mm256_packs_epi32(lo, hi);
+}
+
 #endif // _NPY_SIMD_AVX512_UTILS_H
diff --git a/numpy/core/src/common/simd/emulate_maskop.h b/numpy/core/src/common/simd/emulate_maskop.h
index 41e397c2d301..2a808a153ed4 100644
--- a/numpy/core/src/common/simd/emulate_maskop.h
+++ b/numpy/core/src/common/simd/emulate_maskop.h
@@ -36,7 +36,9 @@ NPYV_IMPL_EMULATE_MASK_ADDSUB(u32, b32)
 NPYV_IMPL_EMULATE_MASK_ADDSUB(s32, b32)
 NPYV_IMPL_EMULATE_MASK_ADDSUB(u64, b64)
 NPYV_IMPL_EMULATE_MASK_ADDSUB(s64, b64)
-NPYV_IMPL_EMULATE_MASK_ADDSUB(f32, b32)
+#if NPY_SIMD_F32
+    NPYV_IMPL_EMULATE_MASK_ADDSUB(f32, b32)
+#endif
 #if NPY_SIMD_F64
     NPYV_IMPL_EMULATE_MASK_ADDSUB(f64, b64)
 #endif
diff --git a/numpy/core/src/common/simd/intdiv.h b/numpy/core/src/common/simd/intdiv.h
index a7a461721dba..f5066b59ba1d 100644
--- a/numpy/core/src/common/simd/intdiv.h
+++ b/numpy/core/src/common/simd/intdiv.h
@@ -46,9 +46,6 @@
  *  - For 64-bit division on Aarch64 and IBM/Power, we fall-back to the scalar division
  *    since emulating multiply-high is expensive and both architectures have very fast dividers.
  *
- ** TODO:
- *   - Add support for Power10(VSX4)
- *
  ***************************************************************
  ** Figure 4.1: Unsigned division by run–time invariant divisor
  ***************************************************************
@@ -92,7 +89,9 @@ NPY_FINLINE unsigned npyv__bitscan_revnz_u32(npy_uint32 a)
     unsigned long rl;
     (void)_BitScanReverse(&rl, (unsigned long)a);
     r = (unsigned)rl;
-#elif defined(NPY_HAVE_SSE2) && (defined(__GNUC__) || defined(__clang__) || defined(__INTEL_COMPILER))
+
+#elif defined(NPY_HAVE_SSE2) && (defined(__GNUC__) || defined(__clang__) || defined(__INTEL_COMPILER)) \
+    &&  (defined(NPY_CPU_X86) || defined(NPY_CPU_AMD64))
     __asm__("bsr %1, %0" : "=r" (r) : "r"(a));
 #elif defined(__GNUC__) || defined(__clang__)
     r = 31 - __builtin_clz(a); // performs on arm -> clz, ppc -> cntlzw
@@ -136,7 +135,7 @@ NPY_FINLINE npy_uint64 npyv__divh128_u64(npy_uint64 high, npy_uint64 divisor)
 {
     assert(divisor > 1);
     npy_uint64 quotient;
-#if defined(_M_X64) && defined(_MSC_VER) && _MSC_VER >= 1920
+#if defined(_M_X64) && defined(_MSC_VER) && _MSC_VER >= 1920 && !defined(__clang__)
     npy_uint64 remainder;
     quotient = _udiv128(high, 0, divisor, &remainder);
     (void)remainder;
@@ -209,7 +208,7 @@ NPY_FINLINE npyv_u8x3 npyv_divisor_u8(npy_uint8 d)
     divisor.val[0] = npyv_setall_u16(m);
     divisor.val[1] = npyv_set_u8(sh1);
     divisor.val[2] = npyv_set_u8(sh2);
-#elif defined(NPY_HAVE_VSX2)
+#elif defined(NPY_HAVE_VSX2) || defined(NPY_HAVE_VX)
     divisor.val[0] = npyv_setall_u8(m);
     divisor.val[1] = npyv_setall_u8(sh1);
     divisor.val[2] = npyv_setall_u8(sh2);
@@ -250,7 +249,7 @@ NPY_FINLINE npyv_s8x3 npyv_divisor_s8(npy_int8 d)
     npyv_s8x3 divisor;
     divisor.val[0] = npyv_setall_s8(m);
     divisor.val[2] = npyv_setall_s8(d < 0 ? -1 : 0);
-    #ifdef NPY_HAVE_VSX2
+    #if defined(NPY_HAVE_VSX2) || defined(NPY_HAVE_VX)
         divisor.val[1] = npyv_setall_s8(sh);
     #elif defined(NPY_HAVE_NEON)
         divisor.val[1] = npyv_setall_s8(-sh);
@@ -286,7 +285,7 @@ NPY_FINLINE npyv_u16x3 npyv_divisor_u16(npy_uint16 d)
 #ifdef NPY_HAVE_SSE2 // SSE/AVX2/AVX512
     divisor.val[1] = npyv_set_u16(sh1);
     divisor.val[2] = npyv_set_u16(sh2);
-#elif defined(NPY_HAVE_VSX2)
+#elif defined(NPY_HAVE_VSX2) || defined(NPY_HAVE_VX)
     divisor.val[1] = npyv_setall_u16(sh1);
     divisor.val[2] = npyv_setall_u16(sh2);
 #elif defined(NPY_HAVE_NEON)
@@ -318,7 +317,7 @@ NPY_FINLINE npyv_s16x3 npyv_divisor_s16(npy_int16 d)
     divisor.val[2] = npyv_setall_s16(d < 0 ? -1 : 0); // sign of divisor
 #ifdef NPY_HAVE_SSE2 // SSE/AVX2/AVX512
     divisor.val[1] = npyv_set_s16(sh);
-#elif defined(NPY_HAVE_VSX2)
+#elif defined(NPY_HAVE_VSX2) || defined(NPY_HAVE_VX)
     divisor.val[1] = npyv_setall_s16(sh);
 #elif defined(NPY_HAVE_NEON)
     divisor.val[1] = npyv_setall_s16(-sh);
@@ -353,7 +352,7 @@ NPY_FINLINE npyv_u32x3 npyv_divisor_u32(npy_uint32 d)
 #ifdef NPY_HAVE_SSE2 // SSE/AVX2/AVX512
     divisor.val[1] = npyv_set_u32(sh1);
     divisor.val[2] = npyv_set_u32(sh2);
-#elif defined(NPY_HAVE_VSX2)
+#elif defined(NPY_HAVE_VSX2) || defined(NPY_HAVE_VX)
     divisor.val[1] = npyv_setall_u32(sh1);
     divisor.val[2] = npyv_setall_u32(sh2);
 #elif defined(NPY_HAVE_NEON)
@@ -390,7 +389,7 @@ NPY_FINLINE npyv_s32x3 npyv_divisor_s32(npy_int32 d)
     divisor.val[2] = npyv_setall_s32(d < 0 ? -1 : 0); // sign of divisor
 #ifdef NPY_HAVE_SSE2 // SSE/AVX2/AVX512
     divisor.val[1] = npyv_set_s32(sh);
-#elif defined(NPY_HAVE_VSX2)
+#elif defined(NPY_HAVE_VSX2) || defined(NPY_HAVE_VX)
     divisor.val[1] = npyv_setall_s32(sh);
 #elif defined(NPY_HAVE_NEON)
     divisor.val[1] = npyv_setall_s32(-sh);
@@ -403,7 +402,7 @@ NPY_FINLINE npyv_s32x3 npyv_divisor_s32(npy_int32 d)
 NPY_FINLINE npyv_u64x3 npyv_divisor_u64(npy_uint64 d)
 {
     npyv_u64x3 divisor;
-#if defined(NPY_HAVE_VSX2) || defined(NPY_HAVE_NEON)
+#if defined(NPY_HAVE_VSX2) || defined(NPY_HAVE_VX) || defined(NPY_HAVE_NEON)
     divisor.val[0] = npyv_setall_u64(d);
 #else
     npy_uint64 l, l2, sh1, sh2, m;
@@ -438,7 +437,7 @@ NPY_FINLINE npyv_u64x3 npyv_divisor_u64(npy_uint64 d)
 NPY_FINLINE npyv_s64x3 npyv_divisor_s64(npy_int64 d)
 {
     npyv_s64x3 divisor;
-#if defined(NPY_HAVE_VSX2) || defined(NPY_HAVE_NEON)
+#if defined(NPY_HAVE_VSX2) || defined(NPY_HAVE_VX) || defined(NPY_HAVE_NEON)
     divisor.val[0] = npyv_setall_s64(d);
     divisor.val[1] = npyv_cvt_s64_b64(
         npyv_cmpeq_s64(npyv_setall_s64(-1), divisor.val[0])
diff --git a/numpy/core/src/common/simd/neon/conversion.h b/numpy/core/src/common/simd/neon/conversion.h
index 7487559d1c30..03a5259f51e9 100644
--- a/numpy/core/src/common/simd/neon/conversion.h
+++ b/numpy/core/src/common/simd/neon/conversion.h
@@ -34,10 +34,10 @@ NPY_FINLINE npy_uint64 npyv_tobits_b8(npyv_b8 a)
 {
     const npyv_u8 scale = npyv_set_u8(1, 2, 4, 8, 16, 32, 64, 128, 1, 2, 4, 8, 16, 32, 64, 128);
     npyv_u8 seq_scale = vandq_u8(a, scale);
-#if NPY_SIMD_F64
-    npy_uint8 sumlo = vaddv_u8(vget_low_u8(seq_scale));
-    npy_uint8 sumhi = vaddv_u8(vget_high_u8(seq_scale));
-    return sumlo + ((int)sumhi << 8);
+#if defined(__aarch64__)
+    const npyv_u8 byteOrder = {0,8,1,9,2,10,3,11,4,12,5,13,6,14,7,15};
+    npyv_u8 v0 = vqtbl1q_u8(seq_scale, byteOrder);
+    return vaddlvq_u16(vreinterpretq_u16_u8(v0));
 #else
     npyv_u64 sumh = vpaddlq_u32(vpaddlq_u16(vpaddlq_u8(seq_scale)));
     return vgetq_lane_u64(sumh, 0) + ((int)vgetq_lane_u64(sumh, 1) << 8);
@@ -67,8 +67,9 @@ NPY_FINLINE npy_uint64 npyv_tobits_b32(npyv_b32 a)
 }
 NPY_FINLINE npy_uint64 npyv_tobits_b64(npyv_b64 a)
 {
-    npyv_u64 bit = vshrq_n_u64(a, 63);
-    return vgetq_lane_u64(bit, 0) | ((int)vgetq_lane_u64(bit, 1) << 1);
+    uint64_t lo = vgetq_lane_u64(a, 0);
+    uint64_t hi = vgetq_lane_u64(a, 1);
+    return ((hi & 0x2) | (lo & 0x1));
 }
 
 //expand
@@ -86,6 +87,46 @@ NPY_FINLINE npyv_u32x2 npyv_expand_u32_u16(npyv_u16 data) {
     return r;
 }
 
+// pack two 16-bit boolean into one 8-bit boolean vector
+NPY_FINLINE npyv_b8 npyv_pack_b8_b16(npyv_b16 a, npyv_b16 b) {
+#if defined(__aarch64__)
+    return vuzp1q_u8((uint8x16_t)a, (uint8x16_t)b);
+#else
+    return vcombine_u8(vmovn_u16(a), vmovn_u16(b));
+#endif
+}
+
+// pack four 32-bit boolean vectors into one 8-bit boolean vector
+NPY_FINLINE npyv_b8
+npyv_pack_b8_b32(npyv_b32 a, npyv_b32 b, npyv_b32 c, npyv_b32 d) {
+#if defined(__aarch64__)
+    npyv_b16 ab = vuzp1q_u16((uint16x8_t)a, (uint16x8_t)b);
+    npyv_b16 cd = vuzp1q_u16((uint16x8_t)c, (uint16x8_t)d);
+#else
+    npyv_b16 ab = vcombine_u16(vmovn_u32(a), vmovn_u32(b));
+    npyv_b16 cd = vcombine_u16(vmovn_u32(c), vmovn_u32(d));
+#endif
+    return npyv_pack_b8_b16(ab, cd);
+}
+
+// pack eight 64-bit boolean vectors into one 8-bit boolean vector
+NPY_FINLINE npyv_b8
+npyv_pack_b8_b64(npyv_b64 a, npyv_b64 b, npyv_b64 c, npyv_b64 d,
+                 npyv_b64 e, npyv_b64 f, npyv_b64 g, npyv_b64 h) {
+#if defined(__aarch64__)
+    npyv_b32 ab = vuzp1q_u32((uint32x4_t)a, (uint32x4_t)b);
+    npyv_b32 cd = vuzp1q_u32((uint32x4_t)c, (uint32x4_t)d);
+    npyv_b32 ef = vuzp1q_u32((uint32x4_t)e, (uint32x4_t)f);
+    npyv_u32 gh = vuzp1q_u32((uint32x4_t)g, (uint32x4_t)h);
+#else
+    npyv_b32 ab = vcombine_u32(vmovn_u64(a), vmovn_u64(b));
+    npyv_b32 cd = vcombine_u32(vmovn_u64(c), vmovn_u64(d));
+    npyv_b32 ef = vcombine_u32(vmovn_u64(e), vmovn_u64(f));
+    npyv_b32 gh = vcombine_u32(vmovn_u64(g), vmovn_u64(h));
+#endif
+    return npyv_pack_b8_b32(ab, cd, ef, gh);
+}
+
 // round to nearest integer
 #if NPY_SIMD_F64
     #define npyv_round_s32_f32 vcvtnq_s32_f32
diff --git a/numpy/core/src/common/simd/neon/math.h b/numpy/core/src/common/simd/neon/math.h
index 19e5cd846f7d..01344a41fe25 100644
--- a/numpy/core/src/common/simd/neon/math.h
+++ b/numpy/core/src/common/simd/neon/math.h
@@ -99,8 +99,12 @@ NPY_FINLINE npyv_f32 npyv_recip_f32(npyv_f32 a)
         return vmaxq_f32(vbslq_f32(nn_a, a, b), vbslq_f32(nn_b, b, a));
     }
 #endif
+// Max, propagates NaNs
+// If any of corresponded element is NaN, NaN is set.
+#define npyv_maxn_f32 vmaxq_f32
 #if NPY_SIMD_F64
     #define npyv_maxp_f64 vmaxnmq_f64
+    #define npyv_maxn_f64 vmaxq_f64
 #endif // NPY_SIMD_F64
 // Maximum, integer operations
 #define npyv_max_u8 vmaxq_u8
@@ -134,9 +138,14 @@ NPY_FINLINE npyv_s64 npyv_max_s64(npyv_s64 a, npyv_s64 b)
         return vminq_f32(vbslq_f32(nn_a, a, b), vbslq_f32(nn_b, b, a));
     }
 #endif
+// Min, propagates NaNs
+// If any of corresponded element is NaN, NaN is set.
+#define npyv_minn_f32 vminq_f32
 #if NPY_SIMD_F64
     #define npyv_minp_f64 vminnmq_f64
+    #define npyv_minn_f64 vminq_f64
 #endif // NPY_SIMD_F64
+
 // Minimum, integer operations
 #define npyv_min_u8 vminq_u8
 #define npyv_min_s8 vminq_s8
@@ -152,38 +161,176 @@ NPY_FINLINE npyv_s64 npyv_min_s64(npyv_s64 a, npyv_s64 b)
 {
     return vbslq_s64(npyv_cmplt_s64(a, b), a, b);
 }
+// reduce min/max for all data types
+#if NPY_SIMD_F64
+    #define npyv_reduce_max_u8 vmaxvq_u8
+    #define npyv_reduce_max_s8 vmaxvq_s8
+    #define npyv_reduce_max_u16 vmaxvq_u16
+    #define npyv_reduce_max_s16 vmaxvq_s16
+    #define npyv_reduce_max_u32 vmaxvq_u32
+    #define npyv_reduce_max_s32 vmaxvq_s32
+
+    #define npyv_reduce_max_f32 vmaxvq_f32
+    #define npyv_reduce_max_f64 vmaxvq_f64
+    #define npyv_reduce_maxn_f32 vmaxvq_f32
+    #define npyv_reduce_maxn_f64 vmaxvq_f64
+    #define npyv_reduce_maxp_f32 vmaxnmvq_f32
+    #define npyv_reduce_maxp_f64 vmaxnmvq_f64
+
+    #define npyv_reduce_min_u8 vminvq_u8
+    #define npyv_reduce_min_s8 vminvq_s8
+    #define npyv_reduce_min_u16 vminvq_u16
+    #define npyv_reduce_min_s16 vminvq_s16
+    #define npyv_reduce_min_u32 vminvq_u32
+    #define npyv_reduce_min_s32 vminvq_s32
+
+    #define npyv_reduce_min_f32 vminvq_f32
+    #define npyv_reduce_min_f64 vminvq_f64
+    #define npyv_reduce_minn_f32 vminvq_f32
+    #define npyv_reduce_minn_f64 vminvq_f64
+    #define npyv_reduce_minp_f32 vminnmvq_f32
+    #define npyv_reduce_minp_f64 vminnmvq_f64
+#else
+    #define NPY_IMPL_NEON_REDUCE_MINMAX(INTRIN, STYPE, SFX)                            \
+        NPY_FINLINE npy_##STYPE npyv_reduce_##INTRIN##_##SFX(npyv_##SFX a)             \
+        {                                                                              \
+            STYPE##x8_t r = vp##INTRIN##_##SFX(vget_low_##SFX(a), vget_high_##SFX(a)); \
+                        r = vp##INTRIN##_##SFX(r, r);                                  \
+                        r = vp##INTRIN##_##SFX(r, r);                                  \
+                        r = vp##INTRIN##_##SFX(r, r);                                  \
+            return (npy_##STYPE)vget_lane_##SFX(r, 0);                                 \
+        }
+    NPY_IMPL_NEON_REDUCE_MINMAX(min, uint8, u8)
+    NPY_IMPL_NEON_REDUCE_MINMAX(max, uint8, u8)
+    NPY_IMPL_NEON_REDUCE_MINMAX(min, int8, s8)
+    NPY_IMPL_NEON_REDUCE_MINMAX(max, int8, s8)
+    #undef NPY_IMPL_NEON_REDUCE_MINMAX
+
+    #define NPY_IMPL_NEON_REDUCE_MINMAX(INTRIN, STYPE, SFX)                            \
+        NPY_FINLINE npy_##STYPE npyv_reduce_##INTRIN##_##SFX(npyv_##SFX a)             \
+        {                                                                              \
+            STYPE##x4_t r = vp##INTRIN##_##SFX(vget_low_##SFX(a), vget_high_##SFX(a)); \
+                        r = vp##INTRIN##_##SFX(r, r);                                  \
+                        r = vp##INTRIN##_##SFX(r, r);                                  \
+            return (npy_##STYPE)vget_lane_##SFX(r, 0);                                 \
+        }
+    NPY_IMPL_NEON_REDUCE_MINMAX(min, uint16, u16)
+    NPY_IMPL_NEON_REDUCE_MINMAX(max, uint16, u16)
+    NPY_IMPL_NEON_REDUCE_MINMAX(min, int16, s16)
+    NPY_IMPL_NEON_REDUCE_MINMAX(max, int16, s16)
+    #undef NPY_IMPL_NEON_REDUCE_MINMAX
+
+    #define NPY_IMPL_NEON_REDUCE_MINMAX(INTRIN, STYPE, SFX)                            \
+        NPY_FINLINE npy_##STYPE npyv_reduce_##INTRIN##_##SFX(npyv_##SFX a)             \
+        {                                                                              \
+            STYPE##x2_t r = vp##INTRIN##_##SFX(vget_low_##SFX(a), vget_high_##SFX(a)); \
+                        r = vp##INTRIN##_##SFX(r, r);                                  \
+            return (npy_##STYPE)vget_lane_##SFX(r, 0);                                 \
+        }
+    NPY_IMPL_NEON_REDUCE_MINMAX(min, uint32, u32)
+    NPY_IMPL_NEON_REDUCE_MINMAX(max, uint32, u32)
+    NPY_IMPL_NEON_REDUCE_MINMAX(min, int32, s32)
+    NPY_IMPL_NEON_REDUCE_MINMAX(max, int32, s32)
+    #undef NPY_IMPL_NEON_REDUCE_MINMAX
+
+    #define NPY_IMPL_NEON_REDUCE_MINMAX(INTRIN, INF)                            \
+        NPY_FINLINE float npyv_reduce_##INTRIN##_f32(npyv_f32 a)                \
+        {                                                                       \
+            float32x2_t r = vp##INTRIN##_f32(vget_low_f32(a), vget_high_f32(a));\
+                        r = vp##INTRIN##_f32(r, r);                             \
+            return vget_lane_f32(r, 0);                                         \
+        }                                                                       \
+        NPY_FINLINE float npyv_reduce_##INTRIN##p_f32(npyv_f32 a)               \
+        {                                                                       \
+            npyv_b32 notnan = npyv_notnan_f32(a);                               \
+            if (NPY_UNLIKELY(!npyv_any_b32(notnan))) {                          \
+                return vgetq_lane_f32(a, 0);                                    \
+            }                                                                   \
+            a = npyv_select_f32(notnan, a,                                      \
+                    npyv_reinterpret_f32_u32(npyv_setall_u32(INF)));            \
+            return npyv_reduce_##INTRIN##_f32(a);                               \
+        }                                                                       \
+        NPY_FINLINE float npyv_reduce_##INTRIN##n_f32(npyv_f32 a)               \
+        {                                                                       \
+            return npyv_reduce_##INTRIN##_f32(a);                               \
+        }
+    NPY_IMPL_NEON_REDUCE_MINMAX(min, 0x7f800000)
+    NPY_IMPL_NEON_REDUCE_MINMAX(max, 0xff800000)
+    #undef NPY_IMPL_NEON_REDUCE_MINMAX
+#endif // NPY_SIMD_F64
+#define NPY_IMPL_NEON_REDUCE_MINMAX(INTRIN, STYPE, SFX, OP)       \
+    NPY_FINLINE STYPE npyv_reduce_##INTRIN##_##SFX(npyv_##SFX a)  \
+    {                                                             \
+        STYPE al = (STYPE)vget_low_##SFX(a);                      \
+        STYPE ah = (STYPE)vget_high_##SFX(a);                     \
+        return al OP ah ? al : ah;                                \
+    }
+NPY_IMPL_NEON_REDUCE_MINMAX(max, npy_uint64, u64, >)
+NPY_IMPL_NEON_REDUCE_MINMAX(max, npy_int64,  s64, >)
+NPY_IMPL_NEON_REDUCE_MINMAX(min, npy_uint64, u64, <)
+NPY_IMPL_NEON_REDUCE_MINMAX(min, npy_int64,  s64, <)
+#undef NPY_IMPL_NEON_REDUCE_MINMAX
+
+// round to nearest integer even
+NPY_FINLINE npyv_f32 npyv_rint_f32(npyv_f32 a)
+{
+#ifdef NPY_HAVE_ASIMD
+    return vrndnq_f32(a);
+#else
+    // ARMv7 NEON only supports fp to int truncate conversion.
+    // a magic trick of adding 1.5 * 2^23 is used for rounding
+    // to nearest even and then subtract this magic number to get
+    // the integer.
+    //
+    const npyv_u32 szero = vreinterpretq_u32_f32(vdupq_n_f32(-0.0f));
+    const npyv_u32 sign_mask = vandq_u32(vreinterpretq_u32_f32(a), szero);
+    const npyv_f32 two_power_23 = vdupq_n_f32(8388608.0); // 2^23
+    const npyv_f32 two_power_23h = vdupq_n_f32(12582912.0f); // 1.5 * 2^23
+    npyv_u32 nnan_mask = vceqq_f32(a, a);
+    // eliminate nans to avoid invalid fp errors
+    npyv_f32 abs_x = vabsq_f32(vreinterpretq_f32_u32(vandq_u32(nnan_mask, vreinterpretq_u32_f32(a))));
+    // round by add magic number 1.5 * 2^23
+    npyv_f32 round = vsubq_f32(vaddq_f32(two_power_23h, abs_x), two_power_23h);
+    // copysign
+    round = vreinterpretq_f32_u32(vorrq_u32(vreinterpretq_u32_f32(round), sign_mask ));
+    // a if |a| >= 2^23 or a == NaN
+    npyv_u32 mask = vcleq_f32(abs_x, two_power_23);
+             mask = vandq_u32(mask, nnan_mask);
+    return vbslq_f32(mask, round, a);
+#endif
+}
+#if NPY_SIMD_F64
+    #define npyv_rint_f64 vrndnq_f64
+#endif // NPY_SIMD_F64
 
 // ceil
 #ifdef NPY_HAVE_ASIMD
     #define npyv_ceil_f32 vrndpq_f32
 #else
-   NPY_FINLINE npyv_f32 npyv_ceil_f32(npyv_f32 a)
-   {
-        const npyv_s32 szero = vreinterpretq_s32_f32(vdupq_n_f32(-0.0f));
+    NPY_FINLINE npyv_f32 npyv_ceil_f32(npyv_f32 a)
+    {
         const npyv_u32 one = vreinterpretq_u32_f32(vdupq_n_f32(1.0f));
-        const npyv_s32 max_int = vdupq_n_s32(0x7fffffff);
-        /**
-         * On armv7, vcvtq.f32 handles special cases as follows:
-         *  NaN return 0
-         * +inf or +outrange return 0x80000000(-0.0f)
-         * -inf or -outrange return 0x7fffffff(nan)
-         */
-        npyv_s32 roundi = vcvtq_s32_f32(a);
-        npyv_f32 round = vcvtq_f32_s32(roundi);
+        const npyv_u32 szero = vreinterpretq_u32_f32(vdupq_n_f32(-0.0f));
+        const npyv_u32 sign_mask = vandq_u32(vreinterpretq_u32_f32(a), szero);
+        const npyv_f32 two_power_23 = vdupq_n_f32(8388608.0); // 2^23
+        const npyv_f32 two_power_23h = vdupq_n_f32(12582912.0f); // 1.5 * 2^23
+        npyv_u32 nnan_mask = vceqq_f32(a, a);
+        npyv_f32 x = vreinterpretq_f32_u32(vandq_u32(nnan_mask, vreinterpretq_u32_f32(a)));
+        // eliminate nans to avoid invalid fp errors
+        npyv_f32 abs_x = vabsq_f32(x);
+        // round by add magic number 1.5 * 2^23
+        npyv_f32 round = vsubq_f32(vaddq_f32(two_power_23h, abs_x), two_power_23h);
+        // copysign
+        round = vreinterpretq_f32_u32(vorrq_u32(vreinterpretq_u32_f32(round), sign_mask));
         npyv_f32 ceil = vaddq_f32(round, vreinterpretq_f32_u32(
-            vandq_u32(vcltq_f32(round, a), one))
-        );
-        // respect signed zero, e.g. -0.5 -> -0.0
-        npyv_f32 rzero = vreinterpretq_f32_s32(vorrq_s32(
-            vreinterpretq_s32_f32(ceil),
-            vandq_s32(vreinterpretq_s32_f32(a), szero)
-        ));
-        // if nan or overflow return a
-        npyv_u32 nnan = npyv_notnan_f32(a);
-        npyv_u32 overflow = vorrq_u32(
-            vceqq_s32(roundi, szero), vceqq_s32(roundi, max_int)
+            vandq_u32(vcltq_f32(round, x), one))
         );
-        return vbslq_f32(vbicq_u32(nnan, overflow), rzero, a);
+        // respects signed zero
+        ceil = vreinterpretq_f32_u32(vorrq_u32(vreinterpretq_u32_f32(ceil), sign_mask));
+        // a if |a| >= 2^23 or a == NaN
+        npyv_u32 mask = vcleq_f32(abs_x, two_power_23);
+                 mask = vandq_u32(mask, nnan_mask);
+        return vbslq_f32(mask, ceil, a);
    }
 #endif
 #if NPY_SIMD_F64
@@ -194,33 +341,76 @@ NPY_FINLINE npyv_s64 npyv_min_s64(npyv_s64 a, npyv_s64 b)
 #ifdef NPY_HAVE_ASIMD
     #define npyv_trunc_f32 vrndq_f32
 #else
-   NPY_FINLINE npyv_f32 npyv_trunc_f32(npyv_f32 a)
-   {
-        const npyv_s32 szero = vreinterpretq_s32_f32(vdupq_n_f32(-0.0f));
+    NPY_FINLINE npyv_f32 npyv_trunc_f32(npyv_f32 a)
+    {
         const npyv_s32 max_int = vdupq_n_s32(0x7fffffff);
+        const npyv_u32 exp_mask = vdupq_n_u32(0xff000000);
+        const npyv_s32 szero = vreinterpretq_s32_f32(vdupq_n_f32(-0.0f));
+        const npyv_u32 sign_mask = vandq_u32(
+            vreinterpretq_u32_f32(a), vreinterpretq_u32_s32(szero));
+
+        npyv_u32 nfinite_mask = vshlq_n_u32(vreinterpretq_u32_f32(a), 1);
+                 nfinite_mask = vandq_u32(nfinite_mask, exp_mask);
+                 nfinite_mask = vceqq_u32(nfinite_mask, exp_mask);
+        // elminate nans/inf to avoid invalid fp errors
+        npyv_f32 x = vreinterpretq_f32_u32(
+            veorq_u32(nfinite_mask, vreinterpretq_u32_f32(a)));
         /**
          * On armv7, vcvtq.f32 handles special cases as follows:
          *  NaN return 0
          * +inf or +outrange return 0x80000000(-0.0f)
          * -inf or -outrange return 0x7fffffff(nan)
          */
-        npyv_s32 roundi = vcvtq_s32_f32(a);
-        npyv_f32 round = vcvtq_f32_s32(roundi);
+        npyv_s32 trunci = vcvtq_s32_f32(x);
+        npyv_f32 trunc = vcvtq_f32_s32(trunci);
         // respect signed zero, e.g. -0.5 -> -0.0
-        npyv_f32 rzero = vreinterpretq_f32_s32(vorrq_s32(
-            vreinterpretq_s32_f32(round),
-            vandq_s32(vreinterpretq_s32_f32(a), szero)
-        ));
-        // if nan or overflow return a
-        npyv_u32 nnan = npyv_notnan_f32(a);
-        npyv_u32 overflow = vorrq_u32(
-            vceqq_s32(roundi, szero), vceqq_s32(roundi, max_int)
+        trunc = vreinterpretq_f32_u32(
+            vorrq_u32(vreinterpretq_u32_f32(trunc), sign_mask));
+        // if overflow return a
+        npyv_u32 overflow_mask = vorrq_u32(
+            vceqq_s32(trunci, szero), vceqq_s32(trunci, max_int)
         );
-        return vbslq_f32(vbicq_u32(nnan, overflow), rzero, a);
+        // a if a overflow or nonfinite
+        return vbslq_f32(vorrq_u32(nfinite_mask, overflow_mask), a, trunc);
    }
 #endif
 #if NPY_SIMD_F64
     #define npyv_trunc_f64 vrndq_f64
 #endif // NPY_SIMD_F64
 
+// floor
+#ifdef NPY_HAVE_ASIMD
+    #define npyv_floor_f32 vrndmq_f32
+#else
+    NPY_FINLINE npyv_f32 npyv_floor_f32(npyv_f32 a)
+    {
+        const npyv_u32 one = vreinterpretq_u32_f32(vdupq_n_f32(1.0f));
+        const npyv_u32 szero = vreinterpretq_u32_f32(vdupq_n_f32(-0.0f));
+        const npyv_u32 sign_mask = vandq_u32(vreinterpretq_u32_f32(a), szero);
+        const npyv_f32 two_power_23 = vdupq_n_f32(8388608.0); // 2^23
+        const npyv_f32 two_power_23h = vdupq_n_f32(12582912.0f); // 1.5 * 2^23
+
+        npyv_u32 nnan_mask = vceqq_f32(a, a);
+        npyv_f32 x = vreinterpretq_f32_u32(vandq_u32(nnan_mask, vreinterpretq_u32_f32(a)));
+        // eliminate nans to avoid invalid fp errors
+        npyv_f32 abs_x = vabsq_f32(x);
+        // round by add magic number 1.5 * 2^23
+        npyv_f32 round = vsubq_f32(vaddq_f32(two_power_23h, abs_x), two_power_23h);
+        // copysign
+        round = vreinterpretq_f32_u32(vorrq_u32(vreinterpretq_u32_f32(round), sign_mask));
+        npyv_f32 floor = vsubq_f32(round, vreinterpretq_f32_u32(
+            vandq_u32(vcgtq_f32(round, x), one)
+        ));
+        // respects signed zero
+        floor = vreinterpretq_f32_u32(vorrq_u32(vreinterpretq_u32_f32(floor), sign_mask));
+        // a if |a| >= 2^23 or a == NaN
+        npyv_u32 mask = vcleq_f32(abs_x, two_power_23);
+                 mask = vandq_u32(mask, nnan_mask);
+        return vbslq_f32(mask, floor, a);
+   }
+#endif // NPY_HAVE_ASIMD
+#if NPY_SIMD_F64
+    #define npyv_floor_f64 vrndmq_f64
+#endif // NPY_SIMD_F64
+
 #endif // _NPY_SIMD_NEON_MATH_H
diff --git a/numpy/core/src/common/simd/neon/memory.h b/numpy/core/src/common/simd/neon/memory.h
index 1e258f1bcbef..7060ea628305 100644
--- a/numpy/core/src/common/simd/neon/memory.h
+++ b/numpy/core/src/common/simd/neon/memory.h
@@ -332,5 +332,45 @@ NPYV_IMPL_NEON_REST_PARTIAL_TYPES(u64, s64)
 #if NPY_SIMD_F64
 NPYV_IMPL_NEON_REST_PARTIAL_TYPES(f64, s64)
 #endif
+/*********************************
+ * Lookup table
+ *********************************/
+// uses vector as indexes into a table
+// that contains 32 elements of uint32.
+NPY_FINLINE npyv_u32 npyv_lut32_u32(const npy_uint32 *table, npyv_u32 idx)
+{
+    const unsigned i0 = vgetq_lane_u32(idx, 0);
+    const unsigned i1 = vgetq_lane_u32(idx, 1);
+    const unsigned i2 = vgetq_lane_u32(idx, 2);
+    const unsigned i3 = vgetq_lane_u32(idx, 3);
+
+    uint32x2_t low = vcreate_u32(table[i0]);
+               low = vld1_lane_u32((const uint32_t*)table + i1, low, 1);
+    uint32x2_t high = vcreate_u32(table[i2]);
+               high = vld1_lane_u32((const uint32_t*)table + i3, high, 1);
+    return vcombine_u32(low, high);
+}
+NPY_FINLINE npyv_s32 npyv_lut32_s32(const npy_int32 *table, npyv_u32 idx)
+{ return npyv_reinterpret_s32_u32(npyv_lut32_u32((const npy_uint32*)table, idx)); }
+NPY_FINLINE npyv_f32 npyv_lut32_f32(const float *table, npyv_u32 idx)
+{ return npyv_reinterpret_f32_u32(npyv_lut32_u32((const npy_uint32*)table, idx)); }
+
+// uses vector as indexes into a table
+// that contains 16 elements of uint64.
+NPY_FINLINE npyv_u64 npyv_lut16_u64(const npy_uint64 *table, npyv_u64 idx)
+{
+    const unsigned i0 = vgetq_lane_u32(vreinterpretq_u32_u64(idx), 0);
+    const unsigned i1 = vgetq_lane_u32(vreinterpretq_u32_u64(idx), 2);
+    return vcombine_u64(
+        vld1_u64((const uint64_t*)table + i0),
+        vld1_u64((const uint64_t*)table + i1)
+    );
+}
+NPY_FINLINE npyv_s64 npyv_lut16_s64(const npy_int64 *table, npyv_u64 idx)
+{ return npyv_reinterpret_s64_u64(npyv_lut16_u64((const npy_uint64*)table, idx)); }
+#if NPY_SIMD_F64
+NPY_FINLINE npyv_f64 npyv_lut16_f64(const double *table, npyv_u64 idx)
+{ return npyv_reinterpret_f64_u64(npyv_lut16_u64((const npy_uint64*)table, idx)); }
+#endif
 
 #endif // _NPY_SIMD_NEON_MEMORY_H
diff --git a/numpy/core/src/common/simd/neon/misc.h b/numpy/core/src/common/simd/neon/misc.h
index 51b0c38584a3..9dac0cfafae9 100644
--- a/numpy/core/src/common/simd/neon/misc.h
+++ b/numpy/core/src/common/simd/neon/misc.h
@@ -31,86 +31,94 @@
 
 // vector with specific values set to each lane and
 // set a specific value to all remained lanes
-NPY_FINLINE uint8x16_t npyv__set_u8(npy_uint8 i0, npy_uint8 i1, npy_uint8 i2, npy_uint8 i3,
-    npy_uint8 i4, npy_uint8 i5, npy_uint8 i6, npy_uint8 i7, npy_uint8 i8, npy_uint8 i9,
-    npy_uint8 i10, npy_uint8 i11, npy_uint8 i12, npy_uint8 i13, npy_uint8 i14, npy_uint8 i15)
-{
-    const uint8_t NPY_DECL_ALIGNED(16) data[16] = {
-        i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15
-    };
-    return vld1q_u8(data);
-}
-#define npyv_setf_u8(FILL, ...)  npyv__set_u8(NPYV__SET_FILL_16(npy_uint8, FILL, __VA_ARGS__))
-
-NPY_FINLINE int8x16_t npyv__set_s8(npy_int8 i0, npy_int8 i1, npy_int8 i2, npy_int8 i3,
-    npy_int8 i4, npy_int8 i5, npy_int8 i6, npy_int8 i7, npy_int8 i8, npy_int8 i9,
-    npy_int8 i10, npy_int8 i11, npy_int8 i12, npy_int8 i13, npy_int8 i14, npy_int8 i15)
-{
-    const int8_t NPY_DECL_ALIGNED(16) data[16] = {
-        i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15
-    };
-    return vld1q_s8(data);
-}
-#define npyv_setf_s8(FILL, ...)  npyv__set_s8(NPYV__SET_FILL_16(npy_int8, FILL, __VA_ARGS__))
-
-NPY_FINLINE uint16x8_t npyv__set_u16(npy_uint16 i0, npy_uint16 i1, npy_uint16 i2, npy_uint16 i3,
-    npy_uint16 i4, npy_uint16 i5, npy_uint16 i6, npy_uint16 i7)
-{
-    const uint16_t NPY_DECL_ALIGNED(16) data[8] = {i0, i1, i2, i3, i4, i5, i6, i7};
-    return vld1q_u16(data);
-}
-#define npyv_setf_u16(FILL, ...) npyv__set_u16(NPYV__SET_FILL_8(npy_uint16, FILL, __VA_ARGS__))
-
-NPY_FINLINE int16x8_t npyv__set_s16(npy_int16 i0, npy_int16 i1, npy_int16 i2, npy_int16 i3,
-    npy_int16 i4, npy_int16 i5, npy_int16 i6, npy_int16 i7)
-{
-    const int16_t NPY_DECL_ALIGNED(16) data[8] = {i0, i1, i2, i3, i4, i5, i6, i7};
-    return vld1q_s16(data);
-}
-#define npyv_setf_s16(FILL, ...) npyv__set_s16(NPYV__SET_FILL_8(npy_int16, FILL, __VA_ARGS__))
-
-NPY_FINLINE uint32x4_t npyv__set_u32(npy_uint32 i0, npy_uint32 i1, npy_uint32 i2, npy_uint32 i3)
-{
-    const uint32_t NPY_DECL_ALIGNED(16) data[4] = {i0, i1, i2, i3};
-    return vld1q_u32(data);
-}
-#define npyv_setf_u32(FILL, ...) npyv__set_u32(NPYV__SET_FILL_4(npy_uint32, FILL, __VA_ARGS__))
-
-NPY_FINLINE int32x4_t npyv__set_s32(npy_int32 i0, npy_int32 i1, npy_int32 i2, npy_int32 i3)
-{
-    const int32_t NPY_DECL_ALIGNED(16) data[4] = {i0, i1, i2, i3};
-    return vld1q_s32(data);
-}
-#define npyv_setf_s32(FILL, ...) npyv__set_s32(NPYV__SET_FILL_4(npy_int32, FILL, __VA_ARGS__))
-
-NPY_FINLINE uint64x2_t npyv__set_u64(npy_uint64 i0, npy_uint64 i1)
-{
-    const uint64_t NPY_DECL_ALIGNED(16) data[2] = {i0, i1};
-    return vld1q_u64(data);
-}
-#define npyv_setf_u64(FILL, ...) npyv__set_u64(NPYV__SET_FILL_2(npy_int64, FILL, __VA_ARGS__))
-
-NPY_FINLINE int64x2_t npyv__set_s64(npy_int64 i0, npy_int64 i1)
-{
-    const int64_t NPY_DECL_ALIGNED(16) data[2] = {i0, i1};
-    return vld1q_s64(data);
-}
-#define npyv_setf_s64(FILL, ...) npyv__set_s64(NPYV__SET_FILL_2(npy_int64, FILL, __VA_ARGS__))
-
-NPY_FINLINE float32x4_t npyv__set_f32(float i0, float i1, float i2, float i3)
-{
-    const float NPY_DECL_ALIGNED(16) data[4] = {i0, i1, i2, i3};
-    return vld1q_f32(data);
-}
-#define npyv_setf_f32(FILL, ...) npyv__set_f32(NPYV__SET_FILL_4(float, FILL, __VA_ARGS__))
-
-#ifdef __aarch64__
-NPY_FINLINE float64x2_t npyv__set_f64(double i0, double i1)
-{
-    const double NPY_DECL_ALIGNED(16) data[2] = {i0, i1};
-    return vld1q_f64(data);
-}
-#define npyv_setf_f64(FILL, ...) npyv__set_f64(NPYV__SET_FILL_2(double, FILL, __VA_ARGS__))
+#if defined(__clang__) || defined(__GNUC__)
+    #define npyv_setf_u8(FILL, ...)  ((uint8x16_t){NPYV__SET_FILL_16(uint8_t, FILL, __VA_ARGS__)})
+    #define npyv_setf_s8(FILL, ...)  ((int8x16_t){NPYV__SET_FILL_16(int8_t, FILL, __VA_ARGS__)})
+    #define npyv_setf_u16(FILL, ...) ((uint16x8_t){NPYV__SET_FILL_8(uint16_t, FILL, __VA_ARGS__)})
+    #define npyv_setf_s16(FILL, ...) ((int16x8_t){NPYV__SET_FILL_8(int16_t, FILL, __VA_ARGS__)})
+    #define npyv_setf_u32(FILL, ...) ((uint32x4_t){NPYV__SET_FILL_4(uint32_t, FILL, __VA_ARGS__)})
+    #define npyv_setf_s32(FILL, ...) ((int32x4_t){NPYV__SET_FILL_4(int32_t, FILL, __VA_ARGS__)})
+    #define npyv_setf_u64(FILL, ...) ((uint64x2_t){NPYV__SET_FILL_2(uint64_t, FILL, __VA_ARGS__)})
+    #define npyv_setf_s64(FILL, ...) ((int64x2_t){NPYV__SET_FILL_2(int64_t, FILL, __VA_ARGS__)})
+    #define npyv_setf_f32(FILL, ...) ((float32x4_t){NPYV__SET_FILL_4(float, FILL, __VA_ARGS__)})
+    #if NPY_SIMD_F64
+        #define npyv_setf_f64(FILL, ...) ((float64x2_t){NPYV__SET_FILL_2(double, FILL, __VA_ARGS__)})
+    #endif
+#else
+    NPY_FINLINE uint8x16_t npyv__set_u8(npy_uint8 i0, npy_uint8 i1, npy_uint8 i2, npy_uint8 i3,
+        npy_uint8 i4, npy_uint8 i5, npy_uint8 i6, npy_uint8 i7, npy_uint8 i8, npy_uint8 i9,
+        npy_uint8 i10, npy_uint8 i11, npy_uint8 i12, npy_uint8 i13, npy_uint8 i14, npy_uint8 i15)
+    {
+        const uint8_t NPY_DECL_ALIGNED(16) data[16] = {
+            i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15
+        };
+        return vld1q_u8(data);
+    }
+    NPY_FINLINE int8x16_t npyv__set_s8(npy_int8 i0, npy_int8 i1, npy_int8 i2, npy_int8 i3,
+        npy_int8 i4, npy_int8 i5, npy_int8 i6, npy_int8 i7, npy_int8 i8, npy_int8 i9,
+        npy_int8 i10, npy_int8 i11, npy_int8 i12, npy_int8 i13, npy_int8 i14, npy_int8 i15)
+    {
+        const int8_t NPY_DECL_ALIGNED(16) data[16] = {
+            i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15
+        };
+        return vld1q_s8(data);
+    }
+    NPY_FINLINE uint16x8_t npyv__set_u16(npy_uint16 i0, npy_uint16 i1, npy_uint16 i2, npy_uint16 i3,
+        npy_uint16 i4, npy_uint16 i5, npy_uint16 i6, npy_uint16 i7)
+    {
+        const uint16_t NPY_DECL_ALIGNED(16) data[8] = {i0, i1, i2, i3, i4, i5, i6, i7};
+        return vld1q_u16(data);
+    }
+    NPY_FINLINE int16x8_t npyv__set_s16(npy_int16 i0, npy_int16 i1, npy_int16 i2, npy_int16 i3,
+        npy_int16 i4, npy_int16 i5, npy_int16 i6, npy_int16 i7)
+    {
+        const int16_t NPY_DECL_ALIGNED(16) data[8] = {i0, i1, i2, i3, i4, i5, i6, i7};
+        return vld1q_s16(data);
+    }
+    NPY_FINLINE uint32x4_t npyv__set_u32(npy_uint32 i0, npy_uint32 i1, npy_uint32 i2, npy_uint32 i3)
+    {
+        const uint32_t NPY_DECL_ALIGNED(16) data[4] = {i0, i1, i2, i3};
+        return vld1q_u32(data);
+    }
+    NPY_FINLINE int32x4_t npyv__set_s32(npy_int32 i0, npy_int32 i1, npy_int32 i2, npy_int32 i3)
+    {
+        const int32_t NPY_DECL_ALIGNED(16) data[4] = {i0, i1, i2, i3};
+        return vld1q_s32(data);
+    }
+    NPY_FINLINE uint64x2_t npyv__set_u64(npy_uint64 i0, npy_uint64 i1)
+    {
+        const uint64_t NPY_DECL_ALIGNED(16) data[2] = {i0, i1};
+        return vld1q_u64(data);
+    }
+    NPY_FINLINE int64x2_t npyv__set_s64(npy_int64 i0, npy_int64 i1)
+    {
+        const int64_t NPY_DECL_ALIGNED(16) data[2] = {i0, i1};
+        return vld1q_s64(data);
+    }
+    NPY_FINLINE float32x4_t npyv__set_f32(float i0, float i1, float i2, float i3)
+    {
+        const float NPY_DECL_ALIGNED(16) data[4] = {i0, i1, i2, i3};
+        return vld1q_f32(data);
+    }
+    #if NPY_SIMD_F64
+        NPY_FINLINE float64x2_t npyv__set_f64(double i0, double i1)
+        {
+            const double NPY_DECL_ALIGNED(16) data[2] = {i0, i1};
+            return vld1q_f64(data);
+        }
+    #endif
+    #define npyv_setf_u8(FILL, ...)  npyv__set_u8(NPYV__SET_FILL_16(npy_uint8, FILL, __VA_ARGS__))
+    #define npyv_setf_s8(FILL, ...)  npyv__set_s8(NPYV__SET_FILL_16(npy_int8, FILL, __VA_ARGS__))
+    #define npyv_setf_u16(FILL, ...) npyv__set_u16(NPYV__SET_FILL_8(npy_uint16, FILL, __VA_ARGS__))
+    #define npyv_setf_s16(FILL, ...) npyv__set_s16(NPYV__SET_FILL_8(npy_int16, FILL, __VA_ARGS__))
+    #define npyv_setf_u32(FILL, ...) npyv__set_u32(NPYV__SET_FILL_4(npy_uint32, FILL, __VA_ARGS__))
+    #define npyv_setf_s32(FILL, ...) npyv__set_s32(NPYV__SET_FILL_4(npy_int32, FILL, __VA_ARGS__))
+    #define npyv_setf_u64(FILL, ...) npyv__set_u64(NPYV__SET_FILL_2(npy_uint64, FILL, __VA_ARGS__))
+    #define npyv_setf_s64(FILL, ...) npyv__set_s64(NPYV__SET_FILL_2(npy_int64, FILL, __VA_ARGS__))
+    #define npyv_setf_f32(FILL, ...) npyv__set_f32(NPYV__SET_FILL_4(float, FILL, __VA_ARGS__))
+    #if NPY_SIMD_F64
+        #define npyv_setf_f64(FILL, ...) npyv__set_f64(NPYV__SET_FILL_2(double, FILL, __VA_ARGS__))
+    #endif
 #endif
 
 // vector with specific values set to each lane and
@@ -138,6 +146,18 @@ NPY_FINLINE float64x2_t npyv__set_f64(double i0, double i1)
 #define npyv_select_f32 vbslq_f32
 #define npyv_select_f64 vbslq_f64
 
+// extract the first vector's lane
+#define npyv_extract0_u8(A) ((npy_uint8)vgetq_lane_u8(A, 0))
+#define npyv_extract0_s8(A) ((npy_int8)vgetq_lane_s8(A, 0))
+#define npyv_extract0_u16(A) ((npy_uint16)vgetq_lane_u16(A, 0))
+#define npyv_extract0_s16(A) ((npy_int16)vgetq_lane_s16(A, 0))
+#define npyv_extract0_u32(A) ((npy_uint32)vgetq_lane_u32(A, 0))
+#define npyv_extract0_s32(A) ((npy_int32)vgetq_lane_s32(A, 0))
+#define npyv_extract0_u64(A) ((npy_uint64)vgetq_lane_u64(A, 0))
+#define npyv_extract0_s64(A) ((npy_int64)vgetq_lane_s64(A, 0))
+#define npyv_extract0_f32(A) vgetq_lane_f32(A, 0)
+#define npyv_extract0_f64(A) vgetq_lane_f64(A, 0)
+
 // Reinterpret
 #define npyv_reinterpret_u8_u8(X) X
 #define npyv_reinterpret_u8_s8  vreinterpretq_u8_s8
diff --git a/numpy/core/src/common/simd/neon/neon.h b/numpy/core/src/common/simd/neon/neon.h
index e6f6a732478a..49c35c415e25 100644
--- a/numpy/core/src/common/simd/neon/neon.h
+++ b/numpy/core/src/common/simd/neon/neon.h
@@ -4,7 +4,7 @@
 
 #define NPY_SIMD 128
 #define NPY_SIMD_WIDTH 16
-
+#define NPY_SIMD_F32 1
 #ifdef __aarch64__
     #define NPY_SIMD_F64 1
 #else
@@ -15,6 +15,8 @@
 #else
     #define NPY_SIMD_FMA3 0  // HW emulated
 #endif
+#define NPY_SIMD_BIGENDIAN 0
+#define NPY_SIMD_CMPSIGNAL 1
 
 typedef uint8x16_t  npyv_u8;
 typedef int8x16_t   npyv_s8;
diff --git a/numpy/core/src/common/simd/neon/operators.h b/numpy/core/src/common/simd/neon/operators.h
index b43ba36537e9..ef05d4463c4c 100644
--- a/numpy/core/src/common/simd/neon/operators.h
+++ b/numpy/core/src/common/simd/neon/operators.h
@@ -116,6 +116,12 @@
 #define npyv_not_b32  vmvnq_u32
 #define npyv_not_b64  npyv_not_u64
 
+// ANDC, ORC and XNOR
+#define npyv_andc_u8 vbicq_u8
+#define npyv_andc_b8 vbicq_u8
+#define npyv_orc_b8 vornq_u8
+#define npyv_xnor_b8 vceqq_u8
+
 /***************************
  * Comparison
  ***************************/
@@ -234,10 +240,160 @@
 
 // check special cases
 NPY_FINLINE npyv_b32 npyv_notnan_f32(npyv_f32 a)
-{ return vceqq_f32(a, a); }
+{
+#if defined(__clang__)
+/**
+ * To avoid signaling qNaN, workaround for clang symmetric inputs bug
+ * check https://github.com/numpy/numpy/issues/22933,
+ * for more clarification.
+ */
+    npyv_b32 ret;
+    #if NPY_SIMD_F64
+        __asm ("fcmeq %0.4s, %1.4s, %1.4s" : "=w" (ret) : "w" (a));
+    #else
+        __asm ("vceq.f32 %q0, %q1, %q1" : "=w" (ret) : "w" (a));
+    #endif
+    return ret;
+#else
+    return vceqq_f32(a, a);
+#endif
+}
 #if NPY_SIMD_F64
     NPY_FINLINE npyv_b64 npyv_notnan_f64(npyv_f64 a)
-    { return vceqq_f64(a, a); }
+    {
+    #if defined(__clang__)
+        npyv_b64 ret;
+        __asm ("fcmeq %0.2d, %1.2d, %1.2d" : "=w" (ret) : "w" (a));
+        return ret;
+    #else
+        return vceqq_f64(a, a);
+    #endif
+    }
 #endif
 
+// Test cross all vector lanes
+// any: returns true if any of the elements is not equal to zero
+// all: returns true if all elements are not equal to zero
+#if NPY_SIMD_F64
+    #define NPYV_IMPL_NEON_ANYALL(LEN)                  \
+        NPY_FINLINE bool npyv_any_b##LEN(npyv_b##LEN a) \
+        { return vmaxvq_u##LEN(a) != 0; }               \
+        NPY_FINLINE bool npyv_all_b##LEN(npyv_b##LEN a) \
+        { return vminvq_u##LEN(a) != 0; }
+    NPYV_IMPL_NEON_ANYALL(8)
+    NPYV_IMPL_NEON_ANYALL(16)
+    NPYV_IMPL_NEON_ANYALL(32)
+    #undef NPYV_IMPL_NEON_ANYALL
+
+    #define NPYV_IMPL_NEON_ANYALL(SFX, USFX, BSFX)                      \
+        NPY_FINLINE bool npyv_any_##SFX(npyv_##SFX a)                   \
+        { return npyv_any_##BSFX(npyv_reinterpret_##USFX##_##SFX(a)); } \
+        NPY_FINLINE bool npyv_all_##SFX(npyv_##SFX a)                   \
+        { return npyv_all_##BSFX(npyv_reinterpret_##USFX##_##SFX(a)); }
+    NPYV_IMPL_NEON_ANYALL(u8,  u8,  b8)
+    NPYV_IMPL_NEON_ANYALL(s8,  u8,  b8)
+    NPYV_IMPL_NEON_ANYALL(u16, u16, b16)
+    NPYV_IMPL_NEON_ANYALL(s16, u16, b16)
+    NPYV_IMPL_NEON_ANYALL(u32, u32, b32)
+    NPYV_IMPL_NEON_ANYALL(s32, u32, b32)
+    #undef NPYV_IMPL_NEON_ANYALL
+
+    NPY_FINLINE bool npyv_any_b64(npyv_b64 a)
+    { return vmaxvq_u32(vreinterpretq_u32_u64(a)) != 0; }
+    NPY_FINLINE bool npyv_all_b64(npyv_b64 a)
+    { return vminvq_u32(vreinterpretq_u32_u64(a)) != 0; }
+    #define npyv_any_u64 npyv_any_b64
+    NPY_FINLINE bool npyv_all_u64(npyv_u64 a)
+    {
+        uint32x4_t a32 = vreinterpretq_u32_u64(a);
+                   a32 = vorrq_u32(a32, vrev64q_u32(a32));
+        return vminvq_u32(a32) != 0;
+    }
+    NPY_FINLINE bool npyv_any_s64(npyv_s64 a)
+    { return npyv_any_u64(vreinterpretq_u64_s64(a)); }
+    NPY_FINLINE bool npyv_all_s64(npyv_s64 a)
+    { return npyv_all_u64(vreinterpretq_u64_s64(a)); }
+
+    #define NPYV_IMPL_NEON_ANYALL(SFX, BSFX)                                 \
+        NPY_FINLINE bool npyv_any_##SFX(npyv_##SFX a)                        \
+        { return !npyv_all_##BSFX(npyv_cmpeq_##SFX(a, npyv_zero_##SFX())); } \
+        NPY_FINLINE bool npyv_all_##SFX(npyv_##SFX a)                        \
+        { return !npyv_any_##BSFX(npyv_cmpeq_##SFX(a, npyv_zero_##SFX())); }
+    NPYV_IMPL_NEON_ANYALL(f32, b32)
+    NPYV_IMPL_NEON_ANYALL(f64, b64)
+    #undef NPYV_IMPL_NEON_ANYALL
+#else
+    #define NPYV_IMPL_NEON_ANYALL(LEN)                    \
+        NPY_FINLINE bool npyv_any_b##LEN(npyv_b##LEN a)   \
+        {                                                 \
+            int64x2_t a64 = vreinterpretq_s64_u##LEN(a);  \
+            return (                                      \
+                vgetq_lane_s64(a64, 0) |                  \
+                vgetq_lane_s64(a64, 1)                    \
+            ) != 0;                                       \
+        }                                                 \
+        NPY_FINLINE bool npyv_all_b##LEN(npyv_b##LEN a)   \
+        {                                                 \
+            int64x2_t a64 = vreinterpretq_s64_u##LEN(a);  \
+            return (                                      \
+                vgetq_lane_s64(a64, 0) &                  \
+                vgetq_lane_s64(a64, 1)                    \
+            ) == -1;                                      \
+        }
+    NPYV_IMPL_NEON_ANYALL(8)
+    NPYV_IMPL_NEON_ANYALL(16)
+    NPYV_IMPL_NEON_ANYALL(32)
+    NPYV_IMPL_NEON_ANYALL(64)
+    #undef NPYV_IMPL_NEON_ANYALL
+
+    #define NPYV_IMPL_NEON_ANYALL(SFX, USFX)              \
+        NPY_FINLINE bool npyv_any_##SFX(npyv_##SFX a)     \
+        {                                                 \
+            int64x2_t a64 = vreinterpretq_s64_##SFX(a);   \
+            return (                                      \
+                vgetq_lane_s64(a64, 0) |                  \
+                vgetq_lane_s64(a64, 1)                    \
+            ) != 0;                                       \
+        }                                                 \
+        NPY_FINLINE bool npyv_all_##SFX(npyv_##SFX a)     \
+        {                                                 \
+            npyv_##USFX tz = npyv_cmpeq_##SFX(            \
+                a, npyv_zero_##SFX()                      \
+            );                                            \
+            int64x2_t a64 = vreinterpretq_s64_##USFX(tz); \
+            return (                                      \
+                vgetq_lane_s64(a64, 0) |                  \
+                vgetq_lane_s64(a64, 1)                    \
+            ) == 0;                                       \
+        }
+    NPYV_IMPL_NEON_ANYALL(u8,  u8)
+    NPYV_IMPL_NEON_ANYALL(s8,  u8)
+    NPYV_IMPL_NEON_ANYALL(u16, u16)
+    NPYV_IMPL_NEON_ANYALL(s16, u16)
+    NPYV_IMPL_NEON_ANYALL(u32, u32)
+    NPYV_IMPL_NEON_ANYALL(s32, u32)
+    #undef NPYV_IMPL_NEON_ANYALL
+
+    NPY_FINLINE bool npyv_any_f32(npyv_f32 a)
+    {
+        uint32x4_t tz = npyv_cmpeq_f32(a, npyv_zero_f32());
+        int64x2_t a64 = vreinterpretq_s64_u32(tz);
+        return (vgetq_lane_s64(a64, 0) & vgetq_lane_s64(a64, 1)) != -1ll;
+    }
+    NPY_FINLINE bool npyv_all_f32(npyv_f32 a)
+    {
+        uint32x4_t tz = npyv_cmpeq_f32(a, npyv_zero_f32());
+        int64x2_t a64 = vreinterpretq_s64_u32(tz);
+        return (vgetq_lane_s64(a64, 0) | vgetq_lane_s64(a64, 1)) == 0;
+    }
+    NPY_FINLINE bool npyv_any_s64(npyv_s64 a)
+    { return (vgetq_lane_s64(a, 0) | vgetq_lane_s64(a, 1)) != 0; }
+    NPY_FINLINE bool npyv_all_s64(npyv_s64 a)
+    { return vgetq_lane_s64(a, 0) && vgetq_lane_s64(a, 1); }
+    NPY_FINLINE bool npyv_any_u64(npyv_u64 a)
+    { return (vgetq_lane_u64(a, 0) | vgetq_lane_u64(a, 1)) != 0; }
+    NPY_FINLINE bool npyv_all_u64(npyv_u64 a)
+    { return vgetq_lane_u64(a, 0) && vgetq_lane_u64(a, 1); }
+#endif // NPY_SIMD_F64
+
 #endif // _NPY_SIMD_NEON_OPERATORS_H
diff --git a/numpy/core/src/common/simd/simd.h b/numpy/core/src/common/simd/simd.h
index 08b2a7d000f6..8c9b14251aa0 100644
--- a/numpy/core/src/common/simd/simd.h
+++ b/numpy/core/src/common/simd/simd.h
@@ -8,6 +8,10 @@
  * TODO: Add an independent sphinx doc.
 */
 #include "numpy/npy_common.h"
+#ifndef __cplusplus
+    #include 
+#endif
+
 #include "npy_cpu_dispatch.h"
 #include "simd_utils.h"
 
@@ -34,7 +38,7 @@ typedef double     npyv_lanetype_f64;
  * They had bad impact on the generated instructions,
  * sometimes the compiler deal with them without the respect
  * of 32-bit mode which lead to crush due to execute 64-bit
- * instructions and other times generate bad emulated instructions. 
+ * instructions and other times generate bad emulated instructions.
  */
     #undef _mm512_set1_epi64
     #undef _mm256_set1_epi64x
@@ -54,9 +58,9 @@ typedef double     npyv_lanetype_f64;
     #include "sse/sse.h"
 #endif
 
-// TODO: Add support for VSX(2.06) and BE Mode
-#if defined(NPY_HAVE_VSX2) && defined(__LITTLE_ENDIAN__)
-    #include "vsx/vsx.h"
+// TODO: Add support for VSX(2.06) and BE Mode for VSX
+#if defined(NPY_HAVE_VX) || (defined(NPY_HAVE_VSX2) && defined(__LITTLE_ENDIAN__))
+    #include "vec/vec.h"
 #endif
 
 #ifdef NPY_HAVE_NEON
@@ -64,10 +68,23 @@ typedef double     npyv_lanetype_f64;
 #endif
 
 #ifndef NPY_SIMD
+    /// SIMD width in bits or 0 if there's no SIMD extension available.
     #define NPY_SIMD 0
+    /// SIMD width in bytes or 0 if there's no SIMD extension available.
     #define NPY_SIMD_WIDTH 0
+    /// 1 if the enabled SIMD extension supports single-precision otherwise 0.
+    #define NPY_SIMD_F32 0
+    /// 1 if the enabled SIMD extension supports double-precision otherwise 0.
     #define NPY_SIMD_F64 0
+    /// 1 if the enabled SIMD extension supports native FMA otherwise 0.
+    /// note: we still emulate(fast) FMA intrinsics even if they
+    /// aren't supported but they shouldn't be used if the precision is matters.
     #define NPY_SIMD_FMA3 0
+    /// 1 if the enabled SIMD extension is running on big-endian mode otherwise 0.
+    #define NPY_SIMD_BIGENDIAN 0
+    /// 1 if the supported comparison intrinsics(lt, le, gt, ge)
+    /// raises FP invalid exception for quite NaNs.
+    #define NPY_SIMD_CMPSIGNAL 0
 #endif
 
 // enable emulated mask operations for all SIMD extension except for AVX512
diff --git a/numpy/core/src/common/simd/sse/conversion.h b/numpy/core/src/common/simd/sse/conversion.h
index ab7eb490727b..0811bf06ae4a 100644
--- a/numpy/core/src/common/simd/sse/conversion.h
+++ b/numpy/core/src/common/simd/sse/conversion.h
@@ -59,6 +59,30 @@ NPY_FINLINE npyv_u32x2 npyv_expand_u32_u16(npyv_u16 data) {
     return r;
 }
 
+// pack two 16-bit boolean into one 8-bit boolean vector
+NPY_FINLINE npyv_b8 npyv_pack_b8_b16(npyv_b16 a, npyv_b16 b) {
+    return _mm_packs_epi16(a, b);
+}
+
+// pack four 32-bit boolean vectors into one 8-bit boolean vector
+NPY_FINLINE npyv_b8
+npyv_pack_b8_b32(npyv_b32 a, npyv_b32 b, npyv_b32 c, npyv_b32 d) {
+    npyv_b16 ab = _mm_packs_epi32(a, b);
+    npyv_b16 cd = _mm_packs_epi32(c, d);
+    return npyv_pack_b8_b16(ab, cd);
+}
+
+// pack eight 64-bit boolean vectors into one 8-bit boolean vector
+NPY_FINLINE npyv_b8
+npyv_pack_b8_b64(npyv_b64 a, npyv_b64 b, npyv_b64 c, npyv_b64 d,
+                 npyv_b64 e, npyv_b64 f, npyv_b64 g, npyv_b64 h) {
+    npyv_b32 ab = _mm_packs_epi32(a, b);
+    npyv_b32 cd = _mm_packs_epi32(c, d);
+    npyv_b32 ef = _mm_packs_epi32(e, f);
+    npyv_b32 gh = _mm_packs_epi32(g, h);
+    return npyv_pack_b8_b32(ab, cd, ef, gh);
+}
+
 // round to nearest integer (assuming even)
 #define npyv_round_s32_f32 _mm_cvtps_epi32
 NPY_FINLINE npyv_s32 npyv_round_s32_f64(npyv_f64 a, npyv_f64 b)
diff --git a/numpy/core/src/common/simd/sse/math.h b/numpy/core/src/common/simd/sse/math.h
index 5daf7711e416..6b42d8ba3818 100644
--- a/numpy/core/src/common/simd/sse/math.h
+++ b/numpy/core/src/common/simd/sse/math.h
@@ -42,18 +42,30 @@ NPY_FINLINE npyv_f64 npyv_square_f64(npyv_f64 a)
 #define npyv_max_f64 _mm_max_pd
 // Maximum, supports IEEE floating-point arithmetic (IEC 60559),
 // - If one of the two vectors contains NaN, the equivalent element of the other vector is set
-// - Only if both corresponded elements are NaN, NaN is set. 
+// - Only if both corresponded elements are NaN, NaN is set.
 NPY_FINLINE npyv_f32 npyv_maxp_f32(npyv_f32 a, npyv_f32 b)
 {
-    __m128 nn  = _mm_cmpord_ps(b, b);
+    __m128i nn = npyv_notnan_f32(b);
     __m128 max = _mm_max_ps(a, b);
-    return npyv_select_f32(_mm_castps_si128(nn), max, a);
+    return npyv_select_f32(nn, max, a);
 }
 NPY_FINLINE npyv_f64 npyv_maxp_f64(npyv_f64 a, npyv_f64 b)
 {
-    __m128d nn  = _mm_cmpord_pd(b, b);
+    __m128i nn  = npyv_notnan_f64(b);
     __m128d max = _mm_max_pd(a, b);
-    return npyv_select_f64(_mm_castpd_si128(nn), max, a);
+    return npyv_select_f64(nn, max, a);
+}
+NPY_FINLINE npyv_f32 npyv_maxn_f32(npyv_f32 a, npyv_f32 b)
+{
+    __m128i nn = npyv_notnan_f32(a);
+    __m128 max = _mm_max_ps(a, b);
+    return npyv_select_f32(nn, max, a);
+}
+NPY_FINLINE npyv_f64 npyv_maxn_f64(npyv_f64 a, npyv_f64 b)
+{
+    __m128i nn  = npyv_notnan_f64(a);
+    __m128d max = _mm_max_pd(a, b);
+    return npyv_select_f64(nn, max, a);
 }
 // Maximum, integer operations
 #ifdef NPY_HAVE_SSE41
@@ -95,18 +107,30 @@ NPY_FINLINE npyv_s64 npyv_max_s64(npyv_s64 a, npyv_s64 b)
 #define npyv_min_f64 _mm_min_pd
 // Minimum, supports IEEE floating-point arithmetic (IEC 60559),
 // - If one of the two vectors contains NaN, the equivalent element of the other vector is set
-// - Only if both corresponded elements are NaN, NaN is set. 
+// - Only if both corresponded elements are NaN, NaN is set.
 NPY_FINLINE npyv_f32 npyv_minp_f32(npyv_f32 a, npyv_f32 b)
 {
-    __m128 nn  = _mm_cmpord_ps(b, b);
+    __m128i nn = npyv_notnan_f32(b);
     __m128 min = _mm_min_ps(a, b);
-    return npyv_select_f32(_mm_castps_si128(nn), min, a);
+    return npyv_select_f32(nn, min, a);
 }
 NPY_FINLINE npyv_f64 npyv_minp_f64(npyv_f64 a, npyv_f64 b)
 {
-    __m128d nn  = _mm_cmpord_pd(b, b);
+    __m128i nn  = npyv_notnan_f64(b);
     __m128d min = _mm_min_pd(a, b);
-    return npyv_select_f64(_mm_castpd_si128(nn), min, a);
+    return npyv_select_f64(nn, min, a);
+}
+NPY_FINLINE npyv_f32 npyv_minn_f32(npyv_f32 a, npyv_f32 b)
+{
+    __m128i nn = npyv_notnan_f32(a);
+    __m128 min = _mm_min_ps(a, b);
+    return npyv_select_f32(nn, min, a);
+}
+NPY_FINLINE npyv_f64 npyv_minn_f64(npyv_f64 a, npyv_f64 b)
+{
+    __m128i nn  = npyv_notnan_f64(a);
+    __m128d min = _mm_min_pd(a, b);
+    return npyv_select_f64(nn, min, a);
 }
 // Minimum, integer operations
 #ifdef NPY_HAVE_SSE41
@@ -143,6 +167,150 @@ NPY_FINLINE npyv_s64 npyv_min_s64(npyv_s64 a, npyv_s64 b)
     return npyv_select_s64(npyv_cmplt_s64(a, b), a, b);
 }
 
+// reduce min&max for 32&64-bits
+#define NPY_IMPL_SSE_REDUCE_MINMAX(STYPE, INTRIN, VINTRIN)                                     \
+    NPY_FINLINE STYPE##32 npyv_reduce_##INTRIN##32(__m128i a)                                  \
+    {                                                                                          \
+        __m128i v64 =  npyv_##INTRIN##32(a, _mm_shuffle_epi32(a, _MM_SHUFFLE(0, 0, 3, 2)));    \
+        __m128i v32 = npyv_##INTRIN##32(v64, _mm_shuffle_epi32(v64, _MM_SHUFFLE(0, 0, 0, 1))); \
+        return (STYPE##32)_mm_cvtsi128_si32(v32);                                              \
+    }                                                                                          \
+    NPY_FINLINE STYPE##64 npyv_reduce_##INTRIN##64(__m128i a)                                  \
+    {                                                                                          \
+        __m128i v64  = npyv_##INTRIN##64(a, _mm_shuffle_epi32(a, _MM_SHUFFLE(0, 0, 3, 2)));    \
+        return (STYPE##64)npyv_extract0_u64(v64);                                              \
+    }
+
+NPY_IMPL_SSE_REDUCE_MINMAX(npy_uint, min_u, min_epu)
+NPY_IMPL_SSE_REDUCE_MINMAX(npy_int,  min_s, min_epi)
+NPY_IMPL_SSE_REDUCE_MINMAX(npy_uint, max_u, max_epu)
+NPY_IMPL_SSE_REDUCE_MINMAX(npy_int,  max_s, max_epi)
+#undef NPY_IMPL_SSE_REDUCE_MINMAX
+// reduce min&max for ps & pd
+#define NPY_IMPL_SSE_REDUCE_MINMAX(INTRIN, INF, INF64)                                          \
+    NPY_FINLINE float npyv_reduce_##INTRIN##_f32(npyv_f32 a)                                    \
+    {                                                                                           \
+        __m128 v64 =  _mm_##INTRIN##_ps(a, _mm_shuffle_ps(a, a, _MM_SHUFFLE(0, 0, 3, 2)));      \
+        __m128 v32 = _mm_##INTRIN##_ps(v64, _mm_shuffle_ps(v64, v64, _MM_SHUFFLE(0, 0, 0, 1))); \
+        return _mm_cvtss_f32(v32);                                                              \
+    }                                                                                           \
+    NPY_FINLINE double npyv_reduce_##INTRIN##_f64(npyv_f64 a)                                   \
+    {                                                                                           \
+        __m128d v64 = _mm_##INTRIN##_pd(a, _mm_shuffle_pd(a, a, _MM_SHUFFLE(0, 0, 0, 1)));      \
+        return _mm_cvtsd_f64(v64);                                                              \
+    }                                                                                           \
+    NPY_FINLINE float npyv_reduce_##INTRIN##p_f32(npyv_f32 a)                                   \
+    {                                                                                           \
+        npyv_b32 notnan = npyv_notnan_f32(a);                                                   \
+        if (NPY_UNLIKELY(!npyv_any_b32(notnan))) {                                              \
+            return _mm_cvtss_f32(a);                                                            \
+        }                                                                                       \
+        a = npyv_select_f32(notnan, a, npyv_reinterpret_f32_u32(npyv_setall_u32(INF)));         \
+        return npyv_reduce_##INTRIN##_f32(a);                                                   \
+    }                                                                                           \
+    NPY_FINLINE double npyv_reduce_##INTRIN##p_f64(npyv_f64 a)                                  \
+    {                                                                                           \
+        npyv_b64 notnan = npyv_notnan_f64(a);                                                   \
+        if (NPY_UNLIKELY(!npyv_any_b64(notnan))) {                                              \
+            return _mm_cvtsd_f64(a);                                                            \
+        }                                                                                       \
+        a = npyv_select_f64(notnan, a, npyv_reinterpret_f64_u64(npyv_setall_u64(INF64)));       \
+        return npyv_reduce_##INTRIN##_f64(a);                                                   \
+    }                                                                                           \
+    NPY_FINLINE float npyv_reduce_##INTRIN##n_f32(npyv_f32 a)                                   \
+    {                                                                                           \
+        npyv_b32 notnan = npyv_notnan_f32(a);                                                   \
+        if (NPY_UNLIKELY(!npyv_all_b32(notnan))) {                                              \
+            const union { npy_uint32 i; float f;} pnan = {0x7fc00000UL};                        \
+            return pnan.f;                                                                      \
+        }                                                                                       \
+        return npyv_reduce_##INTRIN##_f32(a);                                                   \
+    }                                                                                           \
+    NPY_FINLINE double npyv_reduce_##INTRIN##n_f64(npyv_f64 a)                                  \
+    {                                                                                           \
+        npyv_b64 notnan = npyv_notnan_f64(a);                                                   \
+        if (NPY_UNLIKELY(!npyv_all_b64(notnan))) {                                              \
+            const union { npy_uint64 i; double d;} pnan = {0x7ff8000000000000ull};              \
+            return pnan.d;                                                                      \
+        }                                                                                       \
+        return npyv_reduce_##INTRIN##_f64(a);                                                   \
+    }
+
+NPY_IMPL_SSE_REDUCE_MINMAX(min, 0x7f800000, 0x7ff0000000000000)
+NPY_IMPL_SSE_REDUCE_MINMAX(max, 0xff800000, 0xfff0000000000000)
+#undef NPY_IMPL_SSE_REDUCE_MINMAX
+
+// reduce min&max for 8&16-bits
+#define NPY_IMPL_SSE_REDUCE_MINMAX(STYPE, INTRIN)                                                    \
+    NPY_FINLINE STYPE##16 npyv_reduce_##INTRIN##16(__m128i a)                                        \
+    {                                                                                                \
+        __m128i v64 =  npyv_##INTRIN##16(a, _mm_shuffle_epi32(a, _MM_SHUFFLE(0, 0, 3, 2)));          \
+        __m128i v32 = npyv_##INTRIN##16(v64, _mm_shuffle_epi32(v64, _MM_SHUFFLE(0, 0, 0, 1)));       \
+        __m128i v16 = npyv_##INTRIN##16(v32, _mm_shufflelo_epi16(v32, _MM_SHUFFLE(0, 0, 0, 1)));     \
+        return (STYPE##16)_mm_cvtsi128_si32(v16);                                                    \
+    }                                                                                                \
+    NPY_FINLINE STYPE##8 npyv_reduce_##INTRIN##8(__m128i a)                                          \
+    {                                                                                                \
+        __m128i v64 =  npyv_##INTRIN##8(a, _mm_shuffle_epi32(a, _MM_SHUFFLE(0, 0, 3, 2)));           \
+        __m128i v32 = npyv_##INTRIN##8(v64, _mm_shuffle_epi32(v64, _MM_SHUFFLE(0, 0, 0, 1)));        \
+        __m128i v16 = npyv_##INTRIN##8(v32, _mm_shufflelo_epi16(v32, _MM_SHUFFLE(0, 0, 0, 1)));      \
+        __m128i v8 = npyv_##INTRIN##8(v16, _mm_srli_epi16(v16, 8));                                  \
+        return (STYPE##16)_mm_cvtsi128_si32(v8);                                                     \
+    }
+NPY_IMPL_SSE_REDUCE_MINMAX(npy_uint, min_u)
+NPY_IMPL_SSE_REDUCE_MINMAX(npy_int,  min_s)
+NPY_IMPL_SSE_REDUCE_MINMAX(npy_uint, max_u)
+NPY_IMPL_SSE_REDUCE_MINMAX(npy_int,  max_s)
+#undef NPY_IMPL_SSE_REDUCE_MINMAX
+
+// round to nearest integer even
+NPY_FINLINE npyv_f32 npyv_rint_f32(npyv_f32 a)
+{
+#ifdef NPY_HAVE_SSE41
+    return _mm_round_ps(a, _MM_FROUND_TO_NEAREST_INT);
+#else
+    const __m128 szero = _mm_set1_ps(-0.0f);
+    const __m128i exp_mask = _mm_set1_epi32(0xff000000);
+
+    __m128i nfinite_mask = _mm_slli_epi32(_mm_castps_si128(a), 1);
+            nfinite_mask = _mm_and_si128(nfinite_mask, exp_mask);
+            nfinite_mask = _mm_cmpeq_epi32(nfinite_mask, exp_mask);
+
+    // eliminate nans/inf to avoid invalid fp errors
+    __m128 x = _mm_xor_ps(a, _mm_castsi128_ps(nfinite_mask));
+    __m128i roundi = _mm_cvtps_epi32(x);
+    __m128 round = _mm_cvtepi32_ps(roundi);
+    // respect signed zero
+    round = _mm_or_ps(round, _mm_and_ps(a, szero));
+    // if overflow return a
+    __m128i overflow_mask = _mm_cmpeq_epi32(roundi, _mm_castps_si128(szero));
+    // a if a overflow or nonfinite
+    return npyv_select_f32(_mm_or_si128(nfinite_mask, overflow_mask), a, round);
+#endif
+}
+
+// round to nearest integer even
+NPY_FINLINE npyv_f64 npyv_rint_f64(npyv_f64 a)
+{
+#ifdef NPY_HAVE_SSE41
+    return _mm_round_pd(a, _MM_FROUND_TO_NEAREST_INT);
+#else
+    const __m128d szero = _mm_set1_pd(-0.0);
+    const __m128d two_power_52 = _mm_set1_pd(0x10000000000000);
+    __m128d nan_mask = _mm_cmpunord_pd(a, a);
+    // elminate nans to avoid invalid fp errors within cmpge
+    __m128d abs_x = npyv_abs_f64(_mm_xor_pd(nan_mask, a));
+    // round by add magic number 2^52
+    // assuming that MXCSR register is set to rounding
+    __m128d round = _mm_sub_pd(_mm_add_pd(two_power_52, abs_x), two_power_52);
+    // copysign
+    round = _mm_or_pd(round, _mm_and_pd(a, szero));
+    // a if |a| >= 2^52 or a == NaN
+    __m128d mask = _mm_cmpge_pd(abs_x, two_power_52);
+            mask = _mm_or_pd(mask, nan_mask);
+    return npyv_select_f64(_mm_castpd_si128(mask), a, round);
+#endif
+}
 // ceil
 #ifdef NPY_HAVE_SSE41
     #define npyv_ceil_f32 _mm_ceil_ps
@@ -150,27 +318,48 @@ NPY_FINLINE npyv_s64 npyv_min_s64(npyv_s64 a, npyv_s64 b)
 #else
     NPY_FINLINE npyv_f32 npyv_ceil_f32(npyv_f32 a)
     {
-        const npyv_f32 szero = _mm_set1_ps(-0.0f);
-        const npyv_f32 one = _mm_set1_ps(1.0f);
-        npyv_s32 roundi = _mm_cvttps_epi32(a);
-        npyv_f32 round = _mm_cvtepi32_ps(roundi);
-        npyv_f32 ceil = _mm_add_ps(round, _mm_and_ps(_mm_cmplt_ps(round, a), one));
-        // respect signed zero, e.g. -0.5 -> -0.0
-        npyv_f32 rzero = _mm_or_ps(ceil, _mm_and_ps(a, szero));
+        const __m128 one = _mm_set1_ps(1.0f);
+        const __m128 szero = _mm_set1_ps(-0.0f);
+        const __m128i exp_mask = _mm_set1_epi32(0xff000000);
+
+        __m128i nfinite_mask = _mm_slli_epi32(_mm_castps_si128(a), 1);
+                nfinite_mask = _mm_and_si128(nfinite_mask, exp_mask);
+                nfinite_mask = _mm_cmpeq_epi32(nfinite_mask, exp_mask);
+
+        // eliminate nans/inf to avoid invalid fp errors
+        __m128 x = _mm_xor_ps(a, _mm_castsi128_ps(nfinite_mask));
+        __m128i roundi = _mm_cvtps_epi32(x);
+        __m128 round = _mm_cvtepi32_ps(roundi);
+        __m128 ceil = _mm_add_ps(round, _mm_and_ps(_mm_cmplt_ps(round, x), one));
+        // respect signed zero
+        ceil = _mm_or_ps(ceil, _mm_and_ps(a, szero));
         // if overflow return a
-        return npyv_select_f32(_mm_cmpeq_epi32(roundi, _mm_castps_si128(szero)), a, rzero);
+        __m128i overflow_mask = _mm_cmpeq_epi32(roundi, _mm_castps_si128(szero));
+        // a if a overflow or nonfinite
+        return npyv_select_f32(_mm_or_si128(nfinite_mask, overflow_mask), a, ceil);
     }
     NPY_FINLINE npyv_f64 npyv_ceil_f64(npyv_f64 a)
     {
-        const npyv_f64 szero = _mm_set1_pd(-0.0);
-        const npyv_f64 one = _mm_set1_pd(1.0);
-        const npyv_f64 two_power_52 = _mm_set1_pd(0x10000000000000);
-        npyv_f64 sign_two52 = _mm_or_pd(two_power_52, _mm_and_pd(a, szero));
+        const __m128d one = _mm_set1_pd(1.0);
+        const __m128d szero = _mm_set1_pd(-0.0);
+        const __m128d two_power_52 = _mm_set1_pd(0x10000000000000);
+        __m128d nan_mask = _mm_cmpunord_pd(a, a);
+        // elminate nans to avoid invalid fp errors within cmpge
+        __m128d x = _mm_xor_pd(nan_mask, a);
+        __m128d abs_x = npyv_abs_f64(x);
+        __m128d sign_x = _mm_and_pd(x, szero);
         // round by add magic number 2^52
-        npyv_f64 round = _mm_sub_pd(_mm_add_pd(a, sign_two52), sign_two52);
-        npyv_f64 ceil = _mm_add_pd(round, _mm_and_pd(_mm_cmplt_pd(round, a), one));
-        // respect signed zero, e.g. -0.5 -> -0.0
-        return _mm_or_pd(ceil, _mm_and_pd(a, szero));
+        // assuming that MXCSR register is set to rounding
+        __m128d round = _mm_sub_pd(_mm_add_pd(two_power_52, abs_x), two_power_52);
+        // copysign
+        round = _mm_or_pd(round, sign_x);
+        __m128d ceil = _mm_add_pd(round, _mm_and_pd(_mm_cmplt_pd(round, x), one));
+        // respects sign of 0.0
+        ceil = _mm_or_pd(ceil, sign_x);
+        // a if |a| >= 2^52 or a == NaN
+        __m128d mask = _mm_cmpge_pd(abs_x, two_power_52);
+                mask = _mm_or_pd(mask, nan_mask);
+        return npyv_select_f64(_mm_castpd_si128(mask), a, ceil);
     }
 #endif
 
@@ -181,25 +370,94 @@ NPY_FINLINE npyv_s64 npyv_min_s64(npyv_s64 a, npyv_s64 b)
 #else
     NPY_FINLINE npyv_f32 npyv_trunc_f32(npyv_f32 a)
     {
-        const npyv_f32 szero = _mm_set1_ps(-0.0f);
-        npyv_s32 roundi = _mm_cvttps_epi32(a);
-        npyv_f32 trunc = _mm_cvtepi32_ps(roundi);
+        const __m128 szero = _mm_set1_ps(-0.0f);
+        const __m128i exp_mask = _mm_set1_epi32(0xff000000);
+
+        __m128i nfinite_mask = _mm_slli_epi32(_mm_castps_si128(a), 1);
+                nfinite_mask = _mm_and_si128(nfinite_mask, exp_mask);
+                nfinite_mask = _mm_cmpeq_epi32(nfinite_mask, exp_mask);
+
+        // elminate nans/inf to avoid invalid fp errors
+        __m128 x = _mm_xor_ps(a, _mm_castsi128_ps(nfinite_mask));
+        __m128i trunci = _mm_cvttps_epi32(x);
+        __m128 trunc = _mm_cvtepi32_ps(trunci);
         // respect signed zero, e.g. -0.5 -> -0.0
-        npyv_f32 rzero = _mm_or_ps(trunc, _mm_and_ps(a, szero));
+        trunc = _mm_or_ps(trunc, _mm_and_ps(a, szero));
         // if overflow return a
-        return npyv_select_f32(_mm_cmpeq_epi32(roundi, _mm_castps_si128(szero)), a, rzero);
+        __m128i overflow_mask = _mm_cmpeq_epi32(trunci, _mm_castps_si128(szero));
+        // a if a overflow or nonfinite
+        return npyv_select_f32(_mm_or_si128(nfinite_mask, overflow_mask), a, trunc);
     }
     NPY_FINLINE npyv_f64 npyv_trunc_f64(npyv_f64 a)
     {
-        const npyv_f64 szero = _mm_set1_pd(-0.0);
-        const npyv_f64 one = _mm_set1_pd(1.0);
-        const npyv_f64 two_power_52 = _mm_set1_pd(0x10000000000000);
-        npyv_f64 abs_a = npyv_abs_f64(a);
+        const __m128d one = _mm_set1_pd(1.0);
+        const __m128d szero = _mm_set1_pd(-0.0);
+        const __m128d two_power_52 = _mm_set1_pd(0x10000000000000);
+        __m128d nan_mask = _mm_cmpunord_pd(a, a);
+        // elminate nans to avoid invalid fp errors within cmpge
+        __m128d abs_x = npyv_abs_f64(_mm_xor_pd(nan_mask, a));
         // round by add magic number 2^52
-        npyv_f64 abs_round = _mm_sub_pd(_mm_add_pd(abs_a, two_power_52), two_power_52);
-        npyv_f64 subtrahend = _mm_and_pd(_mm_cmpgt_pd(abs_round, abs_a), one);
-        return _mm_or_pd(_mm_sub_pd(abs_round, subtrahend), _mm_and_pd(a, szero));
+        // assuming that MXCSR register is set to rounding
+        __m128d abs_round = _mm_sub_pd(_mm_add_pd(two_power_52, abs_x), two_power_52);
+        __m128d subtrahend = _mm_and_pd(_mm_cmpgt_pd(abs_round, abs_x), one);
+        __m128d trunc = _mm_sub_pd(abs_round, subtrahend);
+        // copysign
+        trunc = _mm_or_pd(trunc, _mm_and_pd(a, szero));
+        // a if |a| >= 2^52 or a == NaN
+        __m128d mask = _mm_cmpge_pd(abs_x, two_power_52);
+               mask = _mm_or_pd(mask, nan_mask);
+        return npyv_select_f64(_mm_castpd_si128(mask), a, trunc);
     }
 #endif
 
+// floor
+#ifdef NPY_HAVE_SSE41
+    #define npyv_floor_f32 _mm_floor_ps
+    #define npyv_floor_f64 _mm_floor_pd
+#else
+    NPY_FINLINE npyv_f32 npyv_floor_f32(npyv_f32 a)
+    {
+        const __m128 one = _mm_set1_ps(1.0f);
+        const __m128 szero = _mm_set1_ps(-0.0f);
+        const __m128i exp_mask = _mm_set1_epi32(0xff000000);
+
+        __m128i nfinite_mask = _mm_slli_epi32(_mm_castps_si128(a), 1);
+                nfinite_mask = _mm_and_si128(nfinite_mask, exp_mask);
+                nfinite_mask = _mm_cmpeq_epi32(nfinite_mask, exp_mask);
+
+        // eliminate nans/inf to avoid invalid fp errors
+        __m128 x = _mm_xor_ps(a, _mm_castsi128_ps(nfinite_mask));
+        __m128i roundi = _mm_cvtps_epi32(x);
+        __m128 round = _mm_cvtepi32_ps(roundi);
+        __m128 floor = _mm_sub_ps(round, _mm_and_ps(_mm_cmpgt_ps(round, x), one));
+        // respect signed zero
+        floor = _mm_or_ps(floor, _mm_and_ps(a, szero));
+        // if overflow return a
+        __m128i overflow_mask = _mm_cmpeq_epi32(roundi, _mm_castps_si128(szero));
+        // a if a overflow or nonfinite
+        return npyv_select_f32(_mm_or_si128(nfinite_mask, overflow_mask), a, floor);
+    }
+    NPY_FINLINE npyv_f64 npyv_floor_f64(npyv_f64 a)
+    {
+        const __m128d one = _mm_set1_pd(1.0f);
+        const __m128d szero = _mm_set1_pd(-0.0f);
+        const __m128d two_power_52 = _mm_set1_pd(0x10000000000000);
+        __m128d nan_mask = _mm_cmpunord_pd(a, a);
+        // elminate nans to avoid invalid fp errors within cmpge
+        __m128d x = _mm_xor_pd(nan_mask, a);
+        __m128d abs_x = npyv_abs_f64(x);
+        __m128d sign_x = _mm_and_pd(x, szero);
+        // round by add magic number 2^52
+        // assuming that MXCSR register is set to rounding
+        __m128d round = _mm_sub_pd(_mm_add_pd(two_power_52, abs_x), two_power_52);
+        // copysign
+        round = _mm_or_pd(round, sign_x);
+        __m128d floor = _mm_sub_pd(round, _mm_and_pd(_mm_cmpgt_pd(round, x), one));
+        // a if |a| >= 2^52 or a == NaN
+        __m128d mask = _mm_cmpge_pd(abs_x, two_power_52);
+               mask = _mm_or_pd(mask, nan_mask);
+        return npyv_select_f64(_mm_castpd_si128(mask), a, floor);
+    }
+#endif // NPY_HAVE_SSE41
+
 #endif // _NPY_SIMD_SSE_MATH_H
diff --git a/numpy/core/src/common/simd/sse/memory.h b/numpy/core/src/common/simd/sse/memory.h
index 1074c3b02efe..3ff64848d281 100644
--- a/numpy/core/src/common/simd/sse/memory.h
+++ b/numpy/core/src/common/simd/sse/memory.h
@@ -495,4 +495,45 @@ NPYV_IMPL_SSE_REST_PARTIAL_TYPES(f32, s32)
 NPYV_IMPL_SSE_REST_PARTIAL_TYPES(u64, s64)
 NPYV_IMPL_SSE_REST_PARTIAL_TYPES(f64, s64)
 
+/*********************************
+ * Lookup table
+ *********************************/
+// uses vector as indexes into a table
+// that contains 32 elements of float32.
+NPY_FINLINE npyv_f32 npyv_lut32_f32(const float *table, npyv_u32 idx)
+{
+    const int i0 = _mm_cvtsi128_si32(idx);
+#ifdef NPY_HAVE_SSE41
+    const int i1 = _mm_extract_epi32(idx, 1);
+    const int i2 = _mm_extract_epi32(idx, 2);
+    const int i3 = _mm_extract_epi32(idx, 3);
+#else
+    const int i1 = _mm_extract_epi16(idx, 2);
+    const int i2 = _mm_extract_epi16(idx, 4);
+    const int i3 = _mm_extract_epi16(idx, 6);
+#endif
+    return npyv_set_f32(table[i0], table[i1], table[i2], table[i3]);
+}
+NPY_FINLINE npyv_u32 npyv_lut32_u32(const npy_uint32 *table, npyv_u32 idx)
+{ return npyv_reinterpret_u32_f32(npyv_lut32_f32((const float*)table, idx)); }
+NPY_FINLINE npyv_s32 npyv_lut32_s32(const npy_int32 *table, npyv_u32 idx)
+{ return npyv_reinterpret_s32_f32(npyv_lut32_f32((const float*)table, idx)); }
+
+// uses vector as indexes into a table
+// that contains 16 elements of float64.
+NPY_FINLINE npyv_f64 npyv_lut16_f64(const double *table, npyv_u64 idx)
+{
+    const int i0 = _mm_cvtsi128_si32(idx);
+#ifdef NPY_HAVE_SSE41
+    const int i1 = _mm_extract_epi32(idx, 2);
+#else
+    const int i1 = _mm_extract_epi16(idx, 4);
+#endif
+    return npyv_set_f64(table[i0], table[i1]);
+}
+NPY_FINLINE npyv_u64 npyv_lut16_u64(const npy_uint64 *table, npyv_u64 idx)
+{ return npyv_reinterpret_u64_f64(npyv_lut16_f64((const double*)table, idx)); }
+NPY_FINLINE npyv_s64 npyv_lut16_s64(const npy_int64 *table, npyv_u64 idx)
+{ return npyv_reinterpret_s64_f64(npyv_lut16_f64((const double*)table, idx)); }
+
 #endif // _NPY_SIMD_SSE_MEMORY_H
diff --git a/numpy/core/src/common/simd/sse/misc.h b/numpy/core/src/common/simd/sse/misc.h
index 7d13fbf555c5..b01ff172297d 100644
--- a/numpy/core/src/common/simd/sse/misc.h
+++ b/numpy/core/src/common/simd/sse/misc.h
@@ -129,6 +129,18 @@ NPY_FINLINE __m128d npyv__setr_pd(double i0, double i1)
 #define npyv_select_u64 npyv_select_u8
 #define npyv_select_s64 npyv_select_u8
 
+// extract the first vector's lane
+#define npyv_extract0_u8(A) ((npy_uint8)_mm_cvtsi128_si32(A))
+#define npyv_extract0_s8(A) ((npy_int8)_mm_cvtsi128_si32(A))
+#define npyv_extract0_u16(A) ((npy_uint16)_mm_cvtsi128_si32(A))
+#define npyv_extract0_s16(A) ((npy_int16)_mm_cvtsi128_si32(A))
+#define npyv_extract0_u32(A) ((npy_uint32)_mm_cvtsi128_si32(A))
+#define npyv_extract0_s32(A) ((npy_int32)_mm_cvtsi128_si32(A))
+#define npyv_extract0_u64(A) ((npy_uint64)npyv128_cvtsi128_si64(A))
+#define npyv_extract0_s64(A) ((npy_int64)npyv128_cvtsi128_si64(A))
+#define npyv_extract0_f32 _mm_cvtss_f32
+#define npyv_extract0_f64 _mm_cvtsd_f64
+
 // Reinterpret
 #define npyv_reinterpret_u8_u8(X)  X
 #define npyv_reinterpret_u8_s8(X)  X
diff --git a/numpy/core/src/common/simd/sse/operators.h b/numpy/core/src/common/simd/sse/operators.h
index 51c84fb4e9d9..59182679e6db 100644
--- a/numpy/core/src/common/simd/sse/operators.h
+++ b/numpy/core/src/common/simd/sse/operators.h
@@ -115,6 +115,12 @@ NPY_FINLINE __m128i npyv_shr_s64(__m128i a, int c)
 #define npyv_not_b32 npyv_not_u8
 #define npyv_not_b64 npyv_not_u8
 
+// ANDC, ORC and XNOR
+#define npyv_andc_u8(A, B) _mm_andnot_si128(B, A)
+#define npyv_andc_b8(A, B) _mm_andnot_si128(B, A)
+#define npyv_orc_b8(A, B) npyv_or_b8(npyv_not_b8(B), A)
+#define npyv_xnor_b8 _mm_cmpeq_epi8
+
 /***************************
  * Comparison
  ***************************/
@@ -277,4 +283,60 @@ NPY_FINLINE npyv_b32 npyv_notnan_f32(npyv_f32 a)
 NPY_FINLINE npyv_b64 npyv_notnan_f64(npyv_f64 a)
 { return _mm_castpd_si128(_mm_cmpord_pd(a, a)); }
 
+// Test cross all vector lanes
+// any: returns true if any of the elements is not equal to zero
+// all: returns true if all elements are not equal to zero
+#define NPYV_IMPL_SSE_ANYALL(SFX)                 \
+    NPY_FINLINE bool npyv_any_##SFX(npyv_##SFX a) \
+    { return _mm_movemask_epi8(a) != 0; }         \
+    NPY_FINLINE bool npyv_all_##SFX(npyv_##SFX a) \
+    { return _mm_movemask_epi8(a) == 0xffff; }
+NPYV_IMPL_SSE_ANYALL(b8)
+NPYV_IMPL_SSE_ANYALL(b16)
+NPYV_IMPL_SSE_ANYALL(b32)
+NPYV_IMPL_SSE_ANYALL(b64)
+#undef NPYV_IMPL_SSE_ANYALL
+
+#define NPYV_IMPL_SSE_ANYALL(SFX, MSFX, TSFX, MASK) \
+    NPY_FINLINE bool npyv_any_##SFX(npyv_##SFX a)   \
+    {                                               \
+        return _mm_movemask_##MSFX(                 \
+            _mm_cmpeq_##TSFX(a, npyv_zero_##SFX())  \
+        ) != MASK;                                  \
+    }                                               \
+    NPY_FINLINE bool npyv_all_##SFX(npyv_##SFX a)   \
+    {                                               \
+        return _mm_movemask_##MSFX(                 \
+            _mm_cmpeq_##TSFX(a, npyv_zero_##SFX())  \
+        ) == 0;                                     \
+    }
+NPYV_IMPL_SSE_ANYALL(u8,  epi8, epi8, 0xffff)
+NPYV_IMPL_SSE_ANYALL(s8,  epi8, epi8, 0xffff)
+NPYV_IMPL_SSE_ANYALL(u16, epi8, epi16, 0xffff)
+NPYV_IMPL_SSE_ANYALL(s16, epi8, epi16, 0xffff)
+NPYV_IMPL_SSE_ANYALL(u32, epi8, epi32, 0xffff)
+NPYV_IMPL_SSE_ANYALL(s32, epi8, epi32, 0xffff)
+#ifdef NPY_HAVE_SSE41
+    NPYV_IMPL_SSE_ANYALL(u64, epi8, epi64, 0xffff)
+    NPYV_IMPL_SSE_ANYALL(s64, epi8, epi64, 0xffff)
+#else
+    NPY_FINLINE bool npyv_any_u64(npyv_u64 a)
+    {
+        return _mm_movemask_epi8(
+            _mm_cmpeq_epi32(a, npyv_zero_u64())
+        ) != 0xffff;
+    }
+    NPY_FINLINE bool npyv_all_u64(npyv_u64 a)
+    {
+        a = _mm_cmpeq_epi32(a, npyv_zero_u64());
+        a = _mm_and_si128(a, _mm_shuffle_epi32(a, _MM_SHUFFLE(2, 3, 0, 1)));
+        return _mm_movemask_epi8(a) == 0;
+    }
+    #define npyv_any_s64 npyv_any_u64
+    #define npyv_all_s64 npyv_all_u64
+#endif
+NPYV_IMPL_SSE_ANYALL(f32, ps, ps, 0xf)
+NPYV_IMPL_SSE_ANYALL(f64, pd, pd, 0x3)
+#undef NPYV_IMPL_SSE_ANYALL
+
 #endif // _NPY_SIMD_SSE_OPERATORS_H
diff --git a/numpy/core/src/common/simd/sse/sse.h b/numpy/core/src/common/simd/sse/sse.h
index 0bb404312867..0c6b8cdbab2e 100644
--- a/numpy/core/src/common/simd/sse/sse.h
+++ b/numpy/core/src/common/simd/sse/sse.h
@@ -4,12 +4,16 @@
 
 #define NPY_SIMD 128
 #define NPY_SIMD_WIDTH 16
+#define NPY_SIMD_F32 1
 #define NPY_SIMD_F64 1
 #if defined(NPY_HAVE_FMA3) || defined(NPY_HAVE_FMA4)
     #define NPY_SIMD_FMA3 1  // native support
 #else
     #define NPY_SIMD_FMA3 0  // fast emulated
 #endif
+#define NPY_SIMD_BIGENDIAN 0
+#define NPY_SIMD_CMPSIGNAL 1
+
 typedef __m128i npyv_u8;
 typedef __m128i npyv_s8;
 typedef __m128i npyv_u16;
diff --git a/numpy/core/src/common/simd/vsx/arithmetic.h b/numpy/core/src/common/simd/vec/arithmetic.h
similarity index 62%
rename from numpy/core/src/common/simd/vsx/arithmetic.h
rename to numpy/core/src/common/simd/vec/arithmetic.h
index eaca536201fb..a2e9d07eb6ab 100644
--- a/numpy/core/src/common/simd/vsx/arithmetic.h
+++ b/numpy/core/src/common/simd/vec/arithmetic.h
@@ -2,8 +2,8 @@
     #error "Not a standalone header"
 #endif
 
-#ifndef _NPY_SIMD_VSX_ARITHMETIC_H
-#define _NPY_SIMD_VSX_ARITHMETIC_H
+#ifndef _NPY_SIMD_VEC_ARITHMETIC_H
+#define _NPY_SIMD_VEC_ARITHMETIC_H
 
 /***************************
  * Addition
@@ -17,15 +17,32 @@
 #define npyv_add_s32 vec_add
 #define npyv_add_u64 vec_add
 #define npyv_add_s64 vec_add
+#if NPY_SIMD_F32
 #define npyv_add_f32 vec_add
+#endif
 #define npyv_add_f64 vec_add
 
 // saturated
-#define npyv_adds_u8  vec_adds
-#define npyv_adds_s8  vec_adds
-#define npyv_adds_u16 vec_adds
-#define npyv_adds_s16 vec_adds
+#ifdef NPY_HAVE_VX
+    #define NPYV_IMPL_VX_ADDS(SFX, PSFX) \
+        NPY_FINLINE npyv_##SFX npyv_adds_##SFX(npyv_##SFX a, npyv_##SFX b)\
+        {                                                                 \
+            return vec_pack##PSFX(                                        \
+                vec_add(vec_unpackh(a), vec_unpackh(b)),                  \
+                vec_add(vec_unpackl(a), vec_unpackl(b))                   \
+            );                                                            \
+        }
 
+    NPYV_IMPL_VX_ADDS(u8, su)
+    NPYV_IMPL_VX_ADDS(s8, s)
+    NPYV_IMPL_VX_ADDS(u16, su)
+    NPYV_IMPL_VX_ADDS(s16, s)
+#else // VSX
+    #define npyv_adds_u8  vec_adds
+    #define npyv_adds_s8  vec_adds
+    #define npyv_adds_u16 vec_adds
+    #define npyv_adds_s16 vec_adds
+#endif
 /***************************
  * Subtraction
  ***************************/
@@ -38,21 +55,39 @@
 #define npyv_sub_s32 vec_sub
 #define npyv_sub_u64 vec_sub
 #define npyv_sub_s64 vec_sub
+#if NPY_SIMD_F32
 #define npyv_sub_f32 vec_sub
+#endif
 #define npyv_sub_f64 vec_sub
 
 // saturated
-#define npyv_subs_u8  vec_subs
-#define npyv_subs_s8  vec_subs
-#define npyv_subs_u16 vec_subs
-#define npyv_subs_s16 vec_subs
+#ifdef NPY_HAVE_VX
+    #define NPYV_IMPL_VX_SUBS(SFX, PSFX)                                  \
+        NPY_FINLINE npyv_##SFX npyv_subs_##SFX(npyv_##SFX a, npyv_##SFX b)\
+        {                                                                 \
+            return vec_pack##PSFX(                                        \
+                vec_sub(vec_unpackh(a), vec_unpackh(b)),                  \
+                vec_sub(vec_unpackl(a), vec_unpackl(b))                   \
+            );                                                            \
+        }
+
+    NPYV_IMPL_VX_SUBS(u8, su)
+    NPYV_IMPL_VX_SUBS(s8, s)
+    NPYV_IMPL_VX_SUBS(u16, su)
+    NPYV_IMPL_VX_SUBS(s16, s)
+#else // VSX
+    #define npyv_subs_u8  vec_subs
+    #define npyv_subs_s8  vec_subs
+    #define npyv_subs_u16 vec_subs
+    #define npyv_subs_s16 vec_subs
+#endif
 
 /***************************
  * Multiplication
  ***************************/
 // non-saturated
 // up to GCC 6 vec_mul only supports precisions and llong
-#if defined(__GNUC__) && __GNUC__ < 7
+#if defined(NPY_HAVE_VSX) && defined(__GNUC__) && __GNUC__ < 7
     #define NPYV_IMPL_VSX_MUL(T_VEC, SFX, ...)              \
         NPY_FINLINE T_VEC npyv_mul_##SFX(T_VEC a, T_VEC b)  \
         {                                                   \
@@ -91,19 +126,21 @@
     #define npyv_mul_u32 vec_mul
     #define npyv_mul_s32 vec_mul
 #endif
+#if NPY_SIMD_F32
 #define npyv_mul_f32 vec_mul
+#endif
 #define npyv_mul_f64 vec_mul
 
 /***************************
  * Integer Division
  ***************************/
-/***
- * TODO: Add support for VSX4(Power10)
- */
 // See simd/intdiv.h for more clarification
 // divide each unsigned 8-bit element by a precomputed divisor
 NPY_FINLINE npyv_u8 npyv_divc_u8(npyv_u8 a, const npyv_u8x3 divisor)
 {
+#ifdef NPY_HAVE_VX
+    npyv_u8  mulhi    = vec_mulh(a, divisor.val[0]);
+#else // VSX
     const npyv_u8 mergeo_perm = {
         1, 17, 3, 19, 5, 21, 7, 23, 9, 25, 11, 27, 13, 29, 15, 31
     };
@@ -111,6 +148,7 @@ NPY_FINLINE npyv_u8 npyv_divc_u8(npyv_u8 a, const npyv_u8x3 divisor)
     npyv_u16 mul_even = vec_mule(a, divisor.val[0]);
     npyv_u16 mul_odd  = vec_mulo(a, divisor.val[0]);
     npyv_u8  mulhi    = (npyv_u8)vec_perm(mul_even, mul_odd, mergeo_perm);
+#endif
     // floor(a/d)     = (mulhi + ((a-mulhi) >> sh1)) >> sh2
     npyv_u8 q         = vec_sub(a, mulhi);
             q         = vec_sr(q, divisor.val[1]);
@@ -121,6 +159,9 @@ NPY_FINLINE npyv_u8 npyv_divc_u8(npyv_u8 a, const npyv_u8x3 divisor)
 // divide each signed 8-bit element by a precomputed divisor
 NPY_FINLINE npyv_s8 npyv_divc_s8(npyv_s8 a, const npyv_s8x3 divisor)
 {
+#ifdef NPY_HAVE_VX
+    npyv_s8  mulhi    = vec_mulh(a, divisor.val[0]);
+#else
     const npyv_u8 mergeo_perm = {
         1, 17, 3, 19, 5, 21, 7, 23, 9, 25, 11, 27, 13, 29, 15, 31
     };
@@ -128,16 +169,20 @@ NPY_FINLINE npyv_s8 npyv_divc_s8(npyv_s8 a, const npyv_s8x3 divisor)
     npyv_s16 mul_even = vec_mule(a, divisor.val[0]);
     npyv_s16 mul_odd  = vec_mulo(a, divisor.val[0]);
     npyv_s8  mulhi    = (npyv_s8)vec_perm(mul_even, mul_odd, mergeo_perm);
+#endif
     // q              = ((a + mulhi) >> sh1) - XSIGN(a)
     // trunc(a/d)     = (q ^ dsign) - dsign
-    npyv_s8 q         = vec_sra(vec_add(a, mulhi), (npyv_u8)divisor.val[1]);
-            q         = vec_sub(q, vec_sra(a, npyv_setall_u8(7)));
+    npyv_s8 q         = vec_sra_s8(vec_add(a, mulhi), (npyv_u8)divisor.val[1]);
+            q         = vec_sub(q, vec_sra_s8(a, npyv_setall_u8(7)));
             q         = vec_sub(vec_xor(q, divisor.val[2]), divisor.val[2]);
     return  q;
 }
 // divide each unsigned 16-bit element by a precomputed divisor
 NPY_FINLINE npyv_u16 npyv_divc_u16(npyv_u16 a, const npyv_u16x3 divisor)
 {
+#ifdef NPY_HAVE_VX
+    npyv_u16 mulhi    = vec_mulh(a, divisor.val[0]);
+#else // VSX
     const npyv_u8 mergeo_perm = {
         2, 3, 18, 19, 6, 7, 22, 23, 10, 11, 26, 27, 14, 15, 30, 31
     };
@@ -145,6 +190,7 @@ NPY_FINLINE npyv_u16 npyv_divc_u16(npyv_u16 a, const npyv_u16x3 divisor)
     npyv_u32 mul_even = vec_mule(a, divisor.val[0]);
     npyv_u32 mul_odd  = vec_mulo(a, divisor.val[0]);
     npyv_u16 mulhi    = (npyv_u16)vec_perm(mul_even, mul_odd, mergeo_perm);
+#endif
     // floor(a/d)     = (mulhi + ((a-mulhi) >> sh1)) >> sh2
     npyv_u16 q        = vec_sub(a, mulhi);
              q        = vec_sr(q, divisor.val[1]);
@@ -155,6 +201,9 @@ NPY_FINLINE npyv_u16 npyv_divc_u16(npyv_u16 a, const npyv_u16x3 divisor)
 // divide each signed 16-bit element by a precomputed divisor (round towards zero)
 NPY_FINLINE npyv_s16 npyv_divc_s16(npyv_s16 a, const npyv_s16x3 divisor)
 {
+#ifdef NPY_HAVE_VX
+    npyv_s16 mulhi    = vec_mulh(a, divisor.val[0]);
+#else // VSX
     const npyv_u8 mergeo_perm = {
         2, 3, 18, 19, 6, 7, 22, 23, 10, 11, 26, 27, 14, 15, 30, 31
     };
@@ -162,28 +211,34 @@ NPY_FINLINE npyv_s16 npyv_divc_s16(npyv_s16 a, const npyv_s16x3 divisor)
     npyv_s32 mul_even = vec_mule(a, divisor.val[0]);
     npyv_s32 mul_odd  = vec_mulo(a, divisor.val[0]);
     npyv_s16 mulhi    = (npyv_s16)vec_perm(mul_even, mul_odd, mergeo_perm);
+#endif
     // q              = ((a + mulhi) >> sh1) - XSIGN(a)
     // trunc(a/d)     = (q ^ dsign) - dsign
-    npyv_s16 q        = vec_sra(vec_add(a, mulhi), (npyv_u16)divisor.val[1]);
-             q        = vec_sub(q, vec_sra(a, npyv_setall_u16(15)));
+    npyv_s16 q        = vec_sra_s16(vec_add(a, mulhi), (npyv_u16)divisor.val[1]);
+             q        = vec_sub(q, vec_sra_s16(a, npyv_setall_u16(15)));
              q        = vec_sub(vec_xor(q, divisor.val[2]), divisor.val[2]);
     return   q;
 }
 // divide each unsigned 32-bit element by a precomputed divisor
 NPY_FINLINE npyv_u32 npyv_divc_u32(npyv_u32 a, const npyv_u32x3 divisor)
 {
-#if defined(__GNUC__) && __GNUC__ < 8
-    // Doubleword integer wide multiplication supported by GCC 8+
-    npyv_u64 mul_even, mul_odd;
-    __asm__ ("vmulouw %0,%1,%2" : "=v" (mul_even) : "v" (a), "v" (divisor.val[0]));
-    __asm__ ("vmuleuw %0,%1,%2" : "=v" (mul_odd)  : "v" (a), "v" (divisor.val[0]));
-#else
-    // Doubleword integer wide multiplication supported by GCC 8+
-    npyv_u64 mul_even = vec_mule(a, divisor.val[0]);
-    npyv_u64 mul_odd  = vec_mulo(a, divisor.val[0]);
-#endif
+#if defined(NPY_HAVE_VSX4) || defined(NPY_HAVE_VX)
+    // high part of unsigned multiplication
+    npyv_u32 mulhi    = vec_mulh(a, divisor.val[0]);
+#else // VSX
+    #if defined(__GNUC__) && __GNUC__ < 8
+        // Doubleword integer wide multiplication supported by GCC 8+
+        npyv_u64 mul_even, mul_odd;
+        __asm__ ("vmulouw %0,%1,%2" : "=v" (mul_even) : "v" (a), "v" (divisor.val[0]));
+        __asm__ ("vmuleuw %0,%1,%2" : "=v" (mul_odd)  : "v" (a), "v" (divisor.val[0]));
+    #else
+        // Doubleword integer wide multiplication supported by GCC 8+
+        npyv_u64 mul_even = vec_mule(a, divisor.val[0]);
+        npyv_u64 mul_odd  = vec_mulo(a, divisor.val[0]);
+    #endif
     // high part of unsigned multiplication
     npyv_u32 mulhi    = vec_mergeo((npyv_u32)mul_even, (npyv_u32)mul_odd);
+#endif
     // floor(x/d)     = (((a-mulhi) >> sh1) + mulhi) >> sh2
     npyv_u32 q        = vec_sub(a, mulhi);
              q        = vec_sr(q, divisor.val[1]);
@@ -194,30 +249,39 @@ NPY_FINLINE npyv_u32 npyv_divc_u32(npyv_u32 a, const npyv_u32x3 divisor)
 // divide each signed 32-bit element by a precomputed divisor (round towards zero)
 NPY_FINLINE npyv_s32 npyv_divc_s32(npyv_s32 a, const npyv_s32x3 divisor)
 {
-#if defined(__GNUC__) && __GNUC__ < 8
-    // Doubleword integer wide multiplication supported by GCC8+
-    npyv_s64 mul_even, mul_odd;
-    __asm__ ("vmulosw %0,%1,%2" : "=v" (mul_even) : "v" (a), "v" (divisor.val[0]));
-    __asm__ ("vmulesw %0,%1,%2" : "=v" (mul_odd)  : "v" (a), "v" (divisor.val[0]));
+#if defined(NPY_HAVE_VSX4) || defined(NPY_HAVE_VX)
+    // high part of signed multiplication
+    npyv_s32 mulhi    = vec_mulh(a, divisor.val[0]);
 #else
-    // Doubleword integer wide multiplication supported by GCC8+
-    npyv_s64 mul_even = vec_mule(a, divisor.val[0]);
-    npyv_s64 mul_odd  = vec_mulo(a, divisor.val[0]);
-#endif
+    #if defined(__GNUC__) && __GNUC__ < 8
+        // Doubleword integer wide multiplication supported by GCC8+
+        npyv_s64 mul_even, mul_odd;
+        __asm__ ("vmulosw %0,%1,%2" : "=v" (mul_even) : "v" (a), "v" (divisor.val[0]));
+        __asm__ ("vmulesw %0,%1,%2" : "=v" (mul_odd)  : "v" (a), "v" (divisor.val[0]));
+    #else
+        // Doubleword integer wide multiplication supported by GCC8+
+        npyv_s64 mul_even = vec_mule(a, divisor.val[0]);
+        npyv_s64 mul_odd  = vec_mulo(a, divisor.val[0]);
+    #endif
     // high part of signed multiplication
     npyv_s32 mulhi    = vec_mergeo((npyv_s32)mul_even, (npyv_s32)mul_odd);
+#endif
     // q              = ((a + mulhi) >> sh1) - XSIGN(a)
     // trunc(a/d)     = (q ^ dsign) - dsign
-    npyv_s32 q        = vec_sra(vec_add(a, mulhi), (npyv_u32)divisor.val[1]);
-             q        = vec_sub(q, vec_sra(a, npyv_setall_u32(31)));
+    npyv_s32 q        = vec_sra_s32(vec_add(a, mulhi), (npyv_u32)divisor.val[1]);
+             q        = vec_sub(q, vec_sra_s32(a, npyv_setall_u32(31)));
              q        = vec_sub(vec_xor(q, divisor.val[2]), divisor.val[2]);
     return   q;
 }
 // divide each unsigned 64-bit element by a precomputed divisor
 NPY_FINLINE npyv_u64 npyv_divc_u64(npyv_u64 a, const npyv_u64x3 divisor)
 {
+#if defined(NPY_HAVE_VSX4)
+    return vec_div(a, divisor.val[0]);
+#else
     const npy_uint64 d = vec_extract(divisor.val[0], 0);
     return npyv_set_u64(vec_extract(a, 0) / d, vec_extract(a, 1) / d);
+#endif
 }
 // divide each signed 64-bit element by a precomputed divisor (round towards zero)
 NPY_FINLINE npyv_s64 npyv_divc_s64(npyv_s64 a, const npyv_s64x3 divisor)
@@ -229,45 +293,67 @@ NPY_FINLINE npyv_s64 npyv_divc_s64(npyv_s64 a, const npyv_s64x3 divisor)
 /***************************
  * Division
  ***************************/
-#define npyv_div_f32 vec_div
+#if NPY_SIMD_F32
+    #define npyv_div_f32 vec_div
+#endif
 #define npyv_div_f64 vec_div
 
 /***************************
  * FUSED
  ***************************/
 // multiply and add, a*b + c
-#define npyv_muladd_f32 vec_madd
 #define npyv_muladd_f64 vec_madd
 // multiply and subtract, a*b - c
-#define npyv_mulsub_f32 vec_msub
 #define npyv_mulsub_f64 vec_msub
-// negate multiply and add, -(a*b) + c
-#define npyv_nmuladd_f32 vec_nmsub // equivalent to -(a*b - c)
-#define npyv_nmuladd_f64 vec_nmsub
-// negate multiply and subtract, -(a*b) - c
-#define npyv_nmulsub_f32 vec_nmadd // equivalent to -(a*b + c)
-#define npyv_nmulsub_f64 vec_nmadd
-
+#if NPY_SIMD_F32
+    #define npyv_muladd_f32 vec_madd
+    #define npyv_mulsub_f32 vec_msub
+#endif
+#if defined(NPY_HAVE_VXE) || defined(NPY_HAVE_VSX)
+    // negate multiply and add, -(a*b) + c
+    #define npyv_nmuladd_f32 vec_nmsub // equivalent to -(a*b - c)
+    #define npyv_nmuladd_f64 vec_nmsub
+    // negate multiply and subtract, -(a*b) - c
+    #define npyv_nmulsub_f64 vec_nmadd
+    #define npyv_nmulsub_f32 vec_nmadd // equivalent to -(a*b + c)
+#else
+    NPY_FINLINE npyv_f64 npyv_nmuladd_f64(npyv_f64 a, npyv_f64 b, npyv_f64 c)
+    { return vec_neg(vec_msub(a, b, c)); }
+    NPY_FINLINE npyv_f64 npyv_nmulsub_f64(npyv_f64 a, npyv_f64 b, npyv_f64 c)
+    { return vec_neg(vec_madd(a, b, c)); }
+#endif
 /***************************
  * Summation
  ***************************/
 // reduce sum across vector
 NPY_FINLINE npy_uint64 npyv_sum_u64(npyv_u64 a)
 {
+#ifdef NPY_HAVE_VX
+    const npyv_u64 zero = npyv_zero_u64();
+    return vec_extract((npyv_u64)vec_sum_u128(a, zero), 1);
+#else
     return vec_extract(vec_add(a, vec_mergel(a, a)), 0);
+#endif
 }
 
 NPY_FINLINE npy_uint32 npyv_sum_u32(npyv_u32 a)
 {
+#ifdef NPY_HAVE_VX
+    const npyv_u32 zero = npyv_zero_u32();
+    return vec_extract((npyv_u32)vec_sum_u128(a, zero), 3);
+#else
     const npyv_u32 rs = vec_add(a, vec_sld(a, a, 8));
     return vec_extract(vec_add(rs, vec_sld(rs, rs, 4)), 0);
+#endif
 }
 
+#if NPY_SIMD_F32
 NPY_FINLINE float npyv_sum_f32(npyv_f32 a)
 {
     npyv_f32 sum = vec_add(a, npyv_combineh_f32(a, a));
     return vec_extract(sum, 0) + vec_extract(sum, 1);
 }
+#endif
 
 NPY_FINLINE double npyv_sum_f64(npyv_f64 a)
 {
@@ -277,19 +363,30 @@ NPY_FINLINE double npyv_sum_f64(npyv_f64 a)
 // expand the source vector and performs sum reduce
 NPY_FINLINE npy_uint16 npyv_sumup_u8(npyv_u8 a)
 {
+#ifdef NPY_HAVE_VX
+    const npyv_u8 zero = npyv_zero_u8();
+    npyv_u32 sum4 = vec_sum4(a, zero);
+    return (npy_uint16)npyv_sum_u32(sum4);
+#else
     const npyv_u32 zero = npyv_zero_u32();
     npyv_u32 four = vec_sum4s(a, zero);
     npyv_s32 one  = vec_sums((npyv_s32)four, (npyv_s32)zero);
     return (npy_uint16)vec_extract(one, 3);
+#endif
 }
 
 NPY_FINLINE npy_uint32 npyv_sumup_u16(npyv_u16 a)
 {
+#ifdef NPY_HAVE_VX
+    npyv_u64 sum = vec_sum2(a, npyv_zero_u16());
+    return (npy_uint32)npyv_sum_u64(sum);
+#else // VSX
     const npyv_s32 zero = npyv_zero_s32();
     npyv_u32x2 eight = npyv_expand_u32_u16(a);
     npyv_u32   four  = vec_add(eight.val[0], eight.val[1]);
     npyv_s32   one   = vec_sums((npyv_s32)four, zero);
     return (npy_uint32)vec_extract(one, 3);
+#endif
 }
 
-#endif // _NPY_SIMD_VSX_ARITHMETIC_H
+#endif // _NPY_SIMD_VEC_ARITHMETIC_H
diff --git a/numpy/core/src/common/simd/vec/conversion.h b/numpy/core/src/common/simd/vec/conversion.h
new file mode 100644
index 000000000000..0c0d5b3ac50e
--- /dev/null
+++ b/numpy/core/src/common/simd/vec/conversion.h
@@ -0,0 +1,229 @@
+#ifndef NPY_SIMD
+    #error "Not a standalone header"
+#endif
+
+#ifndef _NPY_SIMD_VEC_CVT_H
+#define _NPY_SIMD_VEC_CVT_H
+
+// convert boolean vectors to integer vectors
+#define npyv_cvt_u8_b8(BL)   ((npyv_u8)  BL)
+#define npyv_cvt_s8_b8(BL)   ((npyv_s8)  BL)
+#define npyv_cvt_u16_b16(BL) ((npyv_u16) BL)
+#define npyv_cvt_s16_b16(BL) ((npyv_s16) BL)
+#define npyv_cvt_u32_b32(BL) ((npyv_u32) BL)
+#define npyv_cvt_s32_b32(BL) ((npyv_s32) BL)
+#define npyv_cvt_u64_b64(BL) ((npyv_u64) BL)
+#define npyv_cvt_s64_b64(BL) ((npyv_s64) BL)
+#if NPY_SIMD_F32
+    #define npyv_cvt_f32_b32(BL) ((npyv_f32) BL)
+#endif
+#define npyv_cvt_f64_b64(BL) ((npyv_f64) BL)
+
+// convert integer vectors to boolean vectors
+#define npyv_cvt_b8_u8(A)   ((npyv_b8)  A)
+#define npyv_cvt_b8_s8(A)   ((npyv_b8)  A)
+#define npyv_cvt_b16_u16(A) ((npyv_b16) A)
+#define npyv_cvt_b16_s16(A) ((npyv_b16) A)
+#define npyv_cvt_b32_u32(A) ((npyv_b32) A)
+#define npyv_cvt_b32_s32(A) ((npyv_b32) A)
+#define npyv_cvt_b64_u64(A) ((npyv_b64) A)
+#define npyv_cvt_b64_s64(A) ((npyv_b64) A)
+#if NPY_SIMD_F32
+    #define npyv_cvt_b32_f32(A) ((npyv_b32) A)
+#endif
+#define npyv_cvt_b64_f64(A) ((npyv_b64) A)
+
+//expand
+NPY_FINLINE npyv_u16x2 npyv_expand_u16_u8(npyv_u8 data)
+{
+    npyv_u16x2 r;
+#ifdef NPY_HAVE_VX
+    r.val[0] = vec_unpackh(data);
+    r.val[1] = vec_unpackl(data);
+#else
+    npyv_u8 zero = npyv_zero_u8();
+    r.val[0] = (npyv_u16)vec_mergeh(data, zero);
+    r.val[1] = (npyv_u16)vec_mergel(data, zero);
+#endif
+    return r;
+}
+
+NPY_FINLINE npyv_u32x2 npyv_expand_u32_u16(npyv_u16 data)
+{
+    npyv_u32x2 r;
+#ifdef NPY_HAVE_VX
+    r.val[0] = vec_unpackh(data);
+    r.val[1] = vec_unpackl(data);
+#else
+    npyv_u16 zero = npyv_zero_u16();
+    r.val[0] = (npyv_u32)vec_mergeh(data, zero);
+    r.val[1] = (npyv_u32)vec_mergel(data, zero);
+#endif
+    return r;
+}
+
+// pack two 16-bit boolean into one 8-bit boolean vector
+NPY_FINLINE npyv_b8 npyv_pack_b8_b16(npyv_b16 a, npyv_b16 b) {
+    return vec_pack(a, b);
+}
+
+// pack four 32-bit boolean vectors into one 8-bit boolean vector
+NPY_FINLINE npyv_b8 npyv_pack_b8_b32(npyv_b32 a, npyv_b32 b, npyv_b32 c, npyv_b32 d) {
+    npyv_b16 ab = vec_pack(a, b);
+    npyv_b16 cd = vec_pack(c, d);
+    return npyv_pack_b8_b16(ab, cd);
+}
+
+// pack eight 64-bit boolean vectors into one 8-bit boolean vector
+NPY_FINLINE npyv_b8
+npyv_pack_b8_b64(npyv_b64 a, npyv_b64 b, npyv_b64 c, npyv_b64 d,
+                 npyv_b64 e, npyv_b64 f, npyv_b64 g, npyv_b64 h) {
+    npyv_b32 ab = vec_pack(a, b);
+    npyv_b32 cd = vec_pack(c, d);
+    npyv_b32 ef = vec_pack(e, f);
+    npyv_b32 gh = vec_pack(g, h);
+    return npyv_pack_b8_b32(ab, cd, ef, gh);
+}
+
+// convert boolean vector to integer bitfield
+#if defined(NPY_HAVE_VXE) || defined(NPY_HAVE_VSX2)
+    NPY_FINLINE npy_uint64 npyv_tobits_b8(npyv_b8 a)
+    {
+        const npyv_u8 qperm = npyv_set_u8(120, 112, 104, 96, 88, 80, 72, 64, 56, 48, 40, 32, 24, 16, 8, 0);
+        npyv_u16 r = (npyv_u16)vec_vbpermq((npyv_u8)a, qperm);
+    #ifdef NPY_HAVE_VXE
+        return vec_extract(r, 3);
+    #else
+        return vec_extract(r, 4);
+    #endif
+    }
+    NPY_FINLINE npy_uint64 npyv_tobits_b16(npyv_b16 a)
+    {
+        const npyv_u8 qperm = npyv_setf_u8(128, 112, 96, 80, 64, 48, 32, 16, 0);
+        npyv_u8 r = (npyv_u8)vec_vbpermq((npyv_u8)a, qperm);
+    #ifdef NPY_HAVE_VXE
+        return vec_extract(r, 6);
+    #else
+        return vec_extract(r, 8);
+    #endif
+    }
+    NPY_FINLINE npy_uint64 npyv_tobits_b32(npyv_b32 a)
+    {
+    #ifdef NPY_HAVE_VXE
+        const npyv_u8 qperm = npyv_setf_u8(128, 128, 128, 128, 128, 96, 64, 32, 0);
+    #else
+        const npyv_u8 qperm = npyv_setf_u8(128, 96, 64, 32, 0);
+    #endif
+        npyv_u8 r = (npyv_u8)vec_vbpermq((npyv_u8)a, qperm);
+    #ifdef NPY_HAVE_VXE
+        return vec_extract(r, 6);
+    #else
+        return vec_extract(r, 8);
+    #endif
+    }
+    NPY_FINLINE npy_uint64 npyv_tobits_b64(npyv_b64 a)
+    {
+    #ifdef NPY_HAVE_VXE
+        const npyv_u8 qperm = npyv_setf_u8(128, 128, 128, 128, 128, 128, 128, 64, 0);
+    #else
+        const npyv_u8 qperm = npyv_setf_u8(128, 64, 0);
+    #endif
+        npyv_u8 r = (npyv_u8)vec_vbpermq((npyv_u8)a, qperm);
+    #ifdef NPY_HAVE_VXE
+        return vec_extract(r, 6);
+    #else
+        return vec_extract(r, 8);
+    #endif
+    }
+#else
+    NPY_FINLINE npy_uint64 npyv_tobits_b8(npyv_b8 a)
+    {
+        const npyv_u8 scale = npyv_set_u8(1, 2, 4, 8, 16, 32, 64, 128, 1, 2, 4, 8, 16, 32, 64, 128);
+        npyv_u8 seq_scale = vec_and((npyv_u8)a, scale);
+        npyv_u64 sum = vec_sum2(vec_sum4(seq_scale, npyv_zero_u8()), npyv_zero_u32());
+        return vec_extract(sum, 0) + ((int)vec_extract(sum, 1) << 8);
+    }
+    NPY_FINLINE npy_uint64 npyv_tobits_b16(npyv_b16 a)
+    {
+        const npyv_u16 scale = npyv_set_u16(1, 2, 4, 8, 16, 32, 64, 128);
+        npyv_u16 seq_scale = vec_and((npyv_u16)a, scale);
+        npyv_u64 sum = vec_sum2(seq_scale, npyv_zero_u16());
+        return vec_extract(vec_sum_u128(sum, npyv_zero_u64()), 15);
+    }
+    NPY_FINLINE npy_uint64 npyv_tobits_b32(npyv_b32 a)
+    {
+        const npyv_u32 scale = npyv_set_u32(1, 2, 4, 8);
+        npyv_u32 seq_scale = vec_and((npyv_u32)a, scale);
+        return vec_extract(vec_sum_u128(seq_scale, npyv_zero_u32()), 15);
+    }
+    NPY_FINLINE npy_uint64 npyv_tobits_b64(npyv_b64 a)
+    {
+        const npyv_u64 scale = npyv_set_u64(1, 2);
+        npyv_u64 seq_scale = vec_and((npyv_u64)a, scale);
+        return vec_extract(vec_sum_u128(seq_scale, npyv_zero_u64()), 15);
+    }
+#endif
+// truncate compatible with all compilers(internal use for now)
+#if NPY_SIMD_F32
+    NPY_FINLINE npyv_s32 npyv__trunc_s32_f32(npyv_f32 a)
+    {
+    #ifdef NPY_HAVE_VXE2
+        return vec_signed(a);
+    #elif defined(NPY_HAVE_VXE)
+        return vec_packs(vec_signed(npyv_doublee(vec_mergeh(a,a))),
+            vec_signed(npyv_doublee(vec_mergel(a, a))));
+    // VSX
+    #elif defined(__IBMC__)
+        return vec_cts(a, 0);
+    #elif defined(__clang__)
+        /**
+         * old versions of CLANG doesn't support %x in the inline asm template
+         * which fixes register number when using any of the register constraints wa, wd, wf.
+         * therefore, we count on built-in functions.
+         */
+        return __builtin_convertvector(a, npyv_s32);
+    #else // gcc
+        npyv_s32 ret;
+        __asm__ ("xvcvspsxws %x0,%x1" : "=wa" (ret) : "wa" (a));
+        return ret;
+    #endif
+    }
+#endif
+
+NPY_FINLINE npyv_s32 npyv__trunc_s32_f64(npyv_f64 a, npyv_f64 b)
+{
+#ifdef NPY_HAVE_VX
+    return vec_packs(vec_signed(a), vec_signed(b));
+// VSX
+#elif defined(__IBMC__)
+    const npyv_u8 seq_even = npyv_set_u8(0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27);
+    // unfortunately, XLC missing asm register vsx fixer
+    // hopefully, xlc can optimize around big-endian compatibility
+    npyv_s32 lo_even = vec_cts(a, 0);
+    npyv_s32 hi_even = vec_cts(b, 0);
+    return vec_perm(lo_even, hi_even, seq_even);
+#else
+    const npyv_u8 seq_odd = npyv_set_u8(4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23, 28, 29, 30, 31);
+    #ifdef __clang__
+        // __builtin_convertvector doesn't support this conversion on wide range of versions
+        // fortunately, almost all versions have direct builtin of 'xvcvdpsxws'
+        npyv_s32 lo_odd = __builtin_vsx_xvcvdpsxws(a);
+        npyv_s32 hi_odd = __builtin_vsx_xvcvdpsxws(b);
+    #else // gcc
+        npyv_s32 lo_odd, hi_odd;
+        __asm__ ("xvcvdpsxws %x0,%x1" : "=wa" (lo_odd) : "wa" (a));
+        __asm__ ("xvcvdpsxws %x0,%x1" : "=wa" (hi_odd) : "wa" (b));
+    #endif
+    return vec_perm(lo_odd, hi_odd, seq_odd);
+#endif
+}
+
+// round to nearest integer (assuming even)
+#if NPY_SIMD_F32
+    NPY_FINLINE npyv_s32 npyv_round_s32_f32(npyv_f32 a)
+    { return npyv__trunc_s32_f32(vec_rint(a)); }
+#endif
+NPY_FINLINE npyv_s32 npyv_round_s32_f64(npyv_f64 a, npyv_f64 b)
+{ return npyv__trunc_s32_f64(vec_rint(a), vec_rint(b)); }
+
+#endif // _NPY_SIMD_VEC_CVT_H
diff --git a/numpy/core/src/common/simd/vec/math.h b/numpy/core/src/common/simd/vec/math.h
new file mode 100644
index 000000000000..95b16fdf76e3
--- /dev/null
+++ b/numpy/core/src/common/simd/vec/math.h
@@ -0,0 +1,283 @@
+#ifndef NPY_SIMD
+    #error "Not a standalone header"
+#endif
+
+#ifndef _NPY_SIMD_VEC_MATH_H
+#define _NPY_SIMD_VEC_MATH_H
+/***************************
+ * Elementary
+ ***************************/
+// Square root
+#if NPY_SIMD_F32
+    #define npyv_sqrt_f32 vec_sqrt
+#endif
+#define npyv_sqrt_f64 vec_sqrt
+
+// Reciprocal
+#if NPY_SIMD_F32
+    NPY_FINLINE npyv_f32 npyv_recip_f32(npyv_f32 a)
+    {
+        const npyv_f32 one = npyv_setall_f32(1.0f);
+        return vec_div(one, a);
+    }
+#endif
+NPY_FINLINE npyv_f64 npyv_recip_f64(npyv_f64 a)
+{
+    const npyv_f64 one = npyv_setall_f64(1.0);
+    return vec_div(one, a);
+}
+
+// Absolute
+#if NPY_SIMD_F32
+    #define npyv_abs_f32 vec_abs
+#endif
+#define npyv_abs_f64 vec_abs
+
+// Square
+#if NPY_SIMD_F32
+    NPY_FINLINE npyv_f32 npyv_square_f32(npyv_f32 a)
+    { return vec_mul(a, a); }
+#endif
+NPY_FINLINE npyv_f64 npyv_square_f64(npyv_f64 a)
+{ return vec_mul(a, a); }
+
+// Maximum, natively mapping with no guarantees to handle NaN.
+#if NPY_SIMD_F32
+    #define npyv_max_f32 vec_max
+#endif
+#define npyv_max_f64 vec_max
+// Maximum, supports IEEE floating-point arithmetic (IEC 60559),
+// - If one of the two vectors contains NaN, the equivalent element of the other vector is set
+// - Only if both corresponded elements are NaN, NaN is set.
+#if NPY_SIMD_F32
+    #define npyv_maxp_f32 vec_max
+#endif
+#if defined(NPY_HAVE_VXE) || defined(NPY_HAVE_VSX)
+    #define npyv_maxp_f64 vec_max
+#else
+    // vfmindb & vfmaxdb appears in zarch12
+    NPY_FINLINE npyv_f64 npyv_maxp_f64(npyv_f64 a, npyv_f64 b)
+    {
+        npyv_b64 nn_a = npyv_notnan_f64(a);
+        npyv_b64 nn_b = npyv_notnan_f64(b);
+        return vec_max(vec_sel(b, a, nn_a), vec_sel(a, b, nn_b));
+    }
+#endif
+#if NPY_SIMD_F32
+    NPY_FINLINE npyv_f32 npyv_maxn_f32(npyv_f32 a, npyv_f32 b)
+    {
+        npyv_b32 nn_a = npyv_notnan_f32(a);
+        npyv_b32 nn_b = npyv_notnan_f32(b);
+        npyv_f32 max = vec_max(a, b);
+        return vec_sel(b, vec_sel(a, max, nn_a), nn_b);
+    }
+#endif
+NPY_FINLINE npyv_f64 npyv_maxn_f64(npyv_f64 a, npyv_f64 b)
+{
+    npyv_b64 nn_a = npyv_notnan_f64(a);
+    npyv_b64 nn_b = npyv_notnan_f64(b);
+    npyv_f64 max = vec_max(a, b);
+    return vec_sel(b, vec_sel(a, max, nn_a), nn_b);
+}
+
+// Maximum, integer operations
+#define npyv_max_u8 vec_max
+#define npyv_max_s8 vec_max
+#define npyv_max_u16 vec_max
+#define npyv_max_s16 vec_max
+#define npyv_max_u32 vec_max
+#define npyv_max_s32 vec_max
+#define npyv_max_u64 vec_max
+#define npyv_max_s64 vec_max
+
+// Minimum, natively mapping with no guarantees to handle NaN.
+#if NPY_SIMD_F32
+    #define npyv_min_f32 vec_min
+#endif
+#define npyv_min_f64 vec_min
+// Minimum, supports IEEE floating-point arithmetic (IEC 60559),
+// - If one of the two vectors contains NaN, the equivalent element of the other vector is set
+// - Only if both corresponded elements are NaN, NaN is set.
+#if NPY_SIMD_F32
+    #define npyv_minp_f32 vec_min
+#endif
+#if defined(NPY_HAVE_VXE) || defined(NPY_HAVE_VSX)
+    #define npyv_minp_f64 vec_min
+#else
+    // vfmindb & vfmaxdb appears in zarch12
+    NPY_FINLINE npyv_f64 npyv_minp_f64(npyv_f64 a, npyv_f64 b)
+    {
+        npyv_b64 nn_a = npyv_notnan_f64(a);
+        npyv_b64 nn_b = npyv_notnan_f64(b);
+        return vec_min(vec_sel(b, a, nn_a), vec_sel(a, b, nn_b));
+    }
+#endif
+#if NPY_SIMD_F32
+    NPY_FINLINE npyv_f32 npyv_minn_f32(npyv_f32 a, npyv_f32 b)
+    {
+        npyv_b32 nn_a = npyv_notnan_f32(a);
+        npyv_b32 nn_b = npyv_notnan_f32(b);
+        npyv_f32 min = vec_min(a, b);
+        return vec_sel(b, vec_sel(a, min, nn_a), nn_b);
+    }
+#endif
+NPY_FINLINE npyv_f64 npyv_minn_f64(npyv_f64 a, npyv_f64 b)
+{
+    npyv_b64 nn_a = npyv_notnan_f64(a);
+    npyv_b64 nn_b = npyv_notnan_f64(b);
+    npyv_f64 min = vec_min(a, b);
+    return vec_sel(b, vec_sel(a, min, nn_a), nn_b);
+}
+
+// Minimum, integer operations
+#define npyv_min_u8 vec_min
+#define npyv_min_s8 vec_min
+#define npyv_min_u16 vec_min
+#define npyv_min_s16 vec_min
+#define npyv_min_u32 vec_min
+#define npyv_min_s32 vec_min
+#define npyv_min_u64 vec_min
+#define npyv_min_s64 vec_min
+
+#define NPY_IMPL_VEC_REDUCE_MINMAX(INTRIN, STYPE, SFX)                  \
+    NPY_FINLINE npy_##STYPE npyv_reduce_##INTRIN##_##SFX(npyv_##SFX a)  \
+    {                                                                   \
+        npyv_##SFX r = vec_##INTRIN(a, vec_sld(a, a, 8));               \
+                   r = vec_##INTRIN(r, vec_sld(r, r, 4));               \
+                   r = vec_##INTRIN(r, vec_sld(r, r, 2));               \
+                   r = vec_##INTRIN(r, vec_sld(r, r, 1));               \
+        return (npy_##STYPE)vec_extract(r, 0);                          \
+    }
+NPY_IMPL_VEC_REDUCE_MINMAX(min, uint8, u8)
+NPY_IMPL_VEC_REDUCE_MINMAX(max, uint8, u8)
+NPY_IMPL_VEC_REDUCE_MINMAX(min, int8, s8)
+NPY_IMPL_VEC_REDUCE_MINMAX(max, int8, s8)
+#undef NPY_IMPL_VEC_REDUCE_MINMAX
+
+#define NPY_IMPL_VEC_REDUCE_MINMAX(INTRIN, STYPE, SFX)                  \
+    NPY_FINLINE npy_##STYPE npyv_reduce_##INTRIN##_##SFX(npyv_##SFX a)  \
+    {                                                                   \
+        npyv_##SFX r = vec_##INTRIN(a, vec_sld(a, a, 8));               \
+                   r = vec_##INTRIN(r, vec_sld(r, r, 4));               \
+                   r = vec_##INTRIN(r, vec_sld(r, r, 2));               \
+        return (npy_##STYPE)vec_extract(r, 0);                          \
+    }
+NPY_IMPL_VEC_REDUCE_MINMAX(min, uint16, u16)
+NPY_IMPL_VEC_REDUCE_MINMAX(max, uint16, u16)
+NPY_IMPL_VEC_REDUCE_MINMAX(min, int16, s16)
+NPY_IMPL_VEC_REDUCE_MINMAX(max, int16, s16)
+#undef NPY_IMPL_VEC_REDUCE_MINMAX
+
+#define NPY_IMPL_VEC_REDUCE_MINMAX(INTRIN, STYPE, SFX)                  \
+    NPY_FINLINE npy_##STYPE npyv_reduce_##INTRIN##_##SFX(npyv_##SFX a)  \
+    {                                                                   \
+        npyv_##SFX r = vec_##INTRIN(a, vec_sld(a, a, 8));               \
+                   r = vec_##INTRIN(r, vec_sld(r, r, 4));               \
+        return (npy_##STYPE)vec_extract(r, 0);                          \
+    }
+NPY_IMPL_VEC_REDUCE_MINMAX(min, uint32, u32)
+NPY_IMPL_VEC_REDUCE_MINMAX(max, uint32, u32)
+NPY_IMPL_VEC_REDUCE_MINMAX(min, int32, s32)
+NPY_IMPL_VEC_REDUCE_MINMAX(max, int32, s32)
+#undef NPY_IMPL_VEC_REDUCE_MINMAX
+
+#define NPY_IMPL_VEC_REDUCE_MINMAX(INTRIN, STYPE, SFX)                  \
+    NPY_FINLINE npy_##STYPE npyv_reduce_##INTRIN##_##SFX(npyv_##SFX a)  \
+    {                                                                   \
+        npyv_##SFX r = vec_##INTRIN(a, vec_sld(a, a, 8));               \
+        return (npy_##STYPE)vec_extract(r, 0);                          \
+    }
+NPY_IMPL_VEC_REDUCE_MINMAX(min, uint64, u64)
+NPY_IMPL_VEC_REDUCE_MINMAX(max, uint64, u64)
+NPY_IMPL_VEC_REDUCE_MINMAX(min, int64, s64)
+NPY_IMPL_VEC_REDUCE_MINMAX(max, int64, s64)
+#undef NPY_IMPL_VEC_REDUCE_MINMAX
+
+#if NPY_SIMD_F32
+    #define NPY_IMPL_VEC_REDUCE_MINMAX(INTRIN, INF)                   \
+        NPY_FINLINE float npyv_reduce_##INTRIN##_f32(npyv_f32 a)      \
+        {                                                             \
+            npyv_f32 r = vec_##INTRIN(a, vec_sld(a, a, 8));           \
+                     r = vec_##INTRIN(r, vec_sld(r, r, 4));           \
+            return vec_extract(r, 0);                                 \
+        }                                                             \
+        NPY_FINLINE float npyv_reduce_##INTRIN##p_f32(npyv_f32 a)     \
+        {                                                             \
+            return npyv_reduce_##INTRIN##_f32(a);                     \
+        }                                                             \
+        NPY_FINLINE float npyv_reduce_##INTRIN##n_f32(npyv_f32 a)     \
+        {                                                             \
+            npyv_b32 notnan = npyv_notnan_f32(a);                     \
+            if (NPY_UNLIKELY(!npyv_all_b32(notnan))) {                \
+                const union { npy_uint32 i; float f;}                 \
+                pnan = {0x7fc00000UL};                                \
+                return pnan.f;                                        \
+            }                                                         \
+            return npyv_reduce_##INTRIN##_f32(a);                     \
+        }
+    NPY_IMPL_VEC_REDUCE_MINMAX(min, 0x7f800000)
+    NPY_IMPL_VEC_REDUCE_MINMAX(max, 0xff800000)
+    #undef NPY_IMPL_VEC_REDUCE_MINMAX
+#endif // NPY_SIMD_F32
+
+#define NPY_IMPL_VEC_REDUCE_MINMAX(INTRIN, INF)                   \
+    NPY_FINLINE double npyv_reduce_##INTRIN##_f64(npyv_f64 a)     \
+    {                                                             \
+        npyv_f64 r = vec_##INTRIN(a, vec_sld(a, a, 8));           \
+        return vec_extract(r, 0);                                 \
+    }                                                             \
+    NPY_FINLINE double npyv_reduce_##INTRIN##n_f64(npyv_f64 a)    \
+    {                                                             \
+        npyv_b64 notnan = npyv_notnan_f64(a);                     \
+        if (NPY_UNLIKELY(!npyv_all_b64(notnan))) {                \
+            const union { npy_uint64 i; double f;}                \
+            pnan = {0x7ff8000000000000ull};                       \
+            return pnan.f;                                        \
+        }                                                         \
+        return npyv_reduce_##INTRIN##_f64(a);                     \
+    }
+NPY_IMPL_VEC_REDUCE_MINMAX(min, 0x7ff0000000000000)
+NPY_IMPL_VEC_REDUCE_MINMAX(max, 0xfff0000000000000)
+#undef NPY_IMPL_VEC_REDUCE_MINMAX
+
+#if defined(NPY_HAVE_VXE) || defined(NPY_HAVE_VSX)
+    #define npyv_reduce_minp_f64 npyv_reduce_min_f64
+    #define npyv_reduce_maxp_f64 npyv_reduce_max_f64
+#else
+    NPY_FINLINE double npyv_reduce_minp_f64(npyv_f64 a)
+    {
+        npyv_b64 notnan = npyv_notnan_f64(a);
+        if (NPY_UNLIKELY(!npyv_any_b64(notnan))) {
+            return vec_extract(a, 0);
+        }
+        a = npyv_select_f64(notnan, a, npyv_reinterpret_f64_u64(
+                    npyv_setall_u64(0x7ff0000000000000)));
+        return npyv_reduce_min_f64(a);
+    }
+    NPY_FINLINE double npyv_reduce_maxp_f64(npyv_f64 a)
+    {
+        npyv_b64 notnan = npyv_notnan_f64(a);
+        if (NPY_UNLIKELY(!npyv_any_b64(notnan))) {
+            return vec_extract(a, 0);
+        }
+        a = npyv_select_f64(notnan, a, npyv_reinterpret_f64_u64(
+                    npyv_setall_u64(0xfff0000000000000)));
+        return npyv_reduce_max_f64(a);
+    }
+#endif
+// round to nearest int even
+#define npyv_rint_f64 vec_rint
+// ceil
+#define npyv_ceil_f64 vec_ceil
+// trunc
+#define npyv_trunc_f64 vec_trunc
+// floor
+#define npyv_floor_f64 vec_floor
+#if NPY_SIMD_F32
+    #define npyv_rint_f32 vec_rint
+    #define npyv_ceil_f32 vec_ceil
+    #define npyv_trunc_f32 vec_trunc
+    #define npyv_floor_f32 vec_floor
+#endif
+
+#endif // _NPY_SIMD_VEC_MATH_H
diff --git a/numpy/core/src/common/simd/vsx/memory.h b/numpy/core/src/common/simd/vec/memory.h
similarity index 76%
rename from numpy/core/src/common/simd/vsx/memory.h
rename to numpy/core/src/common/simd/vec/memory.h
index 08a0a9276cc6..495f698bf4dc 100644
--- a/numpy/core/src/common/simd/vsx/memory.h
+++ b/numpy/core/src/common/simd/vec/memory.h
@@ -2,8 +2,8 @@
     #error "Not a standalone header"
 #endif
 
-#ifndef _NPY_SIMD_VSX_MEMORY_H
-#define _NPY_SIMD_VSX_MEMORY_H
+#ifndef _NPY_SIMD_VEC_MEMORY_H
+#define _NPY_SIMD_VEC_MEMORY_H
 
 #include "misc.h"
 
@@ -19,19 +19,32 @@
      * CLANG fails to load unaligned addresses via vec_xl, vec_xst
      * so we failback to vec_vsx_ld, vec_vsx_st
      */
-    #if (defined(__GNUC__) && !defined(vec_xl)) || (defined(__clang__) && !defined(__IBMC__))
+    #if defined (NPY_HAVE_VSX2) && ( \
+        (defined(__GNUC__) && !defined(vec_xl)) || (defined(__clang__) && !defined(__IBMC__)) \
+    )
         #define npyv__load(T_VEC, PTR) vec_vsx_ld(0, PTR)
-    #else
+    #else // VX
         #define npyv__load(T_VEC, PTR) vec_xl(0, PTR)
     #endif
 #endif
 // unaligned store
-#if (defined(__GNUC__) && !defined(vec_xl)) || (defined(__clang__) && !defined(__IBMC__))
+#if defined (NPY_HAVE_VSX2) && ( \
+    (defined(__GNUC__) && !defined(vec_xl)) || (defined(__clang__) && !defined(__IBMC__)) \
+)
     #define npyv__store(PTR, VEC) vec_vsx_st(VEC, 0, PTR)
-#else
+#else // VX
     #define npyv__store(PTR, VEC) vec_xst(VEC, 0, PTR)
 #endif
 
+// aligned load/store
+#if defined (NPY_HAVE_VSX)
+    #define npyv__loada(PTR) vec_ld(0, PTR)
+    #define npyv__storea(PTR, VEC) vec_st(VEC, 0, PTR)
+#else // VX
+    #define npyv__loada(PTR) vec_xl(0, PTR)
+    #define npyv__storea(PTR, VEC) vec_xst(VEC, 0, PTR)
+#endif
+
 // avoid aliasing rules
 #ifdef __cplusplus
     template
@@ -45,12 +58,16 @@
 // load lower part
 NPY_FINLINE npyv_u64 npyv__loadl(const void *ptr)
 {
+#ifdef NPY_HAVE_VSX
     #if defined(__clang__) && !defined(__IBMC__)
         // vec_promote doesn't support doubleword on clang
         return npyv_setall_u64(*npyv__ptr2u64(ptr));
     #else
         return vec_promote(*npyv__ptr2u64(ptr), 0);
     #endif
+#else // VX
+    return vec_load_len((const unsigned long long*)ptr, 7);
+#endif
 }
 // store lower part
 #define npyv__storel(PTR, VEC) \
@@ -62,11 +79,11 @@ NPY_FINLINE npyv_u64 npyv__loadl(const void *ptr)
 /****************************
  * load/store
  ****************************/
-#define NPYV_IMPL_VSX_MEM(SFX, DW_CAST)                                                 \
+#define NPYV_IMPL_VEC_MEM(SFX, DW_CAST)                                                 \
     NPY_FINLINE npyv_##SFX npyv_load_##SFX(const npyv_lanetype_##SFX *ptr)              \
     { return (npyv_##SFX)npyv__load(npyv_##SFX, (const npyv_lanetype_##DW_CAST*)ptr); } \
     NPY_FINLINE npyv_##SFX npyv_loada_##SFX(const npyv_lanetype_##SFX *ptr)             \
-    { return (npyv_##SFX)vec_ld(0, (const npyv_lanetype_u32*)ptr); }                    \
+    { return (npyv_##SFX)npyv__loada((const npyv_lanetype_u32*)ptr); }                  \
     NPY_FINLINE npyv_##SFX npyv_loads_##SFX(const npyv_lanetype_##SFX *ptr)             \
     { return npyv_loada_##SFX(ptr); }                                                   \
     NPY_FINLINE npyv_##SFX npyv_loadl_##SFX(const npyv_lanetype_##SFX *ptr)             \
@@ -74,7 +91,7 @@ NPY_FINLINE npyv_u64 npyv__loadl(const void *ptr)
     NPY_FINLINE void npyv_store_##SFX(npyv_lanetype_##SFX *ptr, npyv_##SFX vec)         \
     { npyv__store((npyv_lanetype_##DW_CAST*)ptr, (npyv_##DW_CAST)vec); }                \
     NPY_FINLINE void npyv_storea_##SFX(npyv_lanetype_##SFX *ptr, npyv_##SFX vec)        \
-    { vec_st((npyv_u32)vec, 0, (npyv_lanetype_u32*)ptr); }                              \
+    { npyv__storea((npyv_lanetype_##DW_CAST*)ptr, (npyv_##DW_CAST)vec); }               \
     NPY_FINLINE void npyv_stores_##SFX(npyv_lanetype_##SFX *ptr, npyv_##SFX vec)        \
     { npyv_storea_##SFX(ptr, vec); }                                                    \
     NPY_FINLINE void npyv_storel_##SFX(npyv_lanetype_##SFX *ptr, npyv_##SFX vec)        \
@@ -82,16 +99,18 @@ NPY_FINLINE npyv_u64 npyv__loadl(const void *ptr)
     NPY_FINLINE void npyv_storeh_##SFX(npyv_lanetype_##SFX *ptr, npyv_##SFX vec)        \
     { npyv__storeh(ptr, vec); }
 
-NPYV_IMPL_VSX_MEM(u8,  u8)
-NPYV_IMPL_VSX_MEM(s8,  s8)
-NPYV_IMPL_VSX_MEM(u16, u16)
-NPYV_IMPL_VSX_MEM(s16, s16)
-NPYV_IMPL_VSX_MEM(u32, u32)
-NPYV_IMPL_VSX_MEM(s32, s32)
-NPYV_IMPL_VSX_MEM(u64, f64)
-NPYV_IMPL_VSX_MEM(s64, f64)
-NPYV_IMPL_VSX_MEM(f32, f32)
-NPYV_IMPL_VSX_MEM(f64, f64)
+NPYV_IMPL_VEC_MEM(u8,  u8)
+NPYV_IMPL_VEC_MEM(s8,  s8)
+NPYV_IMPL_VEC_MEM(u16, u16)
+NPYV_IMPL_VEC_MEM(s16, s16)
+NPYV_IMPL_VEC_MEM(u32, u32)
+NPYV_IMPL_VEC_MEM(s32, s32)
+NPYV_IMPL_VEC_MEM(u64, f64)
+NPYV_IMPL_VEC_MEM(s64, f64)
+#if NPY_SIMD_F32
+NPYV_IMPL_VEC_MEM(f32, f32)
+#endif
+NPYV_IMPL_VEC_MEM(f64, f64)
 
 /***************************
  * Non-contiguous Load
@@ -106,8 +125,10 @@ NPY_FINLINE npyv_u32 npyv_loadn_u32(const npy_uint32 *ptr, npy_intp stride)
 }
 NPY_FINLINE npyv_s32 npyv_loadn_s32(const npy_int32 *ptr, npy_intp stride)
 { return (npyv_s32)npyv_loadn_u32((const npy_uint32*)ptr, stride); }
+#if NPY_SIMD_F32
 NPY_FINLINE npyv_f32 npyv_loadn_f32(const float *ptr, npy_intp stride)
 { return (npyv_f32)npyv_loadn_u32((const npy_uint32*)ptr, stride); }
+#endif
 //// 64
 NPY_FINLINE npyv_u64 npyv_loadn_u64(const npy_uint64 *ptr, npy_intp stride)
 { return npyv_set_u64(ptr[0], ptr[stride]); }
@@ -128,8 +149,10 @@ NPY_FINLINE void npyv_storen_u32(npy_uint32 *ptr, npy_intp stride, npyv_u32 a)
 }
 NPY_FINLINE void npyv_storen_s32(npy_int32 *ptr, npy_intp stride, npyv_s32 a)
 { npyv_storen_u32((npy_uint32*)ptr, stride, (npyv_u32)a); }
+#if NPY_SIMD_F32
 NPY_FINLINE void npyv_storen_f32(float *ptr, npy_intp stride, npyv_f32 a)
 { npyv_storen_u32((npy_uint32*)ptr, stride, (npyv_u32)a); }
+#endif
 //// 64
 NPY_FINLINE void npyv_storen_u64(npy_uint64 *ptr, npy_intp stride, npyv_u64 a)
 {
@@ -149,6 +172,14 @@ NPY_FINLINE npyv_s32 npyv_load_till_s32(const npy_int32 *ptr, npy_uintp nlane, n
 {
     assert(nlane > 0);
     npyv_s32 vfill = npyv_setall_s32(fill);
+#ifdef NPY_HAVE_VX
+    const unsigned blane = (nlane > 4) ? 4 : nlane;
+    const npyv_u32 steps = npyv_set_u32(0, 1, 2, 3);
+    const npyv_u32 vlane = npyv_setall_u32(blane);
+    const npyv_b32 mask  = vec_cmpgt(vlane, steps);
+    npyv_s32 a = vec_load_len(ptr, blane*4-1);
+    return vec_sel(vfill, a, mask);
+#else
     switch(nlane) {
     case 1:
         return vec_insert(ptr[0], vfill, 0);
@@ -164,10 +195,18 @@ NPY_FINLINE npyv_s32 npyv_load_till_s32(const npy_int32 *ptr, npy_uintp nlane, n
     default:
         return npyv_load_s32(ptr);
     }
+#endif
 }
 // fill zero to rest lanes
 NPY_FINLINE npyv_s32 npyv_load_tillz_s32(const npy_int32 *ptr, npy_uintp nlane)
-{ return npyv_load_till_s32(ptr, nlane, 0); }
+{
+#ifdef NPY_HAVE_VX
+    unsigned blane = (nlane > 4) ? 4 : nlane;
+    return vec_load_len(ptr, blane*4-1);
+#else
+    return npyv_load_till_s32(ptr, nlane, 0);
+#endif
+}
 //// 64
 NPY_FINLINE npyv_s64 npyv_load_till_s64(const npy_int64 *ptr, npy_uintp nlane, npy_int64 fill)
 {
@@ -179,7 +218,14 @@ NPY_FINLINE npyv_s64 npyv_load_till_s64(const npy_int64 *ptr, npy_uintp nlane, n
 }
 // fill zero to rest lanes
 NPY_FINLINE npyv_s64 npyv_load_tillz_s64(const npy_int64 *ptr, npy_uintp nlane)
-{  return npyv_load_till_s64(ptr, nlane, 0); }
+{
+#ifdef NPY_HAVE_VX
+    unsigned blane = (nlane > 2) ? 2 : nlane;
+    return vec_load_len((const signed long long*)ptr, blane*8-1);
+#else
+    return npyv_load_till_s64(ptr, nlane, 0);
+#endif
+}
 /*********************************
  * Non-contiguous partial load
  *********************************/
@@ -226,6 +272,10 @@ NPY_FINLINE npyv_s64 npyv_loadn_tillz_s64(const npy_int64 *ptr, npy_intp stride,
 NPY_FINLINE void npyv_store_till_s32(npy_int32 *ptr, npy_uintp nlane, npyv_s32 a)
 {
     assert(nlane > 0);
+#ifdef NPY_HAVE_VX
+    unsigned blane = (nlane > 4) ? 4 : nlane;
+    vec_store_len(a, ptr, blane*4-1);
+#else
     switch(nlane) {
     case 1:
         *ptr = vec_extract(a, 0);
@@ -240,16 +290,22 @@ NPY_FINLINE void npyv_store_till_s32(npy_int32 *ptr, npy_uintp nlane, npyv_s32 a
     default:
         npyv_store_s32(ptr, a);
     }
+#endif
 }
 //// 64
 NPY_FINLINE void npyv_store_till_s64(npy_int64 *ptr, npy_uintp nlane, npyv_s64 a)
 {
     assert(nlane > 0);
+#ifdef NPY_HAVE_VX
+    unsigned blane = (nlane > 2) ? 2 : nlane;
+    vec_store_len(a, (signed long long*)ptr, blane*8-1);
+#else
     if (nlane == 1) {
         npyv_storel_s64(ptr, a);
         return;
     }
     npyv_store_s64(ptr, a);
+#endif
 }
 /*********************************
  * Non-contiguous partial store
@@ -283,7 +339,7 @@ NPY_FINLINE void npyv_storen_till_s64(npy_int64 *ptr, npy_intp stride, npy_uintp
 /*****************************************************************
  * Implement partial load/store for u32/f32/u64/f64... via casting
  *****************************************************************/
-#define NPYV_IMPL_VSX_REST_PARTIAL_TYPES(F_SFX, T_SFX)                                      \
+#define NPYV_IMPL_VEC_REST_PARTIAL_TYPES(F_SFX, T_SFX)                                      \
     NPY_FINLINE npyv_##F_SFX npyv_load_till_##F_SFX                                         \
     (const npyv_lanetype_##F_SFX *ptr, npy_uintp nlane, npyv_lanetype_##F_SFX fill)         \
     {                                                                                       \
@@ -338,9 +394,54 @@ NPY_FINLINE void npyv_storen_till_s64(npy_int64 *ptr, npy_intp stride, npy_uintp
         );                                                                                  \
     }
 
-NPYV_IMPL_VSX_REST_PARTIAL_TYPES(u32, s32)
-NPYV_IMPL_VSX_REST_PARTIAL_TYPES(f32, s32)
-NPYV_IMPL_VSX_REST_PARTIAL_TYPES(u64, s64)
-NPYV_IMPL_VSX_REST_PARTIAL_TYPES(f64, s64)
+NPYV_IMPL_VEC_REST_PARTIAL_TYPES(u32, s32)
+#if NPY_SIMD_F32
+NPYV_IMPL_VEC_REST_PARTIAL_TYPES(f32, s32)
+#endif
+NPYV_IMPL_VEC_REST_PARTIAL_TYPES(u64, s64)
+NPYV_IMPL_VEC_REST_PARTIAL_TYPES(f64, s64)
+
+/*********************************
+ * Lookup table
+ *********************************/
+// uses vector as indexes into a table
+// that contains 32 elements of float32.
+NPY_FINLINE npyv_u32 npyv_lut32_u32(const npy_uint32 *table, npyv_u32 idx)
+{
+    const unsigned i0 = vec_extract(idx, 0);
+    const unsigned i1 = vec_extract(idx, 1);
+    const unsigned i2 = vec_extract(idx, 2);
+    const unsigned i3 = vec_extract(idx, 3);
+    npyv_u32 r = vec_promote(table[i0], 0);
+             r = vec_insert(table[i1], r, 1);
+             r = vec_insert(table[i2], r, 2);
+             r = vec_insert(table[i3], r, 3);
+    return r;
+}
+NPY_FINLINE npyv_s32 npyv_lut32_s32(const npy_int32 *table, npyv_u32 idx)
+{ return (npyv_s32)npyv_lut32_u32((const npy_uint32*)table, idx); }
+#if NPY_SIMD_F32
+    NPY_FINLINE npyv_f32 npyv_lut32_f32(const float *table, npyv_u32 idx)
+    { return (npyv_f32)npyv_lut32_u32((const npy_uint32*)table, idx); }
+#endif
+// uses vector as indexes into a table
+// that contains 16 elements of float64.
+NPY_FINLINE npyv_f64 npyv_lut16_f64(const double *table, npyv_u64 idx)
+{
+#ifdef NPY_HAVE_VX
+    const unsigned i0 = vec_extract((npyv_u32)idx, 1);
+    const unsigned i1 = vec_extract((npyv_u32)idx, 3);
+#else
+    const unsigned i0 = vec_extract((npyv_u32)idx, 0);
+    const unsigned i1 = vec_extract((npyv_u32)idx, 2);
+#endif
+    npyv_f64 r = vec_promote(table[i0], 0);
+             r = vec_insert(table[i1], r, 1);
+    return r;
+}
+NPY_FINLINE npyv_u64 npyv_lut16_u64(const npy_uint64 *table, npyv_u64 idx)
+{ return npyv_reinterpret_u64_f64(npyv_lut16_f64((const double*)table, idx)); }
+NPY_FINLINE npyv_s64 npyv_lut16_s64(const npy_int64 *table, npyv_u64 idx)
+{ return npyv_reinterpret_s64_f64(npyv_lut16_f64((const double*)table, idx)); }
 
-#endif // _NPY_SIMD_VSX_MEMORY_H
+#endif // _NPY_SIMD_VEC_MEMORY_H
diff --git a/numpy/core/src/common/simd/vsx/misc.h b/numpy/core/src/common/simd/vec/misc.h
similarity index 68%
rename from numpy/core/src/common/simd/vsx/misc.h
rename to numpy/core/src/common/simd/vec/misc.h
index f7a0cdd5c137..7ea0f21f65e0 100644
--- a/numpy/core/src/common/simd/vsx/misc.h
+++ b/numpy/core/src/common/simd/vec/misc.h
@@ -2,8 +2,8 @@
     #error "Not a standalone header"
 #endif
 
-#ifndef _NPY_SIMD_VSX_MISC_H
-#define _NPY_SIMD_VSX_MISC_H
+#ifndef _NPY_SIMD_VEC_MISC_H
+#define _NPY_SIMD_VEC_MISC_H
 
 // vector with zero lanes
 #define npyv_zero_u8()  ((npyv_u8)   npyv_setall_s32(0))
@@ -14,26 +14,30 @@
 #define npyv_zero_s32() npyv_setall_s32(0)
 #define npyv_zero_u64() ((npyv_u64) npyv_setall_s32(0))
 #define npyv_zero_s64() ((npyv_s64) npyv_setall_s32(0))
-#define npyv_zero_f32() npyv_setall_f32(0.0f)
+#if NPY_SIMD_F32
+    #define npyv_zero_f32() npyv_setall_f32(0.0f)
+#endif
 #define npyv_zero_f64() npyv_setall_f64(0.0)
 
 // vector with a specific value set to all lanes
 // the safest way to generate vsplti* and vsplt* instructions
-#define NPYV_IMPL_VSX_SPLTB(T_VEC, V) ((T_VEC){V, V, V, V, V, V, V, V, V, V, V, V, V, V, V, V})
-#define NPYV_IMPL_VSX_SPLTH(T_VEC, V) ((T_VEC){V, V, V, V, V, V, V, V})
-#define NPYV_IMPL_VSX_SPLTW(T_VEC, V) ((T_VEC){V, V, V, V})
-#define NPYV_IMPL_VSX_SPLTD(T_VEC, V) ((T_VEC){V, V})
-
-#define npyv_setall_u8(VAL)  NPYV_IMPL_VSX_SPLTB(npyv_u8,  (unsigned char)VAL)
-#define npyv_setall_s8(VAL)  NPYV_IMPL_VSX_SPLTB(npyv_s8,  (signed char)VAL)
-#define npyv_setall_u16(VAL) NPYV_IMPL_VSX_SPLTH(npyv_u16, (unsigned short)VAL)
-#define npyv_setall_s16(VAL) NPYV_IMPL_VSX_SPLTH(npyv_s16, (short)VAL)
-#define npyv_setall_u32(VAL) NPYV_IMPL_VSX_SPLTW(npyv_u32, (unsigned int)VAL)
-#define npyv_setall_s32(VAL) NPYV_IMPL_VSX_SPLTW(npyv_s32, (int)VAL)
-#define npyv_setall_f32(VAL) NPYV_IMPL_VSX_SPLTW(npyv_f32, VAL)
-#define npyv_setall_u64(VAL) NPYV_IMPL_VSX_SPLTD(npyv_u64, (npy_uint64)VAL)
-#define npyv_setall_s64(VAL) NPYV_IMPL_VSX_SPLTD(npyv_s64, (npy_int64)VAL)
-#define npyv_setall_f64(VAL) NPYV_IMPL_VSX_SPLTD(npyv_f64, VAL)
+#define NPYV_IMPL_VEC_SPLTB(T_VEC, V) ((T_VEC){V, V, V, V, V, V, V, V, V, V, V, V, V, V, V, V})
+#define NPYV_IMPL_VEC_SPLTH(T_VEC, V) ((T_VEC){V, V, V, V, V, V, V, V})
+#define NPYV_IMPL_VEC_SPLTW(T_VEC, V) ((T_VEC){V, V, V, V})
+#define NPYV_IMPL_VEC_SPLTD(T_VEC, V) ((T_VEC){V, V})
+
+#define npyv_setall_u8(VAL)  NPYV_IMPL_VEC_SPLTB(npyv_u8,  (unsigned char)VAL)
+#define npyv_setall_s8(VAL)  NPYV_IMPL_VEC_SPLTB(npyv_s8,  (signed char)VAL)
+#define npyv_setall_u16(VAL) NPYV_IMPL_VEC_SPLTH(npyv_u16, (unsigned short)VAL)
+#define npyv_setall_s16(VAL) NPYV_IMPL_VEC_SPLTH(npyv_s16, (short)VAL)
+#define npyv_setall_u32(VAL) NPYV_IMPL_VEC_SPLTW(npyv_u32, (unsigned int)VAL)
+#define npyv_setall_s32(VAL) NPYV_IMPL_VEC_SPLTW(npyv_s32, (int)VAL)
+#if NPY_SIMD_F32
+    #define npyv_setall_f32(VAL) NPYV_IMPL_VEC_SPLTW(npyv_f32, VAL)
+#endif
+#define npyv_setall_u64(VAL) NPYV_IMPL_VEC_SPLTD(npyv_u64, (npy_uint64)VAL)
+#define npyv_setall_s64(VAL) NPYV_IMPL_VEC_SPLTD(npyv_s64, (npy_int64)VAL)
+#define npyv_setall_f64(VAL) NPYV_IMPL_VEC_SPLTD(npyv_f64, VAL)
 
 // vector with specific values set to each lane and
 // set a specific value to all remained lanes
@@ -45,7 +49,9 @@
 #define npyv_setf_s32(FILL, ...) ((npyv_s32){NPYV__SET_FILL_4(int, FILL, __VA_ARGS__)})
 #define npyv_setf_u64(FILL, ...) ((npyv_u64){NPYV__SET_FILL_2(npy_int64, FILL, __VA_ARGS__)})
 #define npyv_setf_s64(FILL, ...) ((npyv_s64){NPYV__SET_FILL_2(npy_int64, FILL, __VA_ARGS__)})
-#define npyv_setf_f32(FILL, ...) ((npyv_f32){NPYV__SET_FILL_4(float, FILL, __VA_ARGS__)})
+#if NPY_SIMD_F32
+    #define npyv_setf_f32(FILL, ...) ((npyv_f32){NPYV__SET_FILL_4(float, FILL, __VA_ARGS__)})
+#endif
 #define npyv_setf_f64(FILL, ...) ((npyv_f64){NPYV__SET_FILL_2(double, FILL, __VA_ARGS__)})
 
 // vector with specific values set to each lane and
@@ -58,7 +64,9 @@
 #define npyv_set_s32(...) npyv_setf_s32(0, __VA_ARGS__)
 #define npyv_set_u64(...) npyv_setf_u64(0, __VA_ARGS__)
 #define npyv_set_s64(...) npyv_setf_s64(0, __VA_ARGS__)
-#define npyv_set_f32(...) npyv_setf_f32(0, __VA_ARGS__)
+#if NPY_SIMD_F32
+    #define npyv_set_f32(...) npyv_setf_f32(0, __VA_ARGS__)
+#endif
 #define npyv_set_f64(...) npyv_setf_f64(0, __VA_ARGS__)
 
 // Per lane select
@@ -70,9 +78,25 @@
 #define npyv_select_s32 npyv_select_u8
 #define npyv_select_u64 npyv_select_u8
 #define npyv_select_s64 npyv_select_u8
-#define npyv_select_f32 npyv_select_u8
+#if NPY_SIMD_F32
+    #define npyv_select_f32 npyv_select_u8
+#endif
 #define npyv_select_f64 npyv_select_u8
 
+// extract the first vector's lane
+#define npyv_extract0_u8(A) ((npy_uint8)vec_extract(A, 0))
+#define npyv_extract0_s8(A) ((npy_int8)vec_extract(A, 0))
+#define npyv_extract0_u16(A) ((npy_uint16)vec_extract(A, 0))
+#define npyv_extract0_s16(A) ((npy_int16)vec_extract(A, 0))
+#define npyv_extract0_u32(A) ((npy_uint32)vec_extract(A, 0))
+#define npyv_extract0_s32(A) ((npy_int32)vec_extract(A, 0))
+#define npyv_extract0_u64(A) ((npy_uint64)vec_extract(A, 0))
+#define npyv_extract0_s64(A) ((npy_int64)vec_extract(A, 0))
+#if NPY_SIMD_F32
+    #define npyv_extract0_f32(A) vec_extract(A, 0)
+#endif
+#define npyv_extract0_f64(A) vec_extract(A, 0)
+
 // Reinterpret
 #define npyv_reinterpret_u8_u8(X) X
 #define npyv_reinterpret_u8_s8(X) ((npyv_u8)X)
@@ -82,7 +106,9 @@
 #define npyv_reinterpret_u8_s32 npyv_reinterpret_u8_s8
 #define npyv_reinterpret_u8_u64 npyv_reinterpret_u8_s8
 #define npyv_reinterpret_u8_s64 npyv_reinterpret_u8_s8
-#define npyv_reinterpret_u8_f32 npyv_reinterpret_u8_s8
+#if NPY_SIMD_F32
+    #define npyv_reinterpret_u8_f32 npyv_reinterpret_u8_s8
+#endif
 #define npyv_reinterpret_u8_f64 npyv_reinterpret_u8_s8
 
 #define npyv_reinterpret_s8_s8(X) X
@@ -93,7 +119,9 @@
 #define npyv_reinterpret_s8_s32 npyv_reinterpret_s8_u8
 #define npyv_reinterpret_s8_u64 npyv_reinterpret_s8_u8
 #define npyv_reinterpret_s8_s64 npyv_reinterpret_s8_u8
-#define npyv_reinterpret_s8_f32 npyv_reinterpret_s8_u8
+#if NPY_SIMD_F32
+    #define npyv_reinterpret_s8_f32 npyv_reinterpret_s8_u8
+#endif
 #define npyv_reinterpret_s8_f64 npyv_reinterpret_s8_u8
 
 #define npyv_reinterpret_u16_u16(X) X
@@ -104,7 +132,9 @@
 #define npyv_reinterpret_u16_s32 npyv_reinterpret_u16_u8
 #define npyv_reinterpret_u16_u64 npyv_reinterpret_u16_u8
 #define npyv_reinterpret_u16_s64 npyv_reinterpret_u16_u8
-#define npyv_reinterpret_u16_f32 npyv_reinterpret_u16_u8
+#if NPY_SIMD_F32
+    #define npyv_reinterpret_u16_f32 npyv_reinterpret_u16_u8
+#endif
 #define npyv_reinterpret_u16_f64 npyv_reinterpret_u16_u8
 
 #define npyv_reinterpret_s16_s16(X) X
@@ -115,7 +145,9 @@
 #define npyv_reinterpret_s16_s32 npyv_reinterpret_s16_u8
 #define npyv_reinterpret_s16_u64 npyv_reinterpret_s16_u8
 #define npyv_reinterpret_s16_s64 npyv_reinterpret_s16_u8
-#define npyv_reinterpret_s16_f32 npyv_reinterpret_s16_u8
+#if NPY_SIMD_F32
+    #define npyv_reinterpret_s16_f32 npyv_reinterpret_s16_u8
+#endif
 #define npyv_reinterpret_s16_f64 npyv_reinterpret_s16_u8
 
 #define npyv_reinterpret_u32_u32(X) X
@@ -126,7 +158,9 @@
 #define npyv_reinterpret_u32_s32 npyv_reinterpret_u32_u8
 #define npyv_reinterpret_u32_u64 npyv_reinterpret_u32_u8
 #define npyv_reinterpret_u32_s64 npyv_reinterpret_u32_u8
-#define npyv_reinterpret_u32_f32 npyv_reinterpret_u32_u8
+#if NPY_SIMD_F32
+    #define npyv_reinterpret_u32_f32 npyv_reinterpret_u32_u8
+#endif
 #define npyv_reinterpret_u32_f64 npyv_reinterpret_u32_u8
 
 #define npyv_reinterpret_s32_s32(X) X
@@ -137,7 +171,9 @@
 #define npyv_reinterpret_s32_u32 npyv_reinterpret_s32_u8
 #define npyv_reinterpret_s32_u64 npyv_reinterpret_s32_u8
 #define npyv_reinterpret_s32_s64 npyv_reinterpret_s32_u8
-#define npyv_reinterpret_s32_f32 npyv_reinterpret_s32_u8
+#if NPY_SIMD_F32
+    #define npyv_reinterpret_s32_f32 npyv_reinterpret_s32_u8
+#endif
 #define npyv_reinterpret_s32_f64 npyv_reinterpret_s32_u8
 
 #define npyv_reinterpret_u64_u64(X) X
@@ -148,7 +184,9 @@
 #define npyv_reinterpret_u64_u32 npyv_reinterpret_u64_u8
 #define npyv_reinterpret_u64_s32 npyv_reinterpret_u64_u8
 #define npyv_reinterpret_u64_s64 npyv_reinterpret_u64_u8
-#define npyv_reinterpret_u64_f32 npyv_reinterpret_u64_u8
+#if NPY_SIMD_F32
+    #define npyv_reinterpret_u64_f32 npyv_reinterpret_u64_u8
+#endif
 #define npyv_reinterpret_u64_f64 npyv_reinterpret_u64_u8
 
 #define npyv_reinterpret_s64_s64(X) X
@@ -159,19 +197,23 @@
 #define npyv_reinterpret_s64_u32 npyv_reinterpret_s64_u8
 #define npyv_reinterpret_s64_s32 npyv_reinterpret_s64_u8
 #define npyv_reinterpret_s64_u64 npyv_reinterpret_s64_u8
-#define npyv_reinterpret_s64_f32 npyv_reinterpret_s64_u8
+#if NPY_SIMD_F32
+    #define npyv_reinterpret_s64_f32 npyv_reinterpret_s64_u8
+#endif
 #define npyv_reinterpret_s64_f64 npyv_reinterpret_s64_u8
 
-#define npyv_reinterpret_f32_f32(X) X
-#define npyv_reinterpret_f32_u8(X) ((npyv_f32)X)
-#define npyv_reinterpret_f32_s8  npyv_reinterpret_f32_u8
-#define npyv_reinterpret_f32_u16 npyv_reinterpret_f32_u8
-#define npyv_reinterpret_f32_s16 npyv_reinterpret_f32_u8
-#define npyv_reinterpret_f32_u32 npyv_reinterpret_f32_u8
-#define npyv_reinterpret_f32_s32 npyv_reinterpret_f32_u8
-#define npyv_reinterpret_f32_u64 npyv_reinterpret_f32_u8
-#define npyv_reinterpret_f32_s64 npyv_reinterpret_f32_u8
-#define npyv_reinterpret_f32_f64 npyv_reinterpret_f32_u8
+#if NPY_SIMD_F32
+    #define npyv_reinterpret_f32_f32(X) X
+    #define npyv_reinterpret_f32_u8(X) ((npyv_f32)X)
+    #define npyv_reinterpret_f32_s8  npyv_reinterpret_f32_u8
+    #define npyv_reinterpret_f32_u16 npyv_reinterpret_f32_u8
+    #define npyv_reinterpret_f32_s16 npyv_reinterpret_f32_u8
+    #define npyv_reinterpret_f32_u32 npyv_reinterpret_f32_u8
+    #define npyv_reinterpret_f32_s32 npyv_reinterpret_f32_u8
+    #define npyv_reinterpret_f32_u64 npyv_reinterpret_f32_u8
+    #define npyv_reinterpret_f32_s64 npyv_reinterpret_f32_u8
+    #define npyv_reinterpret_f32_f64 npyv_reinterpret_f32_u8
+#endif
 
 #define npyv_reinterpret_f64_f64(X) X
 #define npyv_reinterpret_f64_u8(X) ((npyv_f64)X)
@@ -182,9 +224,10 @@
 #define npyv_reinterpret_f64_s32 npyv_reinterpret_f64_u8
 #define npyv_reinterpret_f64_u64 npyv_reinterpret_f64_u8
 #define npyv_reinterpret_f64_s64 npyv_reinterpret_f64_u8
-#define npyv_reinterpret_f64_f32 npyv_reinterpret_f64_u8
-
+#if NPY_SIMD_F32
+    #define npyv_reinterpret_f64_f32 npyv_reinterpret_f64_u8
+#endif
 // Only required by AVX2/AVX512
 #define npyv_cleanup() ((void)0)
 
-#endif // _NPY_SIMD_VSX_MISC_H
+#endif // _NPY_SIMD_VEC_MISC_H
diff --git a/numpy/core/src/common/simd/vsx/operators.h b/numpy/core/src/common/simd/vec/operators.h
similarity index 67%
rename from numpy/core/src/common/simd/vsx/operators.h
rename to numpy/core/src/common/simd/vec/operators.h
index d34057ff3f38..50dac20f6d7d 100644
--- a/numpy/core/src/common/simd/vsx/operators.h
+++ b/numpy/core/src/common/simd/vec/operators.h
@@ -2,8 +2,8 @@
     #error "Not a standalone header"
 #endif
 
-#ifndef _NPY_SIMD_VSX_OPERATORS_H
-#define _NPY_SIMD_VSX_OPERATORS_H
+#ifndef _NPY_SIMD_VEC_OPERATORS_H
+#define _NPY_SIMD_VEC_OPERATORS_H
 
 /***************************
  * Shifting
@@ -11,11 +11,11 @@
 
 // Left
 #define npyv_shl_u16(A, C) vec_sl(A, npyv_setall_u16(C))
-#define npyv_shl_s16(A, C) vec_sl(A, npyv_setall_u16(C))
+#define npyv_shl_s16(A, C) vec_sl_s16(A, npyv_setall_u16(C))
 #define npyv_shl_u32(A, C) vec_sl(A, npyv_setall_u32(C))
-#define npyv_shl_s32(A, C) vec_sl(A, npyv_setall_u32(C))
+#define npyv_shl_s32(A, C) vec_sl_s32(A, npyv_setall_u32(C))
 #define npyv_shl_u64(A, C) vec_sl(A, npyv_setall_u64(C))
-#define npyv_shl_s64(A, C) vec_sl(A, npyv_setall_u64(C))
+#define npyv_shl_s64(A, C) vec_sl_s64(A, npyv_setall_u64(C))
 
 // Left by an immediate constant
 #define npyv_shli_u16 npyv_shl_u16
@@ -27,11 +27,11 @@
 
 // Right
 #define npyv_shr_u16(A, C) vec_sr(A,  npyv_setall_u16(C))
-#define npyv_shr_s16(A, C) vec_sra(A, npyv_setall_u16(C))
+#define npyv_shr_s16(A, C) vec_sra_s16(A, npyv_setall_u16(C))
 #define npyv_shr_u32(A, C) vec_sr(A,  npyv_setall_u32(C))
-#define npyv_shr_s32(A, C) vec_sra(A, npyv_setall_u32(C))
+#define npyv_shr_s32(A, C) vec_sra_s32(A, npyv_setall_u32(C))
 #define npyv_shr_u64(A, C) vec_sr(A,  npyv_setall_u64(C))
-#define npyv_shr_s64(A, C) vec_sra(A, npyv_setall_u64(C))
+#define npyv_shr_s64(A, C) vec_sra_s64(A, npyv_setall_u64(C))
 
 // Right by an immediate constant
 #define npyv_shri_u16 npyv_shr_u16
@@ -44,15 +44,15 @@
 /***************************
  * Logical
  ***************************/
-#define NPYV_IMPL_VSX_BIN_CAST(INTRIN, SFX, CAST) \
+#define NPYV_IMPL_VEC_BIN_CAST(INTRIN, SFX, CAST) \
     NPY_FINLINE npyv_##SFX npyv_##INTRIN##_##SFX(npyv_##SFX a, npyv_##SFX b) \
     { return (npyv_##SFX)vec_##INTRIN((CAST)a, (CAST)b); }
 
 // Up to GCC 6 logical intrinsics don't support bool long long
 #if defined(__GNUC__) && __GNUC__ <= 6
-    #define NPYV_IMPL_VSX_BIN_B64(INTRIN) NPYV_IMPL_VSX_BIN_CAST(INTRIN, b64, npyv_u64)
+    #define NPYV_IMPL_VEC_BIN_B64(INTRIN) NPYV_IMPL_VEC_BIN_CAST(INTRIN, b64, npyv_u64)
 #else
-    #define NPYV_IMPL_VSX_BIN_B64(INTRIN) NPYV_IMPL_VSX_BIN_CAST(INTRIN, b64, npyv_b64)
+    #define NPYV_IMPL_VEC_BIN_B64(INTRIN) NPYV_IMPL_VEC_BIN_CAST(INTRIN, b64, npyv_b64)
 #endif
 // AND
 #define npyv_and_u8  vec_and
@@ -63,12 +63,14 @@
 #define npyv_and_s32 vec_and
 #define npyv_and_u64 vec_and
 #define npyv_and_s64 vec_and
-#define npyv_and_f32 vec_and
+#if NPY_SIMD_F32
+    #define npyv_and_f32 vec_and
+#endif
 #define npyv_and_f64 vec_and
 #define npyv_and_b8  vec_and
 #define npyv_and_b16 vec_and
 #define npyv_and_b32 vec_and
-NPYV_IMPL_VSX_BIN_B64(and)
+NPYV_IMPL_VEC_BIN_B64(and)
 
 // OR
 #define npyv_or_u8  vec_or
@@ -79,12 +81,14 @@ NPYV_IMPL_VSX_BIN_B64(and)
 #define npyv_or_s32 vec_or
 #define npyv_or_u64 vec_or
 #define npyv_or_s64 vec_or
-#define npyv_or_f32 vec_or
+#if NPY_SIMD_F32
+    #define npyv_or_f32 vec_or
+#endif
 #define npyv_or_f64 vec_or
 #define npyv_or_b8  vec_or
 #define npyv_or_b16 vec_or
 #define npyv_or_b32 vec_or
-NPYV_IMPL_VSX_BIN_B64(or)
+NPYV_IMPL_VEC_BIN_B64(or)
 
 // XOR
 #define npyv_xor_u8  vec_xor
@@ -95,16 +99,18 @@ NPYV_IMPL_VSX_BIN_B64(or)
 #define npyv_xor_s32 vec_xor
 #define npyv_xor_u64 vec_xor
 #define npyv_xor_s64 vec_xor
-#define npyv_xor_f32 vec_xor
+#if NPY_SIMD_F32
+    #define npyv_xor_f32 vec_xor
+#endif
 #define npyv_xor_f64 vec_xor
 #define npyv_xor_b8  vec_xor
 #define npyv_xor_b16 vec_xor
 #define npyv_xor_b32 vec_xor
-NPYV_IMPL_VSX_BIN_B64(xor)
+NPYV_IMPL_VEC_BIN_B64(xor)
 
 // NOT
 // note: we implement npyv_not_b*(boolean types) for internal use*/
-#define NPYV_IMPL_VSX_NOT_INT(VEC_LEN)                                 \
+#define NPYV_IMPL_VEC_NOT_INT(VEC_LEN)                                 \
     NPY_FINLINE npyv_u##VEC_LEN npyv_not_u##VEC_LEN(npyv_u##VEC_LEN a) \
     { return vec_nor(a, a); }                                          \
     NPY_FINLINE npyv_s##VEC_LEN npyv_not_s##VEC_LEN(npyv_s##VEC_LEN a) \
@@ -112,13 +118,13 @@ NPYV_IMPL_VSX_BIN_B64(xor)
     NPY_FINLINE npyv_b##VEC_LEN npyv_not_b##VEC_LEN(npyv_b##VEC_LEN a) \
     { return vec_nor(a, a); }
 
-NPYV_IMPL_VSX_NOT_INT(8)
-NPYV_IMPL_VSX_NOT_INT(16)
-NPYV_IMPL_VSX_NOT_INT(32)
+NPYV_IMPL_VEC_NOT_INT(8)
+NPYV_IMPL_VEC_NOT_INT(16)
+NPYV_IMPL_VEC_NOT_INT(32)
 
-// up to gcc5 vec_nor doesn't support bool long long
-#if defined(__GNUC__) && __GNUC__ > 5
-    NPYV_IMPL_VSX_NOT_INT(64)
+// on ppc64, up to gcc5 vec_nor doesn't support bool long long
+#if defined(NPY_HAVE_VSX) && defined(__GNUC__) && __GNUC__ > 5
+    NPYV_IMPL_VEC_NOT_INT(64)
 #else
     NPY_FINLINE npyv_u64 npyv_not_u64(npyv_u64 a)
     { return vec_nor(a, a); }
@@ -128,11 +134,24 @@ NPYV_IMPL_VSX_NOT_INT(32)
     { return (npyv_b64)vec_nor((npyv_u64)a, (npyv_u64)a); }
 #endif
 
-NPY_FINLINE npyv_f32 npyv_not_f32(npyv_f32 a)
-{ return vec_nor(a, a); }
+#if NPY_SIMD_F32
+    NPY_FINLINE npyv_f32 npyv_not_f32(npyv_f32 a)
+    { return vec_nor(a, a); }
+#endif
 NPY_FINLINE npyv_f64 npyv_not_f64(npyv_f64 a)
 { return vec_nor(a, a); }
 
+// ANDC, ORC and XNOR
+#define npyv_andc_u8 vec_andc
+#define npyv_andc_b8 vec_andc
+#if defined(NPY_HAVE_VXE) || defined(NPY_HAVE_VSX)
+    #define npyv_orc_b8 vec_orc
+    #define npyv_xnor_b8 vec_eqv
+#else
+    #define npyv_orc_b8(A, B) npyv_or_b8(npyv_not_b8(B), A)
+    #define npyv_xnor_b8(A, B) npyv_not_b8(npyv_xor_b8(B, A))
+#endif
+
 /***************************
  * Comparison
  ***************************/
@@ -146,7 +165,9 @@ NPY_FINLINE npyv_f64 npyv_not_f64(npyv_f64 a)
 #define npyv_cmpeq_s32 vec_cmpeq
 #define npyv_cmpeq_u64 vec_cmpeq
 #define npyv_cmpeq_s64 vec_cmpeq
-#define npyv_cmpeq_f32 vec_cmpeq
+#if NPY_SIMD_F32
+    #define npyv_cmpeq_f32 vec_cmpeq
+#endif
 #define npyv_cmpeq_f64 vec_cmpeq
 
 // Int Not Equal
@@ -171,7 +192,9 @@ NPY_FINLINE npyv_f64 npyv_not_f64(npyv_f64 a)
     #define npyv_cmpneq_s32(A, B) npyv_not_b32(vec_cmpeq(A, B))
     #define npyv_cmpneq_u64(A, B) npyv_not_b64(vec_cmpeq(A, B))
     #define npyv_cmpneq_s64(A, B) npyv_not_b64(vec_cmpeq(A, B))
-    #define npyv_cmpneq_f32(A, B) npyv_not_b32(vec_cmpeq(A, B))
+    #if NPY_SIMD_F32
+        #define npyv_cmpneq_f32(A, B) npyv_not_b32(vec_cmpeq(A, B))
+    #endif
     #define npyv_cmpneq_f64(A, B) npyv_not_b64(vec_cmpeq(A, B))
 #endif
 
@@ -184,12 +207,14 @@ NPY_FINLINE npyv_f64 npyv_not_f64(npyv_f64 a)
 #define npyv_cmpgt_s32 vec_cmpgt
 #define npyv_cmpgt_u64 vec_cmpgt
 #define npyv_cmpgt_s64 vec_cmpgt
-#define npyv_cmpgt_f32 vec_cmpgt
+#if NPY_SIMD_F32
+    #define npyv_cmpgt_f32 vec_cmpgt
+#endif
 #define npyv_cmpgt_f64 vec_cmpgt
 
 // Greater than or equal
-// up to gcc5 vec_cmpge only supports single and double precision
-#if defined(__GNUC__) && __GNUC__ > 5
+// On ppc64le, up to gcc5 vec_cmpge only supports single and double precision
+#if defined(NPY_HAVE_VX) || (defined(__GNUC__) && __GNUC__ > 5)
     #define npyv_cmpge_u8  vec_cmpge
     #define npyv_cmpge_s8  vec_cmpge
     #define npyv_cmpge_u16 vec_cmpge
@@ -208,7 +233,9 @@ NPY_FINLINE npyv_f64 npyv_not_f64(npyv_f64 a)
     #define npyv_cmpge_u64(A, B) npyv_not_b64(vec_cmpgt(B, A))
     #define npyv_cmpge_s64(A, B) npyv_not_b64(vec_cmpgt(B, A))
 #endif
-#define npyv_cmpge_f32 vec_cmpge
+#if NPY_SIMD_F32
+    #define npyv_cmpge_f32 vec_cmpge
+#endif
 #define npyv_cmpge_f64 vec_cmpge
 
 // Less than
@@ -220,7 +247,9 @@ NPY_FINLINE npyv_f64 npyv_not_f64(npyv_f64 a)
 #define npyv_cmplt_s32(A, B) npyv_cmpgt_s32(B, A)
 #define npyv_cmplt_u64(A, B) npyv_cmpgt_u64(B, A)
 #define npyv_cmplt_s64(A, B) npyv_cmpgt_s64(B, A)
-#define npyv_cmplt_f32(A, B) npyv_cmpgt_f32(B, A)
+#if NPY_SIMD_F32
+    #define npyv_cmplt_f32(A, B) npyv_cmpgt_f32(B, A)
+#endif
 #define npyv_cmplt_f64(A, B) npyv_cmpgt_f64(B, A)
 
 // Less than or equal
@@ -232,13 +261,43 @@ NPY_FINLINE npyv_f64 npyv_not_f64(npyv_f64 a)
 #define npyv_cmple_s32(A, B) npyv_cmpge_s32(B, A)
 #define npyv_cmple_u64(A, B) npyv_cmpge_u64(B, A)
 #define npyv_cmple_s64(A, B) npyv_cmpge_s64(B, A)
-#define npyv_cmple_f32(A, B) npyv_cmpge_f32(B, A)
+#if NPY_SIMD_F32
+    #define npyv_cmple_f32(A, B) npyv_cmpge_f32(B, A)
+#endif
 #define npyv_cmple_f64(A, B) npyv_cmpge_f64(B, A)
 
 // check special cases
-NPY_FINLINE npyv_b32 npyv_notnan_f32(npyv_f32 a)
-{ return vec_cmpeq(a, a); }
+#if NPY_SIMD_F32
+    NPY_FINLINE npyv_b32 npyv_notnan_f32(npyv_f32 a)
+    { return vec_cmpeq(a, a); }
+#endif
 NPY_FINLINE npyv_b64 npyv_notnan_f64(npyv_f64 a)
 { return vec_cmpeq(a, a); }
 
-#endif // _NPY_SIMD_VSX_OPERATORS_H
+// Test cross all vector lanes
+// any: returns true if any of the elements is not equal to zero
+// all: returns true if all elements are not equal to zero
+#define NPYV_IMPL_VEC_ANYALL(SFX, SFX2)                       \
+    NPY_FINLINE bool npyv_any_##SFX(npyv_##SFX a)             \
+    { return vec_any_ne(a, (npyv_##SFX)npyv_zero_##SFX2()); } \
+    NPY_FINLINE bool npyv_all_##SFX(npyv_##SFX a)             \
+    { return vec_all_ne(a, (npyv_##SFX)npyv_zero_##SFX2()); }
+NPYV_IMPL_VEC_ANYALL(b8,  u8)
+NPYV_IMPL_VEC_ANYALL(b16, u16)
+NPYV_IMPL_VEC_ANYALL(b32, u32)
+NPYV_IMPL_VEC_ANYALL(b64, u64)
+NPYV_IMPL_VEC_ANYALL(u8,  u8)
+NPYV_IMPL_VEC_ANYALL(s8,  s8)
+NPYV_IMPL_VEC_ANYALL(u16, u16)
+NPYV_IMPL_VEC_ANYALL(s16, s16)
+NPYV_IMPL_VEC_ANYALL(u32, u32)
+NPYV_IMPL_VEC_ANYALL(s32, s32)
+NPYV_IMPL_VEC_ANYALL(u64, u64)
+NPYV_IMPL_VEC_ANYALL(s64, s64)
+#if NPY_SIMD_F32
+    NPYV_IMPL_VEC_ANYALL(f32, f32)
+#endif
+NPYV_IMPL_VEC_ANYALL(f64, f64)
+#undef NPYV_IMPL_VEC_ANYALL
+
+#endif // _NPY_SIMD_VEC_OPERATORS_H
diff --git a/numpy/core/src/common/simd/vsx/reorder.h b/numpy/core/src/common/simd/vec/reorder.h
similarity index 79%
rename from numpy/core/src/common/simd/vsx/reorder.h
rename to numpy/core/src/common/simd/vec/reorder.h
index 6533e50933d2..b60b9287dcde 100644
--- a/numpy/core/src/common/simd/vsx/reorder.h
+++ b/numpy/core/src/common/simd/vec/reorder.h
@@ -2,8 +2,8 @@
     #error "Not a standalone header"
 #endif
 
-#ifndef _NPY_SIMD_VSX_REORDER_H
-#define _NPY_SIMD_VSX_REORDER_H
+#ifndef _NPY_SIMD_VEC_REORDER_H
+#define _NPY_SIMD_VEC_REORDER_H
 
 // combine lower part of two vectors
 #define npyv__combinel(A, B) vec_mergeh((npyv_u64)(A), (npyv_u64)(B))
@@ -15,7 +15,9 @@
 #define npyv_combinel_s32(A, B) ((npyv_s32)npyv__combinel(A, B))
 #define npyv_combinel_u64       vec_mergeh
 #define npyv_combinel_s64       vec_mergeh
-#define npyv_combinel_f32(A, B) ((npyv_f32)npyv__combinel(A, B))
+#if NPY_SIMD_F32
+    #define npyv_combinel_f32(A, B) ((npyv_f32)npyv__combinel(A, B))
+#endif
 #define npyv_combinel_f64       vec_mergeh
 
 // combine higher part of two vectors
@@ -28,14 +30,16 @@
 #define npyv_combineh_s32(A, B) ((npyv_s32)npyv__combineh(A, B))
 #define npyv_combineh_u64       vec_mergel
 #define npyv_combineh_s64       vec_mergel
-#define npyv_combineh_f32(A, B) ((npyv_f32)npyv__combineh(A, B))
+#if NPY_SIMD_F32
+    #define npyv_combineh_f32(A, B) ((npyv_f32)npyv__combineh(A, B))
+#endif
 #define npyv_combineh_f64       vec_mergel
 
 /*
  * combine: combine two vectors from lower and higher parts of two other vectors
  * zip: interleave two vectors
 */
-#define NPYV_IMPL_VSX_COMBINE_ZIP(T_VEC, SFX)                  \
+#define NPYV_IMPL_VEC_COMBINE_ZIP(T_VEC, SFX)                  \
     NPY_FINLINE T_VEC##x2 npyv_combine_##SFX(T_VEC a, T_VEC b) \
     {                                                          \
         T_VEC##x2 r;                                           \
@@ -51,16 +55,18 @@
         return r;                                              \
     }
 
-NPYV_IMPL_VSX_COMBINE_ZIP(npyv_u8,  u8)
-NPYV_IMPL_VSX_COMBINE_ZIP(npyv_s8,  s8)
-NPYV_IMPL_VSX_COMBINE_ZIP(npyv_u16, u16)
-NPYV_IMPL_VSX_COMBINE_ZIP(npyv_s16, s16)
-NPYV_IMPL_VSX_COMBINE_ZIP(npyv_u32, u32)
-NPYV_IMPL_VSX_COMBINE_ZIP(npyv_s32, s32)
-NPYV_IMPL_VSX_COMBINE_ZIP(npyv_u64, u64)
-NPYV_IMPL_VSX_COMBINE_ZIP(npyv_s64, s64)
-NPYV_IMPL_VSX_COMBINE_ZIP(npyv_f32, f32)
-NPYV_IMPL_VSX_COMBINE_ZIP(npyv_f64, f64)
+NPYV_IMPL_VEC_COMBINE_ZIP(npyv_u8,  u8)
+NPYV_IMPL_VEC_COMBINE_ZIP(npyv_s8,  s8)
+NPYV_IMPL_VEC_COMBINE_ZIP(npyv_u16, u16)
+NPYV_IMPL_VEC_COMBINE_ZIP(npyv_s16, s16)
+NPYV_IMPL_VEC_COMBINE_ZIP(npyv_u32, u32)
+NPYV_IMPL_VEC_COMBINE_ZIP(npyv_s32, s32)
+NPYV_IMPL_VEC_COMBINE_ZIP(npyv_u64, u64)
+NPYV_IMPL_VEC_COMBINE_ZIP(npyv_s64, s64)
+#if NPY_SIMD_F32
+    NPYV_IMPL_VEC_COMBINE_ZIP(npyv_f32, f32)
+#endif
+NPYV_IMPL_VEC_COMBINE_ZIP(npyv_f64, f64)
 
 // Reverse elements of each 64-bit lane
 NPY_FINLINE npyv_u8 npyv_rev64_u8(npyv_u8 a)
@@ -100,7 +106,9 @@ NPY_FINLINE npyv_u32 npyv_rev64_u32(npyv_u32 a)
 }
 NPY_FINLINE npyv_s32 npyv_rev64_s32(npyv_s32 a)
 { return (npyv_s32)npyv_rev64_u32((npyv_u32)a); }
-NPY_FINLINE npyv_f32 npyv_rev64_f32(npyv_f32 a)
-{ return (npyv_f32)npyv_rev64_u32((npyv_u32)a); }
+#if NPY_SIMD_F32
+    NPY_FINLINE npyv_f32 npyv_rev64_f32(npyv_f32 a)
+    { return (npyv_f32)npyv_rev64_u32((npyv_u32)a); }
+#endif
 
-#endif // _NPY_SIMD_VSX_REORDER_H
+#endif // _NPY_SIMD_VEC_REORDER_H
diff --git a/numpy/core/src/common/simd/vec/utils.h b/numpy/core/src/common/simd/vec/utils.h
new file mode 100644
index 000000000000..f8b28cfebd8c
--- /dev/null
+++ b/numpy/core/src/common/simd/vec/utils.h
@@ -0,0 +1,84 @@
+#ifndef NPY_SIMD
+    #error "Not a standalone header"
+#endif
+
+#ifndef _NPY_SIMD_VEC_UTILS_H
+#define _NPY_SIMD_VEC_UTILS_H
+
+// the following intrinsics may not some|all by zvector API on gcc/clang
+#ifdef NPY_HAVE_VX
+    #ifndef vec_neg
+        #define vec_neg(a) (-(a)) // Vector Negate
+    #endif
+    #ifndef vec_add
+        #define vec_add(a, b) ((a) + (b)) // Vector Add
+    #endif
+    #ifndef vec_sub
+        #define vec_sub(a, b) ((a) - (b)) // Vector Subtract
+    #endif
+    #ifndef vec_mul
+        #define vec_mul(a, b) ((a) * (b)) // Vector Multiply
+    #endif
+    #ifndef vec_div
+        #define vec_div(a, b) ((a) / (b)) // Vector Divide
+    #endif
+    #ifndef vec_neg
+        #define vec_neg(a) (-(a))
+    #endif
+    #ifndef vec_and
+        #define vec_and(a, b) ((a) & (b)) // Vector AND
+    #endif
+    #ifndef vec_or
+        #define vec_or(a, b) ((a) | (b)) // Vector OR
+    #endif
+    #ifndef vec_xor
+        #define vec_xor(a, b) ((a) ^ (b)) // Vector XOR
+    #endif
+    #ifndef vec_sl
+        #define vec_sl(a, b) ((a) << (b)) // Vector Shift Left
+    #endif
+    #ifndef vec_sra
+        #define vec_sra(a, b) ((a) >> (b)) // Vector Shift Right
+    #endif
+    #ifndef vec_sr
+        #define vec_sr(a, b) ((a) >> (b)) // Vector Shift Right Algebraic
+    #endif
+    #ifndef vec_slo
+        #define vec_slo(a, b) vec_slb(a, (b) << 64) // Vector Shift Left by Octet
+    #endif
+    #ifndef vec_sro
+        #define vec_sro(a, b) vec_srb(a, (b) << 64) // Vector Shift Right by Octet
+    #endif
+    // vec_doublee maps to wrong intrin "vfll".
+    // see https://gcc.gnu.org/bugzilla/show_bug.cgi?id=100871
+    #if defined(__GNUC__) && !defined(__clang__)
+        #define npyv_doublee __builtin_s390_vflls
+    #else
+        #define npyv_doublee vec_doublee
+    #endif
+    // compatibility with vsx
+    #ifndef vec_vbpermq
+        #define vec_vbpermq vec_bperm_u128
+    #endif
+    // zvector requires second operand to signed while vsx api expected to be
+    // unsigned, the following macros are set to remove this conflict
+    #define vec_sl_s8(a, b)   vec_sl(a, (npyv_s8)(b))
+    #define vec_sl_s16(a, b)  vec_sl(a, (npyv_s16)(b))
+    #define vec_sl_s32(a, b)  vec_sl(a, (npyv_s32)(b))
+    #define vec_sl_s64(a, b)  vec_sl(a, (npyv_s64)(b))
+    #define vec_sra_s8(a, b)  vec_sra(a, (npyv_s8)(b))
+    #define vec_sra_s16(a, b) vec_sra(a, (npyv_s16)(b))
+    #define vec_sra_s32(a, b) vec_sra(a, (npyv_s32)(b))
+    #define vec_sra_s64(a, b) vec_sra(a, (npyv_s64)(b))
+#else
+    #define vec_sl_s8 vec_sl
+    #define vec_sl_s16 vec_sl
+    #define vec_sl_s32 vec_sl
+    #define vec_sl_s64 vec_sl
+    #define vec_sra_s8 vec_sra
+    #define vec_sra_s16 vec_sra
+    #define vec_sra_s32 vec_sra
+    #define vec_sra_s64 vec_sra
+#endif
+
+#endif // _NPY_SIMD_VEC_UTILS_H
diff --git a/numpy/core/src/common/simd/vsx/vsx.h b/numpy/core/src/common/simd/vec/vec.h
similarity index 73%
rename from numpy/core/src/common/simd/vsx/vsx.h
rename to numpy/core/src/common/simd/vec/vec.h
index 66b76208f042..1d4508669286 100644
--- a/numpy/core/src/common/simd/vsx/vsx.h
+++ b/numpy/core/src/common/simd/vec/vec.h
@@ -1,7 +1,22 @@
+/**
+ * branch /vec(altivec-like) provides the SIMD operations for
+ * both IBM VSX(Power) and VX(ZArch).
+*/
 #ifndef _NPY_SIMD_H_
     #error "Not a standalone header"
 #endif
 
+#if !defined(NPY_HAVE_VX) && !defined(NPY_HAVE_VSX2)
+    #error "require minimum support VX(zarch11) or VSX2(Power8/ISA2.07)"
+#endif
+
+#if defined(NPY_HAVE_VSX) && !defined(__LITTLE_ENDIAN__)
+    #error "VSX support doesn't cover big-endian mode yet, only zarch."
+#endif
+#if defined(NPY_HAVE_VX) && defined(__LITTLE_ENDIAN__)
+    #error "VX(zarch) support doesn't cover little-endian mode."
+#endif
+
 #if defined(__GNUC__) && __GNUC__ <= 7
     /**
       * GCC <= 7 produces ambiguous warning caused by -Werror=maybe-uninitialized,
@@ -15,8 +30,21 @@
 #define NPY_SIMD 128
 #define NPY_SIMD_WIDTH 16
 #define NPY_SIMD_F64 1
+#if defined(NPY_HAVE_VXE) || defined(NPY_HAVE_VSX)
+    #define NPY_SIMD_F32 1
+#else
+    #define NPY_SIMD_F32 0
+#endif
 #define NPY_SIMD_FMA3 1 // native support
 
+#ifdef NPY_HAVE_VX
+    #define NPY_SIMD_BIGENDIAN 1
+    #define NPY_SIMD_CMPSIGNAL 0
+#else
+    #define NPY_SIMD_BIGENDIAN 0
+    #define NPY_SIMD_CMPSIGNAL 1
+#endif
+
 typedef __vector unsigned char      npyv_u8;
 typedef __vector signed char        npyv_s8;
 typedef __vector unsigned short     npyv_u16;
@@ -25,7 +53,9 @@ typedef __vector unsigned int       npyv_u32;
 typedef __vector signed int         npyv_s32;
 typedef __vector unsigned long long npyv_u64;
 typedef __vector signed long long   npyv_s64;
+#if NPY_SIMD_F32
 typedef __vector float              npyv_f32;
+#endif
 typedef __vector double             npyv_f64;
 
 typedef struct { npyv_u8  val[2]; } npyv_u8x2;
@@ -36,7 +66,9 @@ typedef struct { npyv_u32 val[2]; } npyv_u32x2;
 typedef struct { npyv_s32 val[2]; } npyv_s32x2;
 typedef struct { npyv_u64 val[2]; } npyv_u64x2;
 typedef struct { npyv_s64 val[2]; } npyv_s64x2;
+#if NPY_SIMD_F32
 typedef struct { npyv_f32 val[2]; } npyv_f32x2;
+#endif
 typedef struct { npyv_f64 val[2]; } npyv_f64x2;
 
 typedef struct { npyv_u8  val[3]; } npyv_u8x3;
@@ -47,7 +79,9 @@ typedef struct { npyv_u32 val[3]; } npyv_u32x3;
 typedef struct { npyv_s32 val[3]; } npyv_s32x3;
 typedef struct { npyv_u64 val[3]; } npyv_u64x3;
 typedef struct { npyv_s64 val[3]; } npyv_s64x3;
+#if NPY_SIMD_F32
 typedef struct { npyv_f32 val[3]; } npyv_f32x3;
+#endif
 typedef struct { npyv_f64 val[3]; } npyv_f64x3;
 
 #define npyv_nlanes_u8  16
@@ -61,12 +95,13 @@ typedef struct { npyv_f64 val[3]; } npyv_f64x3;
 #define npyv_nlanes_f32 4
 #define npyv_nlanes_f64 2
 
-// using __bool with typdef cause ambiguous errors
+// using __bool with typedef cause ambiguous errors
 #define npyv_b8  __vector __bool char
 #define npyv_b16 __vector __bool short
 #define npyv_b32 __vector __bool int
 #define npyv_b64 __vector __bool long long
 
+#include "utils.h"
 #include "memory.h"
 #include "misc.h"
 #include "reorder.h"
diff --git a/numpy/core/src/common/simd/vsx/conversion.h b/numpy/core/src/common/simd/vsx/conversion.h
deleted file mode 100644
index 36bea7bbaddf..000000000000
--- a/numpy/core/src/common/simd/vsx/conversion.h
+++ /dev/null
@@ -1,123 +0,0 @@
-#ifndef NPY_SIMD
-    #error "Not a standalone header"
-#endif
-
-#ifndef _NPY_SIMD_VSX_CVT_H
-#define _NPY_SIMD_VSX_CVT_H
-
-// convert boolean vectors to integer vectors
-#define npyv_cvt_u8_b8(BL)   ((npyv_u8)  BL)
-#define npyv_cvt_s8_b8(BL)   ((npyv_s8)  BL)
-#define npyv_cvt_u16_b16(BL) ((npyv_u16) BL)
-#define npyv_cvt_s16_b16(BL) ((npyv_s16) BL)
-#define npyv_cvt_u32_b32(BL) ((npyv_u32) BL)
-#define npyv_cvt_s32_b32(BL) ((npyv_s32) BL)
-#define npyv_cvt_u64_b64(BL) ((npyv_u64) BL)
-#define npyv_cvt_s64_b64(BL) ((npyv_s64) BL)
-#define npyv_cvt_f32_b32(BL) ((npyv_f32) BL)
-#define npyv_cvt_f64_b64(BL) ((npyv_f64) BL)
-
-// convert integer vectors to boolean vectors
-#define npyv_cvt_b8_u8(A)   ((npyv_b8)  A)
-#define npyv_cvt_b8_s8(A)   ((npyv_b8)  A)
-#define npyv_cvt_b16_u16(A) ((npyv_b16) A)
-#define npyv_cvt_b16_s16(A) ((npyv_b16) A)
-#define npyv_cvt_b32_u32(A) ((npyv_b32) A)
-#define npyv_cvt_b32_s32(A) ((npyv_b32) A)
-#define npyv_cvt_b64_u64(A) ((npyv_b64) A)
-#define npyv_cvt_b64_s64(A) ((npyv_b64) A)
-#define npyv_cvt_b32_f32(A) ((npyv_b32) A)
-#define npyv_cvt_b64_f64(A) ((npyv_b64) A)
-
-//expand
-NPY_FINLINE npyv_u16x2 npyv_expand_u16_u8(npyv_u8 data)
-{
-    npyv_u16x2 r;
-    npyv_u8 zero = npyv_zero_u8();
-    r.val[0] = (npyv_u16)vec_mergeh(data, zero);
-    r.val[1] = (npyv_u16)vec_mergel(data, zero);
-    return r;
-}
-
-NPY_FINLINE npyv_u32x2 npyv_expand_u32_u16(npyv_u16 data)
-{
-    npyv_u32x2 r;
-    npyv_u16 zero = npyv_zero_u16();
-    r.val[0] = (npyv_u32)vec_mergeh(data, zero);
-    r.val[1] = (npyv_u32)vec_mergel(data, zero);
-    return r;
-}
-
-// convert boolean vector to integer bitfield
-NPY_FINLINE npy_uint64 npyv_tobits_b8(npyv_b8 a)
-{
-    const npyv_u8 qperm = npyv_set_u8(120, 112, 104, 96, 88, 80, 72, 64, 56, 48, 40, 32, 24, 16, 8, 0);
-    return vec_extract((npyv_u32)vec_vbpermq((npyv_u8)a, qperm), 2);
-}
-NPY_FINLINE npy_uint64 npyv_tobits_b16(npyv_b16 a)
-{
-    const npyv_u8 qperm = npyv_setf_u8(128, 112, 96, 80, 64, 48, 32, 16, 0);
-    return vec_extract((npyv_u32)vec_vbpermq((npyv_u8)a, qperm), 2);
-}
-NPY_FINLINE npy_uint64 npyv_tobits_b32(npyv_b32 a)
-{
-    const npyv_u8 qperm = npyv_setf_u8(128, 96, 64, 32, 0);
-    return vec_extract((npyv_u32)vec_vbpermq((npyv_u8)a, qperm), 2);
-}
-NPY_FINLINE npy_uint64 npyv_tobits_b64(npyv_b64 a)
-{
-    npyv_u64 bit = npyv_shri_u64((npyv_u64)a, 63);
-    return vec_extract(bit, 0) | (int)vec_extract(bit, 1) << 1;
-}
-
-// truncate compatible with all compilers(internal use for now)
-NPY_FINLINE npyv_s32 npyv__trunc_s32_f32(npyv_f32 a)
-{
-#ifdef __IBMC__
-    return vec_cts(a, 0);
-#elif defined(__clang__)
-    /**
-     * old versions of CLANG doesn't support %x in the inline asm template
-     * which fixes register number when using any of the register constraints wa, wd, wf.
-     * therefore, we count on built-in functions.
-     */
-    return __builtin_convertvector(a, npyv_s32);
-#else // gcc
-    npyv_s32 ret;
-    __asm__ ("xvcvspsxws %x0,%x1" : "=wa" (ret) : "wa" (a));
-    return ret;
-#endif
-}
-NPY_FINLINE npyv_s32 npyv__trunc_s32_f64(npyv_f64 a, npyv_f64 b)
-{
-#ifdef __IBMC__
-    const npyv_u8 seq_even = npyv_set_u8(0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27);
-    // unfortunately, XLC missing asm register vsx fixer
-    // hopefully, xlc can optimize around big-endian compatibility
-    npyv_s32 lo_even = vec_cts(a, 0);
-    npyv_s32 hi_even = vec_cts(b, 0);
-    return vec_perm(lo_even, hi_even, seq_even);
-#else
-    const npyv_u8 seq_odd = npyv_set_u8(4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23, 28, 29, 30, 31);
-    #ifdef __clang__
-        // __builtin_convertvector doesn't support this conversion on wide range of versions
-        // fortunately, almost all versions have direct builtin of 'xvcvdpsxws'
-        npyv_s32 lo_odd = __builtin_vsx_xvcvdpsxws(a);
-        npyv_s32 hi_odd = __builtin_vsx_xvcvdpsxws(b);
-    #else // gcc
-        npyv_s32 lo_odd, hi_odd;
-        __asm__ ("xvcvdpsxws %x0,%x1" : "=wa" (lo_odd) : "wa" (a));
-        __asm__ ("xvcvdpsxws %x0,%x1" : "=wa" (hi_odd) : "wa" (b));
-    #endif
-    return vec_perm(lo_odd, hi_odd, seq_odd);
-#endif
-}
-
-// round to nearest integer (assuming even)
-NPY_FINLINE npyv_s32 npyv_round_s32_f32(npyv_f32 a)
-{ return npyv__trunc_s32_f32(vec_rint(a)); }
-
-NPY_FINLINE npyv_s32 npyv_round_s32_f64(npyv_f64 a, npyv_f64 b)
-{ return npyv__trunc_s32_f64(vec_rint(a), vec_rint(b)); }
-
-#endif // _NPY_SIMD_VSX_CVT_H
diff --git a/numpy/core/src/common/simd/vsx/math.h b/numpy/core/src/common/simd/vsx/math.h
deleted file mode 100644
index d138cae8a24d..000000000000
--- a/numpy/core/src/common/simd/vsx/math.h
+++ /dev/null
@@ -1,80 +0,0 @@
-#ifndef NPY_SIMD
-    #error "Not a standalone header"
-#endif
-
-#ifndef _NPY_SIMD_VSX_MATH_H
-#define _NPY_SIMD_VSX_MATH_H
-/***************************
- * Elementary
- ***************************/
-// Square root
-#define npyv_sqrt_f32 vec_sqrt
-#define npyv_sqrt_f64 vec_sqrt
-
-// Reciprocal
-NPY_FINLINE npyv_f32 npyv_recip_f32(npyv_f32 a)
-{
-    const npyv_f32 one = npyv_setall_f32(1.0f);
-    return vec_div(one, a);
-}
-NPY_FINLINE npyv_f64 npyv_recip_f64(npyv_f64 a)
-{
-    const npyv_f64 one = npyv_setall_f64(1.0);
-    return vec_div(one, a);
-}
-
-// Absolute
-#define npyv_abs_f32 vec_abs
-#define npyv_abs_f64 vec_abs
-
-// Square
-NPY_FINLINE npyv_f32 npyv_square_f32(npyv_f32 a)
-{ return vec_mul(a, a); }
-NPY_FINLINE npyv_f64 npyv_square_f64(npyv_f64 a)
-{ return vec_mul(a, a); }
-
-// Maximum, natively mapping with no guarantees to handle NaN.
-#define npyv_max_f32 vec_max
-#define npyv_max_f64 vec_max
-// Maximum, supports IEEE floating-point arithmetic (IEC 60559),
-// - If one of the two vectors contains NaN, the equivalent element of the other vector is set
-// - Only if both corresponded elements are NaN, NaN is set. 
-#define npyv_maxp_f32 vec_max
-#define npyv_maxp_f64 vec_max
-// Maximum, integer operations
-#define npyv_max_u8 vec_max
-#define npyv_max_s8 vec_max
-#define npyv_max_u16 vec_max
-#define npyv_max_s16 vec_max
-#define npyv_max_u32 vec_max
-#define npyv_max_s32 vec_max
-#define npyv_max_u64 vec_max
-#define npyv_max_s64 vec_max
-
-// Minimum, natively mapping with no guarantees to handle NaN.
-#define npyv_min_f32 vec_min
-#define npyv_min_f64 vec_min
-// Minimum, supports IEEE floating-point arithmetic (IEC 60559),
-// - If one of the two vectors contains NaN, the equivalent element of the other vector is set
-// - Only if both corresponded elements are NaN, NaN is set. 
-#define npyv_minp_f32 vec_min
-#define npyv_minp_f64 vec_min
-// Minimum, integer operations
-#define npyv_min_u8 vec_min
-#define npyv_min_s8 vec_min
-#define npyv_min_u16 vec_min
-#define npyv_min_s16 vec_min
-#define npyv_min_u32 vec_min
-#define npyv_min_s32 vec_min
-#define npyv_min_u64 vec_min
-#define npyv_min_s64 vec_min
-
-// ceil
-#define npyv_ceil_f32 vec_ceil
-#define npyv_ceil_f64 vec_ceil
-
-// trunc
-#define npyv_trunc_f32 vec_trunc
-#define npyv_trunc_f64 vec_trunc
-
-#endif // _NPY_SIMD_VSX_MATH_H
diff --git a/numpy/core/src/common/templ_common.h.src b/numpy/core/src/common/templ_common.h.src
index a65a00758669..84e13481be89 100644
--- a/numpy/core/src/common/templ_common.h.src
+++ b/numpy/core/src/common/templ_common.h.src
@@ -4,16 +4,19 @@
 /* utility functions that profit from templates */
 
 #include "numpy/npy_common.h"
+#include 
 
 /**begin repeat
  *  #name = int, uint, long, ulong,
- *          longlong, ulonglong, intp#
+ *          longlong, ulonglong#
  *  #type = npy_int, npy_uint, npy_long, npy_ulong,
- *          npy_longlong, npy_ulonglong, npy_intp#
+ *          npy_longlong, npy_ulonglong#
  *  #MAX = NPY_MAX_INT, NPY_MAX_UINT, NPY_MAX_LONG, NPY_MAX_ULONG,
- *         NPY_MAX_LONGLONG, NPY_MAX_ULONGLONG, NPY_MAX_INTP#
+ *         NPY_MAX_LONGLONG, NPY_MAX_ULONGLONG#
+ *
+ *  #neg = (1,0)*3#
+ *  #abs_func = abs*2, labs*2, llabs*2#
  */
-
 /*
  * writes result of a * b into r
  * returns 1 if a * b overflowed else returns 0
@@ -34,8 +37,14 @@ npy_mul_with_overflow_@name@(@type@ * r, @type@ a, @type@ b)
     /*
      * avoid expensive division on common no overflow case
      */
-    if (NPY_UNLIKELY((a | b) >= half_sz) &&
-            a != 0 && b > @MAX@ / a) {
+    if ((NPY_UNLIKELY((a | b) >= half_sz) || (a | b) < 0) &&
+            a != 0 && 
+#if @neg@
+            @abs_func@(b) > @abs_func@(@MAX@ / a)
+#else
+            b > @MAX@ / a
+#endif
+            ) {
         return 1;
     }
     return 0;
@@ -43,4 +52,26 @@ npy_mul_with_overflow_@name@(@type@ * r, @type@ a, @type@ b)
 }
 /**end repeat**/
 
+static NPY_INLINE int
+npy_mul_sizes_with_overflow (npy_intp * r, npy_intp a, npy_intp b)
+{
+#ifdef HAVE___BUILTIN_MUL_OVERFLOW
+    return __builtin_mul_overflow(a, b, r);
+#else
+    /* this function only supports non-negative numbers */
+    assert(a >= 0 && b >= 0);
+    const npy_intp half_sz = ((npy_intp)1 << ((sizeof(a) * 8 - 1 ) / 2));
+
+    *r = a * b;
+    /*
+     * avoid expensive division on common no overflow case
+     */
+    if (NPY_UNLIKELY((a | b) >= half_sz)
+        && a != 0 && b > NPY_MAX_INTP / a) {
+        return 1;
+    }
+    return 0;
+#endif
+}
+
 #endif
diff --git a/numpy/core/src/common/ufunc_override.c b/numpy/core/src/common/ufunc_override.c
index d510f185acf3..4fb4d4b3edda 100644
--- a/numpy/core/src/common/ufunc_override.c
+++ b/numpy/core/src/common/ufunc_override.c
@@ -5,6 +5,7 @@
 #include "get_attr_string.h"
 #include "npy_import.h"
 #include "ufunc_override.h"
+#include "scalartypes.h"
 
 /*
  * Check whether an object has __array_ufunc__ defined on its class and it
@@ -30,11 +31,16 @@ PyUFuncOverride_GetNonDefaultArrayUfunc(PyObject *obj)
     if (PyArray_CheckExact(obj)) {
         return NULL;
     }
+   /* Fast return for numpy scalar types */
+    if (is_anyscalar_exact(obj)) {
+        return NULL;
+    }
+
     /*
      * Does the class define __array_ufunc__? (Note that LookupSpecial has fast
      * return for basic python types, so no need to worry about those here)
      */
-    cls_array_ufunc = PyArray_LookupSpecial(obj, "__array_ufunc__");
+    cls_array_ufunc = PyArray_LookupSpecial(obj, npy_um_str_array_ufunc);
     if (cls_array_ufunc == NULL) {
         if (PyErr_Occurred()) {
             PyErr_Clear(); /* TODO[gh-14801]: propagate crashes during attribute access? */
diff --git a/numpy/core/src/common/umathmodule.h b/numpy/core/src/common/umathmodule.h
index 6d4169ad5f8a..0c69f8f545b4 100644
--- a/numpy/core/src/common/umathmodule.h
+++ b/numpy/core/src/common/umathmodule.h
@@ -1,14 +1,20 @@
 #ifndef NUMPY_CORE_SRC_COMMON_UMATHMODULE_H_
 #define NUMPY_CORE_SRC_COMMON_UMATHMODULE_H_
 
-#include "__umath_generated.c"
-#include "__ufunc_api.c"
+#include "ufunc_object.h"
+#include "ufunc_type_resolution.h"
 
 NPY_NO_EXPORT PyObject *
 get_sfloat_dtype(PyObject *NPY_UNUSED(mod), PyObject *NPY_UNUSED(args));
 
+/* Defined in umath/extobj.c */
+NPY_NO_EXPORT int
+PyUFunc_GiveFloatingpointErrors(const char *name, int fpe_errors);
+
 PyObject * add_newdoc_ufunc(PyObject *NPY_UNUSED(dummy), PyObject *args);
 PyObject * ufunc_frompyfunc(PyObject *NPY_UNUSED(dummy), PyObject *args, PyObject *NPY_UNUSED(kwds));
+
+
 int initumath(PyObject *m);
 
 #endif  /* NUMPY_CORE_SRC_COMMON_UMATHMODULE_H_ */
diff --git a/numpy/core/src/multiarray/_multiarray_tests.c.src b/numpy/core/src/multiarray/_multiarray_tests.c.src
index 9486b7cffa5b..1fd28e72192a 100644
--- a/numpy/core/src/multiarray/_multiarray_tests.c.src
+++ b/numpy/core/src/multiarray/_multiarray_tests.c.src
@@ -177,8 +177,14 @@ test_neighborhood_iterator(PyObject* NPY_UNUSED(self), PyObject* args)
         return NULL;
     }
 
-    typenum = PyArray_ObjectType(x, 0);
+    typenum = PyArray_ObjectType(x, NPY_NOTYPE);
+    if (typenum == NPY_NOTYPE) {
+        return NULL;
+    }
     typenum = PyArray_ObjectType(fill, typenum);
+    if (typenum == NPY_NOTYPE) {
+        return NULL;
+    }
 
     ax = (PyArrayObject*)PyArray_FromObject(x, typenum, 1, 10);
     if (ax == NULL) {
@@ -343,7 +349,10 @@ test_neighborhood_iterator_oob(PyObject* NPY_UNUSED(self), PyObject* args)
         return NULL;
     }
 
-    typenum = PyArray_ObjectType(x, 0);
+    typenum = PyArray_ObjectType(x, NPY_NOTYPE);
+    if (typenum == NPY_NOTYPE) {
+        return NULL;
+    }
 
     ax = (PyArrayObject*)PyArray_FromObject(x, typenum, 1, 10);
     if (ax == NULL) {
@@ -643,14 +652,12 @@ static PyObject *
 fromstring_null_term_c_api(PyObject *dummy, PyObject *byte_obj)
 {
     char *string;
-    PyArray_Descr *descr;
 
     string = PyBytes_AsString(byte_obj);
     if (string == NULL) {
         return NULL;
     }
-    descr = PyArray_DescrNewFromType(NPY_FLOAT64);
-    return PyArray_FromString(string, -1, descr, -1, " ");
+    return PyArray_FromString(string, -1, NULL, -1, " ");
 }
 
 
@@ -797,25 +804,6 @@ npy_char_deprecation(PyObject* NPY_UNUSED(self), PyObject* NPY_UNUSED(args))
     return (PyObject *)descr;
 }
 
-/* used to test UPDATEIFCOPY usage emits deprecation warning */
-static PyObject*
-npy_updateifcopy_deprecation(PyObject* NPY_UNUSED(self), PyObject* args)
-{
-    int flags;
-    PyObject* array;
-    if (!PyArray_Check(args)) {
-        PyErr_SetString(PyExc_TypeError, "test needs ndarray input");
-        return NULL;
-    }
-    flags = NPY_ARRAY_CARRAY | NPY_ARRAY_UPDATEIFCOPY;
-    array = PyArray_FromArray((PyArrayObject*)args, NULL, flags);
-    if (array == NULL)
-        return NULL;
-    PyArray_ResolveWritebackIfCopy((PyArrayObject*)array);
-    Py_DECREF(array);
-    Py_RETURN_NONE;
-}
-
 /* used to test PyArray_As1D usage emits not implemented error */
 static PyObject*
 npy_pyarrayas1d_deprecation(PyObject* NPY_UNUSED(self), PyObject* NPY_UNUSED(args))
@@ -1056,7 +1044,7 @@ get_all_cast_information(PyObject *NPY_UNUSED(mod), PyObject *NPY_UNUSED(args))
     PyObject *classes = PyObject_CallMethod(
             (PyObject *)&PyArrayDescr_Type, "__subclasses__", "");
     if (classes == NULL) {
-        return NULL;
+        goto fail;
     }
     Py_SETREF(classes, PySequence_Fast(classes, NULL));
     if (classes == NULL) {
@@ -1086,20 +1074,18 @@ get_all_cast_information(PyObject *NPY_UNUSED(mod), PyObject *NPY_UNUSED(args))
             PyArrayMethodObject *cast = (PyArrayMethodObject *)cast_obj;
 
             /* Pass some information about this cast out! */
-            PyObject *cast_info = Py_BuildValue("{sOsOsisisisisisssi}",
+            PyObject *cast_info = Py_BuildValue("{sOsOsisisisisiss}",
                     "from", from_dtype,
                     "to", to_dtype,
                     "legacy", (cast->name != NULL &&
                                strncmp(cast->name, "legacy_", 7) == 0),
-                    "casting", cast->casting & ~_NPY_CAST_IS_VIEW,
+                    "casting", cast->casting,
                     "requires_pyapi", cast->flags & NPY_METH_REQUIRES_PYAPI,
                     "supports_unaligned",
                         cast->flags & NPY_METH_SUPPORTS_UNALIGNED,
                     "no_floatingpoint_errors",
                         cast->flags & NPY_METH_NO_FLOATINGPOINT_ERRORS,
-                    "name", cast->name,
-                    "cast_is_view",
-                        cast->casting & _NPY_CAST_IS_VIEW);
+                    "name", cast->name);
             if (cast_info == NULL) {
                 goto fail;
             }
@@ -2033,6 +2019,10 @@ get_struct_alignments(PyObject *NPY_UNUSED(self), PyObject *args) {
     PyObject *ret = PyTuple_New(3);
     PyObject *alignment, *size, *val;
 
+    if (ret == NULL) {
+        return NULL;
+    }
+
 /**begin repeat
  * #N = 1,2,3#
  */
@@ -2042,6 +2032,7 @@ get_struct_alignments(PyObject *NPY_UNUSED(self), PyObject *args) {
     Py_DECREF(alignment);
     Py_DECREF(size);
     if (val == NULL) {
+        Py_DECREF(ret);
         return NULL;
     }
     PyTuple_SET_ITEM(ret, @N@-1, val);
@@ -2374,6 +2365,32 @@ npy_ensurenocopy(PyObject* NPY_UNUSED(self), PyObject* args)
     Py_RETURN_NONE;
 }
 
+static PyObject *
+run_scalar_intp_converter(PyObject *NPY_UNUSED(self), PyObject *obj)
+{
+    PyArray_Dims dims;
+    if (!PyArray_IntpConverter(obj, &dims)) {
+        return NULL;
+    }
+    else {
+        PyObject *result = PyArray_IntTupleFromIntp(dims.len, dims.ptr);
+        PyDimMem_FREE(dims.ptr);
+        return result;
+    }
+}
+
+static PyObject *
+run_scalar_intp_from_sequence(PyObject *NPY_UNUSED(self), PyObject *obj)
+{
+    npy_intp vals[1];
+
+    int output = PyArray_IntpFromSequence(obj, vals, 1);
+    if (output == -1) {
+        return NULL;
+    }
+    return PyArray_IntTupleFromIntp(1, vals);
+}
+
 static PyMethodDef Multiarray_TestsMethods[] = {
     {"argparse_example_function",
          (PyCFunction)argparse_example_function,
@@ -2414,9 +2431,6 @@ static PyMethodDef Multiarray_TestsMethods[] = {
     {"npy_char_deprecation",
         npy_char_deprecation,
         METH_NOARGS, NULL},
-    {"npy_updateifcopy_deprecation",
-        npy_updateifcopy_deprecation,
-        METH_O, NULL},
     {"npy_pyarrayas1d_deprecation",
         npy_pyarrayas1d_deprecation,
         METH_NOARGS, NULL},
@@ -2567,6 +2581,12 @@ static PyMethodDef Multiarray_TestsMethods[] = {
     {"run_casting_converter",
         run_casting_converter,
         METH_VARARGS, NULL},
+    {"run_scalar_intp_converter",
+        run_scalar_intp_converter,
+        METH_O, NULL},
+    {"run_scalar_intp_from_sequence",
+        run_scalar_intp_from_sequence,
+        METH_O, NULL},
     {"run_intp_converter",
         run_intp_converter,
         METH_VARARGS, NULL},
diff --git a/numpy/core/src/multiarray/abstractdtypes.c b/numpy/core/src/multiarray/abstractdtypes.c
index cc1d7fad8233..8dc595738e27 100644
--- a/numpy/core/src/multiarray/abstractdtypes.c
+++ b/numpy/core/src/multiarray/abstractdtypes.c
@@ -164,7 +164,39 @@ int_common_dtype(PyArray_DTypeMeta *NPY_UNUSED(cls), PyArray_DTypeMeta *other)
     }
     else if (NPY_DT_is_legacy(other)) {
         /* This is a back-compat fallback to usually do the right thing... */
-        return PyArray_DTypeFromTypeNum(NPY_UINT8);
+        PyArray_DTypeMeta *uint8_dt = PyArray_DTypeFromTypeNum(NPY_UINT8);
+        PyArray_DTypeMeta *res = NPY_DT_CALL_common_dtype(other, uint8_dt);
+        Py_DECREF(uint8_dt);
+        if (res == NULL) {
+            PyErr_Clear();
+        }
+        else if (res == (PyArray_DTypeMeta *)Py_NotImplemented) {
+            Py_DECREF(res);
+        }
+        else {
+            return res;
+        }
+        /* Try again with `int8`, an error may have been set, though */
+        PyArray_DTypeMeta *int8_dt = PyArray_DTypeFromTypeNum(NPY_INT8);
+        res = NPY_DT_CALL_common_dtype(other, int8_dt);
+        Py_DECREF(int8_dt);
+        if (res == NULL) {
+            PyErr_Clear();
+        }
+        else if (res == (PyArray_DTypeMeta *)Py_NotImplemented) {
+            Py_DECREF(res);
+        }
+        else {
+            return res;
+        }
+        /* And finally, we will try the default integer, just for sports... */
+        PyArray_DTypeMeta *default_int = PyArray_DTypeFromTypeNum(NPY_LONG);
+        res = NPY_DT_CALL_common_dtype(other, default_int);
+        Py_DECREF(default_int);
+        if (res == NULL) {
+            PyErr_Clear();
+        }
+        return res;
     }
     Py_INCREF(Py_NotImplemented);
     return (PyArray_DTypeMeta *)Py_NotImplemented;
@@ -191,7 +223,23 @@ float_common_dtype(PyArray_DTypeMeta *cls, PyArray_DTypeMeta *other)
     }
     else if (NPY_DT_is_legacy(other)) {
         /* This is a back-compat fallback to usually do the right thing... */
-        return PyArray_DTypeFromTypeNum(NPY_HALF);
+        PyArray_DTypeMeta *half_dt = PyArray_DTypeFromTypeNum(NPY_HALF);
+        PyArray_DTypeMeta *res = NPY_DT_CALL_common_dtype(other, half_dt);
+        Py_DECREF(half_dt);
+        if (res == NULL) {
+            PyErr_Clear();
+        }
+        else if (res == (PyArray_DTypeMeta *)Py_NotImplemented) {
+            Py_DECREF(res);
+        }
+        else {
+            return res;
+        }
+        /* Retry with double (the default float) */
+        PyArray_DTypeMeta *double_dt = PyArray_DTypeFromTypeNum(NPY_DOUBLE);
+        res = NPY_DT_CALL_common_dtype(other, double_dt);
+        Py_DECREF(double_dt);
+        return res;
     }
     Py_INCREF(Py_NotImplemented);
     return (PyArray_DTypeMeta *)Py_NotImplemented;
@@ -229,7 +277,24 @@ complex_common_dtype(PyArray_DTypeMeta *cls, PyArray_DTypeMeta *other)
     }
     else if (NPY_DT_is_legacy(other)) {
         /* This is a back-compat fallback to usually do the right thing... */
-        return PyArray_DTypeFromTypeNum(NPY_CFLOAT);
+        PyArray_DTypeMeta *cfloat_dt = PyArray_DTypeFromTypeNum(NPY_CFLOAT);
+        PyArray_DTypeMeta *res = NPY_DT_CALL_common_dtype(other, cfloat_dt);
+        Py_DECREF(cfloat_dt);
+        if (res == NULL) {
+            PyErr_Clear();
+        }
+        else if (res == (PyArray_DTypeMeta *)Py_NotImplemented) {
+            Py_DECREF(res);
+        }
+        else {
+            return res;
+        }
+        /* Retry with cdouble (the default complex) */
+        PyArray_DTypeMeta *cdouble_dt = PyArray_DTypeFromTypeNum(NPY_CDOUBLE);
+        res = NPY_DT_CALL_common_dtype(other, cdouble_dt);
+        Py_DECREF(cdouble_dt);
+        return res;
+
     }
     else if (other == &PyArray_PyIntAbstractDType ||
              other == &PyArray_PyFloatAbstractDType) {
@@ -247,51 +312,54 @@ complex_common_dtype(PyArray_DTypeMeta *cls, PyArray_DTypeMeta *other)
  *       They will have to be renamed and exposed in that capacity.
  */
 NPY_DType_Slots pyintabstractdtype_slots = {
-    .default_descr = int_default_descriptor,
     .discover_descr_from_pyobject = discover_descriptor_from_pyint,
+    .default_descr = int_default_descriptor,
     .common_dtype = int_common_dtype,
 };
 
 NPY_NO_EXPORT PyArray_DTypeMeta PyArray_PyIntAbstractDType = {{{
         PyVarObject_HEAD_INIT(&PyArrayDTypeMeta_Type, 0)
+        .tp_name = "numpy._IntegerAbstractDType",
         .tp_basicsize = sizeof(PyArray_Descr),
         .tp_flags = Py_TPFLAGS_DEFAULT,
-        .tp_name = "numpy._IntegerAbstractDType",
     },},
+    .type_num = -1,
     .flags = NPY_DT_ABSTRACT,
     .dt_slots = &pyintabstractdtype_slots,
 };
 
 
 NPY_DType_Slots pyfloatabstractdtype_slots = {
-    .default_descr = float_default_descriptor,
     .discover_descr_from_pyobject = discover_descriptor_from_pyfloat,
+    .default_descr = float_default_descriptor,
     .common_dtype = float_common_dtype,
 };
 
 NPY_NO_EXPORT PyArray_DTypeMeta PyArray_PyFloatAbstractDType = {{{
         PyVarObject_HEAD_INIT(&PyArrayDTypeMeta_Type, 0)
+        .tp_name = "numpy._FloatAbstractDType",
         .tp_basicsize = sizeof(PyArray_Descr),
        .tp_flags = Py_TPFLAGS_DEFAULT,
-        .tp_name = "numpy._FloatAbstractDType",
     },},
+    .type_num = -1,
     .flags = NPY_DT_ABSTRACT,
     .dt_slots = &pyfloatabstractdtype_slots,
 };
 
 
 NPY_DType_Slots pycomplexabstractdtype_slots = {
-    .default_descr = complex_default_descriptor,
     .discover_descr_from_pyobject = discover_descriptor_from_pycomplex,
+    .default_descr = complex_default_descriptor,
     .common_dtype = complex_common_dtype,
 };
 
 NPY_NO_EXPORT PyArray_DTypeMeta PyArray_PyComplexAbstractDType = {{{
         PyVarObject_HEAD_INIT(&PyArrayDTypeMeta_Type, 0)
+        .tp_name = "numpy._ComplexAbstractDType",
         .tp_basicsize = sizeof(PyArray_Descr),
          .tp_flags = Py_TPFLAGS_DEFAULT,
-        .tp_name = "numpy._ComplexAbstractDType",
     },},
+    .type_num = -1,
     .flags = NPY_DT_ABSTRACT,
     .dt_slots = &pycomplexabstractdtype_slots,
 };
diff --git a/numpy/core/src/multiarray/abstractdtypes.h b/numpy/core/src/multiarray/abstractdtypes.h
index 42c192cac7b8..6901ec213a95 100644
--- a/numpy/core/src/multiarray/abstractdtypes.h
+++ b/numpy/core/src/multiarray/abstractdtypes.h
@@ -1,6 +1,7 @@
 #ifndef NUMPY_CORE_SRC_MULTIARRAY_ABSTRACTDTYPES_H_
 #define NUMPY_CORE_SRC_MULTIARRAY_ABSTRACTDTYPES_H_
 
+#include "arrayobject.h"
 #include "dtypemeta.h"
 
 
@@ -16,4 +17,56 @@ NPY_NO_EXPORT extern PyArray_DTypeMeta PyArray_PyComplexAbstractDType;
 NPY_NO_EXPORT int
 initialize_and_map_pytypes_to_dtypes(void);
 
+
+/*
+ * When we get a Python int, float, or complex, we may have to use weak
+ * promotion logic.
+ * To implement this, we sometimes have to tag the converted (temporary)
+ * array when the original object was a Python scalar.
+ *
+ * @param obj The original Python object.
+ * @param arr The array into which the Python object was converted.
+ * @param[in,out] **dtype A pointer to the array's DType, if not NULL it will be
+ *        replaced with the abstract DType.
+ * @return 0 if the `obj` was not a python scalar, and 1 if it was.
+ */
+static NPY_INLINE int
+npy_mark_tmp_array_if_pyscalar(
+        PyObject *obj, PyArrayObject *arr, PyArray_DTypeMeta **dtype)
+{
+    /*
+     * We check the array dtype for two reasons: First, booleans are
+     * integer subclasses.  Second, an int, float, or complex could have
+     * a custom DType registered, and then we should use that.
+     * Further, `np.float64` is a double subclass, so must reject it.
+     */
+    if (PyLong_Check(obj)
+            && (PyArray_ISINTEGER(arr) || PyArray_ISOBJECT(arr))) {
+        ((PyArrayObject_fields *)arr)->flags |= NPY_ARRAY_WAS_PYTHON_INT;
+        if (dtype != NULL) {
+            Py_INCREF(&PyArray_PyIntAbstractDType);
+            Py_SETREF(*dtype, &PyArray_PyIntAbstractDType);
+        }
+        return 1;
+    }
+    else if (PyFloat_Check(obj) && !PyArray_IsScalar(obj, Double)
+             && PyArray_TYPE(arr) == NPY_DOUBLE) {
+        ((PyArrayObject_fields *)arr)->flags |= NPY_ARRAY_WAS_PYTHON_FLOAT;
+        if (dtype != NULL) {
+            Py_INCREF(&PyArray_PyFloatAbstractDType);
+            Py_SETREF(*dtype, &PyArray_PyFloatAbstractDType);
+        }
+        return 1;
+    }
+    else if (PyComplex_Check(obj) && PyArray_TYPE(arr) == NPY_CDOUBLE) {
+        ((PyArrayObject_fields *)arr)->flags |= NPY_ARRAY_WAS_PYTHON_COMPLEX;
+        if (dtype != NULL) {
+            Py_INCREF(&PyArray_PyComplexAbstractDType);
+            Py_SETREF(*dtype, &PyArray_PyComplexAbstractDType);
+        }
+        return 1;
+    }
+    return 0;
+}
+
 #endif  /* NUMPY_CORE_SRC_MULTIARRAY_ABSTRACTDTYPES_H_ */
diff --git a/numpy/core/src/multiarray/alloc.c b/numpy/core/src/multiarray/alloc.c
index 0a694cf62662..8b765aa954da 100644
--- a/numpy/core/src/multiarray/alloc.c
+++ b/numpy/core/src/multiarray/alloc.c
@@ -38,6 +38,25 @@ static cache_bucket dimcache[NBUCKETS_DIM];
 static int _madvise_hugepage = 1;
 
 
+/*
+ * This function tells whether NumPy attempts to call `madvise` with
+ * `MADV_HUGEPAGE`.  `madvise` is only ever used on linux, so the value
+ * of `_madvise_hugepage` may be ignored.
+ *
+ * It is exposed to Python as `np.core.multiarray._get_madvise_hugepage`.
+ */
+NPY_NO_EXPORT PyObject *
+_get_madvise_hugepage(PyObject *NPY_UNUSED(self), PyObject *NPY_UNUSED(args))
+{
+#ifdef NPY_OS_LINUX
+    if (_madvise_hugepage) {
+        Py_RETURN_TRUE;
+    }
+#endif
+    Py_RETURN_FALSE;
+}
+
+
 /*
  * This function enables or disables the use of `MADV_HUGEPAGE` on Linux
  * by modifying the global static `_madvise_hugepage`.
@@ -186,6 +205,24 @@ npy_free_cache_dim(void * p, npy_uintp sz)
                     &PyArray_free);
 }
 
+/* Similar to array_dealloc in arrayobject.c */
+static NPY_INLINE void
+WARN_NO_RETURN(PyObject* warning, const char * msg) {
+    if (PyErr_WarnEx(warning, msg, 1) < 0) {
+        PyObject * s;
+
+        s = PyUnicode_FromString("PyDataMem_UserFREE");
+        if (s) {
+            PyErr_WriteUnraisable(s);
+            Py_DECREF(s);
+        }
+        else {
+            PyErr_WriteUnraisable(Py_None);
+        }
+    }
+}
+
+
 
 /* malloc/free/realloc hook */
 NPY_NO_EXPORT PyDataMem_EventHookFunc *_PyDataMem_eventhook = NULL;
@@ -210,6 +247,8 @@ NPY_NO_EXPORT void *_PyDataMem_eventhook_user_data = NULL;
  * operations that might cause new allocation events (such as the
  * creation/destruction numpy objects, or creating/destroying Python
  * objects which might cause a gc)
+ *
+ * Deprecated in 1.23
  */
 NPY_NO_EXPORT PyDataMem_EventHookFunc *
 PyDataMem_SetEventHook(PyDataMem_EventHookFunc *newhook,
@@ -218,6 +257,10 @@ PyDataMem_SetEventHook(PyDataMem_EventHookFunc *newhook,
     PyDataMem_EventHookFunc *temp;
     NPY_ALLOW_C_API_DEF
     NPY_ALLOW_C_API
+    /* 2021-11-18, 1.23 */
+    WARN_NO_RETURN(PyExc_DeprecationWarning,
+                     "PyDataMem_SetEventHook is deprecated, use tracemalloc "
+                     "and the 'np.lib.tracemalloc_domain' domain");
     temp = _PyDataMem_eventhook;
     _PyDataMem_eventhook = newhook;
     if (old_data != NULL) {
@@ -381,10 +424,7 @@ PyDataMem_Handler default_handler = {
 };
 /* singleton capsule of the default handler */
 PyObject *PyDataMem_DefaultHandler;
-
-#if (!defined(PYPY_VERSION_NUM) || PYPY_VERSION_NUM >= 0x07030600)
 PyObject *current_handler;
-#endif
 
 int uo_index=0;   /* user_override index */
 
@@ -435,33 +475,14 @@ PyDataMem_UserNEW_ZEROED(size_t nmemb, size_t size, PyObject *mem_handler)
     return result;
 }
 
-/* Similar to array_dealloc in arrayobject.c */
-static NPY_INLINE void
-WARN_IN_FREE(PyObject* warning, const char * msg) {
-    if (PyErr_WarnEx(warning, msg, 1) < 0) {
-        PyObject * s;
-
-        s = PyUnicode_FromString("PyDataMem_UserFREE");
-        if (s) {
-            PyErr_WriteUnraisable(s);
-            Py_DECREF(s);
-        }
-        else {
-            PyErr_WriteUnraisable(Py_None);
-        }
-    }
-}
-
-
 
 NPY_NO_EXPORT void
 PyDataMem_UserFREE(void *ptr, size_t size, PyObject *mem_handler)
 {
     PyDataMem_Handler *handler = (PyDataMem_Handler *) PyCapsule_GetPointer(mem_handler, "mem_handler");
     if (handler == NULL) {
-        WARN_IN_FREE(PyExc_RuntimeWarning,
+        WARN_NO_RETURN(PyExc_RuntimeWarning,
                      "Could not get pointer to 'mem_handler' from PyCapsule");
-        PyErr_Clear();
         return;
     }
     PyTraceMalloc_Untrack(NPY_TRACE_DOMAIN, (npy_uintp)ptr);
@@ -515,7 +536,6 @@ NPY_NO_EXPORT PyObject *
 PyDataMem_SetHandler(PyObject *handler)
 {
     PyObject *old_handler;
-#if (!defined(PYPY_VERSION_NUM) || PYPY_VERSION_NUM >= 0x07030600)
     PyObject *token;
     if (PyContextVar_Get(current_handler, NULL, &old_handler)) {
         return NULL;
@@ -530,27 +550,6 @@ PyDataMem_SetHandler(PyObject *handler)
     }
     Py_DECREF(token);
     return old_handler;
-#else
-    PyObject *p;
-    p = PyThreadState_GetDict();
-    if (p == NULL) {
-        return NULL;
-    }
-    old_handler = PyDict_GetItemString(p, "current_allocator");
-    if (old_handler == NULL) {
-        old_handler = PyDataMem_DefaultHandler
-    }
-    Py_INCREF(old_handler);
-    if (handler == NULL) {
-        handler = PyDataMem_DefaultHandler;
-    }
-    const int error = PyDict_SetItemString(p, "current_allocator", handler);
-    if (error) {
-        Py_DECREF(old_handler);
-        return NULL;
-    }
-    return old_handler;
-#endif
 }
 
 /*NUMPY_API
@@ -561,28 +560,10 @@ NPY_NO_EXPORT PyObject *
 PyDataMem_GetHandler()
 {
     PyObject *handler;
-#if (!defined(PYPY_VERSION_NUM) || PYPY_VERSION_NUM >= 0x07030600)
     if (PyContextVar_Get(current_handler, NULL, &handler)) {
         return NULL;
     }
     return handler;
-#else
-    PyObject *p = PyThreadState_GetDict();
-    if (p == NULL) {
-        return NULL;
-    }
-    handler = PyDict_GetItemString(p, "current_allocator");
-    if (handler == NULL) {
-        handler = PyCapsule_New(&default_handler, "mem_handler", NULL);
-        if (handler == NULL) {
-            return NULL;
-        }
-    }
-    else {
-        Py_INCREF(handler);
-    }
-    return handler;
-#endif
 }
 
 NPY_NO_EXPORT PyObject *
diff --git a/numpy/core/src/multiarray/alloc.h b/numpy/core/src/multiarray/alloc.h
index 13c82845813d..0f5a7524cd8e 100644
--- a/numpy/core/src/multiarray/alloc.h
+++ b/numpy/core/src/multiarray/alloc.h
@@ -7,6 +7,9 @@
 
 #define NPY_TRACE_DOMAIN 389047
 
+NPY_NO_EXPORT PyObject *
+_get_madvise_hugepage(PyObject *NPY_UNUSED(self), PyObject *NPY_UNUSED(args));
+
 NPY_NO_EXPORT PyObject *
 _set_madvise_hugepage(PyObject *NPY_UNUSED(self), PyObject *enabled_obj);
 
@@ -41,9 +44,7 @@ npy_free_cache_dim_array(PyArrayObject * arr)
 }
 
 extern PyDataMem_Handler default_handler;
-#if (!defined(PYPY_VERSION_NUM) || PYPY_VERSION_NUM >= 0x07030600)
 extern PyObject *current_handler; /* PyContextVar/PyCapsule */
-#endif
 
 NPY_NO_EXPORT PyObject *
 get_handler_name(PyObject *NPY_UNUSED(self), PyObject *obj);
diff --git a/numpy/core/src/multiarray/argfunc.dispatch.c.src b/numpy/core/src/multiarray/argfunc.dispatch.c.src
new file mode 100644
index 000000000000..1d7753275d7c
--- /dev/null
+++ b/numpy/core/src/multiarray/argfunc.dispatch.c.src
@@ -0,0 +1,398 @@
+/* -*- c -*- */
+/*@targets
+ ** $maxopt baseline
+ ** sse2 sse42 xop avx2 avx512_skx
+ ** vsx2
+ ** neon asimd
+ ** vx vxe
+ **/
+
+#define NPY_NO_DEPRECATED_API NPY_API_VERSION
+
+#include "simd/simd.h"
+#include "numpy/npy_math.h"
+
+#include "arraytypes.h"
+
+#define MIN(a,b) (((a)<(b))?(a):(b))
+
+#if NPY_SIMD
+#if NPY_SIMD > 512 || NPY_SIMD < 0
+    #error "the following 8/16-bit argmax kernel isn't applicable for larger SIMD"
+    // TODO: add special loop for large SIMD width.
+    // i.e avoid unroll by x4 should be numerically safe till 2048-bit SIMD width
+    // or maybe expand the indices to 32|64-bit vectors(slower).
+#endif
+/**begin repeat
+ * #sfx = u8, s8, u16, s16#
+ * #usfx = u8, u8, u16, u16#
+ * #bsfx = b8, b8, b16, b16#
+ * #idx_max = NPY_MAX_UINT8*2, NPY_MAX_UINT16*2#
+ */
+/**begin repeat1
+ * #intrin = cmpgt, cmplt#
+ * #func = argmax, argmin#
+ * #op = >, <#
+ */
+static inline npy_intp
+simd_@func@_@sfx@(npyv_lanetype_@sfx@ *ip, npy_intp len)
+{
+    npyv_lanetype_@sfx@ s_acc = *ip;
+    npy_intp ret_idx = 0, i = 0;
+
+    const int vstep = npyv_nlanes_@sfx@;
+    const int wstep = vstep*4;
+    npyv_lanetype_@usfx@ d_vindices[npyv_nlanes_@sfx@*4];
+    for (int vi = 0; vi < wstep; ++vi) {
+        d_vindices[vi] = vi;
+    }
+    const npyv_@usfx@ vindices_0 = npyv_load_@usfx@(d_vindices);
+    const npyv_@usfx@ vindices_1 = npyv_load_@usfx@(d_vindices + vstep);
+    const npyv_@usfx@ vindices_2 = npyv_load_@usfx@(d_vindices + vstep*2);
+    const npyv_@usfx@ vindices_3 = npyv_load_@usfx@(d_vindices + vstep*3);
+
+    const npy_intp max_block = @idx_max@*wstep & -wstep;
+    npy_intp len0 = len & -wstep;
+    while (i < len0) {
+        npyv_@sfx@ acc = npyv_setall_@sfx@(s_acc);
+        npyv_@usfx@ acc_indices = npyv_zero_@usfx@();
+        npyv_@usfx@ acc_indices_scale = npyv_zero_@usfx@();
+
+        npy_intp n = i + MIN(len0 - i, max_block);
+        npy_intp ik = i, i2 = 0;
+        for (; i < n; i += wstep, ++i2) {
+            npyv_@usfx@ vi = npyv_setall_@usfx@((npyv_lanetype_@usfx@)i2);
+            npyv_@sfx@ a = npyv_load_@sfx@(ip + i);
+            npyv_@sfx@ b = npyv_load_@sfx@(ip + i + vstep);
+            npyv_@sfx@ c = npyv_load_@sfx@(ip + i + vstep*2);
+            npyv_@sfx@ d = npyv_load_@sfx@(ip + i + vstep*3);
+
+            // reverse to put lowest index first in case of matched values
+            npyv_@bsfx@ m_ba = npyv_@intrin@_@sfx@(b, a);
+            npyv_@bsfx@ m_dc = npyv_@intrin@_@sfx@(d, c);
+            npyv_@sfx@  x_ba = npyv_select_@sfx@(m_ba, b, a);
+            npyv_@sfx@  x_dc = npyv_select_@sfx@(m_dc, d, c);
+            npyv_@bsfx@ m_dcba = npyv_@intrin@_@sfx@(x_dc, x_ba);
+            npyv_@sfx@  x_dcba = npyv_select_@sfx@(m_dcba, x_dc, x_ba);
+
+            npyv_@usfx@ idx_ba = npyv_select_@usfx@(m_ba, vindices_1, vindices_0);
+            npyv_@usfx@ idx_dc = npyv_select_@usfx@(m_dc, vindices_3, vindices_2);
+            npyv_@usfx@ idx_dcba = npyv_select_@usfx@(m_dcba, idx_dc, idx_ba);
+            npyv_@bsfx@ m_acc = npyv_@intrin@_@sfx@(x_dcba, acc);
+            acc = npyv_select_@sfx@(m_acc, x_dcba, acc);
+            acc_indices = npyv_select_@usfx@(m_acc, idx_dcba, acc_indices);
+            acc_indices_scale = npyv_select_@usfx@(m_acc, vi, acc_indices_scale);
+        }
+        // reduce
+        npyv_lanetype_@sfx@ dacc[npyv_nlanes_@sfx@];
+        npyv_lanetype_@usfx@ dacc_i[npyv_nlanes_@sfx@];
+        npyv_lanetype_@usfx@ dacc_s[npyv_nlanes_@sfx@];
+        npyv_store_@sfx@(dacc, acc);
+        npyv_store_@usfx@(dacc_i, acc_indices);
+        npyv_store_@usfx@(dacc_s, acc_indices_scale);
+
+        for (int vi = 0; vi < vstep; ++vi) {
+            if (dacc[vi] @op@ s_acc) {
+                s_acc = dacc[vi];
+                ret_idx = ik + (npy_intp)dacc_s[vi]*wstep + dacc_i[vi];
+            }
+        }
+        // get the lowest index in case of matched values
+        for (int vi = 0; vi < vstep; ++vi) {
+            npy_intp idx = ik + (npy_intp)dacc_s[vi]*wstep + dacc_i[vi];
+            if (s_acc == dacc[vi] && ret_idx > idx) {
+                ret_idx = idx;
+            }
+        }
+    }
+    for (; i < len; ++i) {
+        npyv_lanetype_@sfx@ a = ip[i];
+        if (a @op@ s_acc) {
+            s_acc = a;
+            ret_idx = i;
+        }
+    }
+    return ret_idx;
+}
+/**end repeat1**/
+/**end repeat**/
+#endif
+
+/**begin repeat
+ * #sfx = u32, s32, u64, s64, f32, f64#
+ * #usfx = u32, u32, u64, u64, u32, u64#
+ * #bsfx = b32, b32, b64, b64, b32, b64#
+ * #is_fp = 0*4, 1*2#
+ * #is_idx32 = 1*2, 0*2, 1, 0#
+ * #chk_simd = NPY_SIMD*4, NPY_SIMD_F32, NPY_SIMD_F64#
+ */
+#if @chk_simd@
+/**begin repeat1
+ * #intrin = cmpgt, cmplt#
+ * #func = argmax, argmin#
+ * #op = >, <#
+ * #iop = <, >#
+ */
+static inline npy_intp
+simd_@func@_@sfx@(npyv_lanetype_@sfx@ *ip, npy_intp len)
+{
+    npyv_lanetype_@sfx@ s_acc = *ip;
+    npy_intp ret_idx = 0, i = 0;
+    const int vstep = npyv_nlanes_@sfx@;
+    const int wstep = vstep*4;
+    // loop by a scalar will perform better for small arrays
+    if (len < wstep) {
+        goto scalar_loop;
+    }
+    npy_intp len0 = len;
+    // guard against wraparound vector addition for 32-bit indices
+    // in case of the array length is larger than 16gb
+#if @is_idx32@
+    if (len0 > NPY_MAX_UINT32) {
+        len0 = NPY_MAX_UINT32;
+    }
+#endif
+    // create index for vector indices
+    npyv_lanetype_@usfx@ d_vindices[npyv_nlanes_@sfx@*4];
+    for (int vi = 0; vi < wstep; ++vi) {
+        d_vindices[vi] = vi;
+    }
+    const npyv_@usfx@ vindices_0 = npyv_load_@usfx@(d_vindices);
+    const npyv_@usfx@ vindices_1 = npyv_load_@usfx@(d_vindices + vstep);
+    const npyv_@usfx@ vindices_2 = npyv_load_@usfx@(d_vindices + vstep*2);
+    const npyv_@usfx@ vindices_3 = npyv_load_@usfx@(d_vindices + vstep*3);
+    // initialize vector accumulator for highest values and its indexes
+    npyv_@usfx@ acc_indices = npyv_zero_@usfx@();
+    npyv_@sfx@ acc = npyv_setall_@sfx@(s_acc);
+    for (npy_intp n = len0 & -wstep; i < n; i += wstep) {
+        npyv_@usfx@ vi = npyv_setall_@usfx@((npyv_lanetype_@usfx@)i);
+        npyv_@sfx@ a = npyv_load_@sfx@(ip + i);
+        npyv_@sfx@ b = npyv_load_@sfx@(ip + i + vstep);
+        npyv_@sfx@ c = npyv_load_@sfx@(ip + i + vstep*2);
+        npyv_@sfx@ d = npyv_load_@sfx@(ip + i + vstep*3);
+
+        // reverse to put lowest index first in case of matched values
+        npyv_@bsfx@ m_ba = npyv_@intrin@_@sfx@(b, a);
+        npyv_@bsfx@ m_dc = npyv_@intrin@_@sfx@(d, c);
+        npyv_@sfx@  x_ba = npyv_select_@sfx@(m_ba, b, a);
+        npyv_@sfx@  x_dc = npyv_select_@sfx@(m_dc, d, c);
+        npyv_@bsfx@ m_dcba = npyv_@intrin@_@sfx@(x_dc, x_ba);
+        npyv_@sfx@  x_dcba = npyv_select_@sfx@(m_dcba, x_dc, x_ba);
+
+        npyv_@usfx@ idx_ba = npyv_select_@usfx@(m_ba, vindices_1, vindices_0);
+        npyv_@usfx@ idx_dc = npyv_select_@usfx@(m_dc, vindices_3, vindices_2);
+        npyv_@usfx@ idx_dcba = npyv_select_@usfx@(m_dcba, idx_dc, idx_ba);
+        npyv_@bsfx@ m_acc = npyv_@intrin@_@sfx@(x_dcba, acc);
+        acc = npyv_select_@sfx@(m_acc, x_dcba, acc);
+        acc_indices = npyv_select_@usfx@(m_acc, npyv_add_@usfx@(vi, idx_dcba), acc_indices);
+
+    #if @is_fp@
+        npyv_@bsfx@ nnan_a = npyv_notnan_@sfx@(a);
+        npyv_@bsfx@ nnan_b = npyv_notnan_@sfx@(b);
+        npyv_@bsfx@ nnan_c = npyv_notnan_@sfx@(c);
+        npyv_@bsfx@ nnan_d = npyv_notnan_@sfx@(d);
+        npyv_@bsfx@ nnan_ab = npyv_and_@bsfx@(nnan_a, nnan_b);
+        npyv_@bsfx@ nnan_cd = npyv_and_@bsfx@(nnan_c, nnan_d);
+        npy_uint64 nnan = npyv_tobits_@bsfx@(npyv_and_@bsfx@(nnan_ab, nnan_cd));
+        if (nnan != ((1LL << vstep) - 1)) {
+            npy_uint64 nnan_4[4];
+            nnan_4[0] = npyv_tobits_@bsfx@(nnan_a);
+            nnan_4[1] = npyv_tobits_@bsfx@(nnan_b);
+            nnan_4[2] = npyv_tobits_@bsfx@(nnan_c);
+            nnan_4[3] = npyv_tobits_@bsfx@(nnan_d);
+            for (int ni = 0; ni < 4; ++ni) {
+                for (int vi = 0; vi < vstep; ++vi) {
+                    if (!((nnan_4[ni] >> vi) & 1)) {
+                        return i + ni*vstep + vi;
+                    }
+                }
+            }
+        }
+    #endif
+    }
+    for (npy_intp n = len0 & -vstep; i < n; i += vstep) {
+        npyv_@usfx@ vi = npyv_setall_@usfx@((npyv_lanetype_@usfx@)i);
+        npyv_@sfx@ a = npyv_load_@sfx@(ip + i);
+        npyv_@bsfx@ m_acc = npyv_@intrin@_@sfx@(a, acc);
+        acc = npyv_select_@sfx@(m_acc, a, acc);
+        acc_indices = npyv_select_@usfx@(m_acc, npyv_add_@usfx@(vi, vindices_0), acc_indices);
+    #if @is_fp@
+        npyv_@bsfx@ nnan_a = npyv_notnan_@sfx@(a);
+        npy_uint64 nnan = npyv_tobits_@bsfx@(nnan_a);
+        if (nnan != ((1LL << vstep) - 1)) {
+            for (int vi = 0; vi < vstep; ++vi) {
+                if (!((nnan >> vi) & 1)) {
+                    return i + vi;
+                }
+            }
+        }
+    #endif
+    }
+
+    // reduce
+    npyv_lanetype_@sfx@ dacc[npyv_nlanes_@sfx@];
+    npyv_lanetype_@usfx@ dacc_i[npyv_nlanes_@sfx@];
+    npyv_store_@usfx@(dacc_i, acc_indices);
+    npyv_store_@sfx@(dacc, acc);
+
+    s_acc = dacc[0];
+    ret_idx = dacc_i[0];
+    for (int vi = 1; vi < vstep; ++vi) {
+        if (dacc[vi] @op@ s_acc) {
+            s_acc = dacc[vi];
+            ret_idx = (npy_intp)dacc_i[vi];
+        }
+    }
+    // get the lowest index in case of matched values
+    for (int vi = 0; vi < vstep; ++vi) {
+        if (s_acc == dacc[vi] && ret_idx > (npy_intp)dacc_i[vi]) {
+            ret_idx = dacc_i[vi];
+        }
+    }
+scalar_loop:
+    for (; i < len; ++i) {
+        npyv_lanetype_@sfx@ a = ip[i];
+    #if @is_fp@
+        if (!(a @iop@= s_acc)) {  // negated, for correct nan handling
+    #else
+        if (a @op@ s_acc) {
+    #endif
+            s_acc = a;
+            ret_idx = i;
+        #if @is_fp@
+            if (npy_isnan(s_acc)) {
+                // nan encountered, it's maximal
+                return ret_idx;
+            }
+        #endif
+        }
+    }
+    return ret_idx;
+}
+/**end repeat1**/
+#endif // chk_simd
+/**end repeat**/
+
+/**begin repeat
+ * #TYPE = UBYTE, USHORT, UINT, ULONG, ULONGLONG,
+ *         BYTE, SHORT, INT, LONG, LONGLONG,
+ *         FLOAT, DOUBLE, LONGDOUBLE#
+ *
+ * #BTYPE = BYTE, SHORT, INT, LONG, LONGLONG,
+ *          BYTE, SHORT, INT, LONG, LONGLONG,
+ *          FLOAT, DOUBLE, LONGDOUBLE#
+ * #type = npy_ubyte, npy_ushort, npy_uint, npy_ulong, npy_ulonglong,
+ *         npy_byte, npy_short, npy_int, npy_long, npy_longlong,
+ *         npy_float, npy_double, npy_longdouble#
+ *
+ * #is_fp = 0*10, 1*3#
+ * #is_unsigned = 1*5, 0*5, 0*3#
+ */
+#undef TO_SIMD_SFX
+#if 0
+/**begin repeat1
+ * #len = 8, 16, 32, 64#
+ */
+#elif NPY_SIMD && NPY_BITSOF_@BTYPE@ == @len@
+    #if @is_fp@
+        #define TO_SIMD_SFX(X) X##_f@len@
+        #if NPY_BITSOF_@BTYPE@ == 64 && !NPY_SIMD_F64
+            #undef TO_SIMD_SFX
+        #endif
+        #if NPY_BITSOF_@BTYPE@ == 32 && !NPY_SIMD_F32
+            #undef TO_SIMD_SFX
+        #endif
+    #elif @is_unsigned@
+        #define TO_SIMD_SFX(X) X##_u@len@
+    #else
+        #define TO_SIMD_SFX(X) X##_s@len@
+    #endif
+/**end repeat1**/
+#endif
+
+/**begin repeat1
+ * #func = argmax, argmin#
+ * #op = >, <#
+ * #iop = <, >#
+ */
+NPY_NO_EXPORT int NPY_CPU_DISPATCH_CURFX(@TYPE@_@func@)
+(@type@ *ip, npy_intp n, npy_intp *mindx, PyArrayObject *NPY_UNUSED(aip))
+{
+#if @is_fp@
+    if (npy_isnan(*ip)) {
+        // nan encountered; it's maximal|minimal
+        *mindx = 0;
+        return 0;
+    }
+#endif
+#ifdef TO_SIMD_SFX
+    *mindx = TO_SIMD_SFX(simd_@func@)((TO_SIMD_SFX(npyv_lanetype)*)ip, n);
+    npyv_cleanup();
+#else
+    @type@ mp = *ip;
+    *mindx = 0;
+    npy_intp i = 1;
+
+    for (; i < n; ++i) {
+        @type@ a = ip[i];
+    #if @is_fp@
+        if (!(a @iop@= mp)) {  // negated, for correct nan handling
+    #else
+        if (a @op@ mp) {
+    #endif
+            mp = a;
+            *mindx = i;
+        #if @is_fp@
+            if (npy_isnan(mp)) {
+                // nan encountered, it's maximal|minimal
+                break;
+            }
+        #endif
+        }
+    }
+#endif // TO_SIMD_SFX
+    return 0;
+}
+/**end repeat1**/
+/**end repeat**/
+
+NPY_NO_EXPORT int NPY_CPU_DISPATCH_CURFX(BOOL_argmax)
+(npy_bool *ip, npy_intp len, npy_intp *mindx, PyArrayObject *NPY_UNUSED(aip))
+
+{
+    npy_intp i = 0;
+#if NPY_SIMD
+    const npyv_u8 zero = npyv_zero_u8();
+    const int vstep = npyv_nlanes_u8;
+    const int wstep = vstep * 4;
+    for (npy_intp n = len & -wstep; i < n; i += wstep) {
+        npyv_u8 a = npyv_load_u8(ip + i + vstep*0);
+        npyv_u8 b = npyv_load_u8(ip + i + vstep*1);
+        npyv_u8 c = npyv_load_u8(ip + i + vstep*2);
+        npyv_u8 d = npyv_load_u8(ip + i + vstep*3);
+        npyv_b8 m_a = npyv_cmpeq_u8(a, zero);
+        npyv_b8 m_b = npyv_cmpeq_u8(b, zero);
+        npyv_b8 m_c = npyv_cmpeq_u8(c, zero);
+        npyv_b8 m_d = npyv_cmpeq_u8(d, zero);
+        npyv_b8 m_ab = npyv_and_b8(m_a, m_b);
+        npyv_b8 m_cd = npyv_and_b8(m_c, m_d);
+        npy_uint64 m = npyv_tobits_b8(npyv_and_b8(m_ab, m_cd));
+    #if NPY_SIMD == 512
+        if (m != NPY_MAX_UINT64) {
+    #else
+        if ((npy_int64)m != ((1LL << vstep) - 1)) {
+    #endif
+            break;
+        }
+    }
+    npyv_cleanup();
+#endif // NPY_SIMD
+    for (; i < len; ++i) {
+        if (ip[i]) {
+            *mindx = i;
+            return 0;
+        }
+    }
+    *mindx = 0;
+    return 0;
+}
diff --git a/numpy/core/src/multiarray/array_assign_array.c b/numpy/core/src/multiarray/array_assign_array.c
index 020a7f29a615..7aee7d6e9826 100644
--- a/numpy/core/src/multiarray/array_assign_array.c
+++ b/numpy/core/src/multiarray/array_assign_array.c
@@ -8,11 +8,13 @@
  */
 #define NPY_NO_DEPRECATED_API NPY_API_VERSION
 #define _MULTIARRAYMODULE
+#define _UMATHMODULE
 
 #define PY_SSIZE_T_CLEAN
 #include 
 
 #include "numpy/ndarraytypes.h"
+#include "numpy/npy_math.h"
 
 #include "npy_config.h"
 #include "npy_pycompat.h"
@@ -25,6 +27,8 @@
 #include "array_assign.h"
 #include "dtype_transfer.h"
 
+#include "umathmodule.h"
+
 /*
  * Check that array data is both uint-aligned and true-aligned for all array
  * elements, as required by the copy/casting code in lowlevel_strided_loops.c
@@ -83,7 +87,7 @@ raw_array_assign_array(int ndim, npy_intp const *shape,
     npy_intp src_strides_it[NPY_MAXDIMS];
     npy_intp coord[NPY_MAXDIMS];
 
-    int aligned, needs_api = 0;
+    int aligned;
 
     NPY_BEGIN_THREADS_DEF;
 
@@ -116,15 +120,19 @@ raw_array_assign_array(int ndim, npy_intp const *shape,
 
     /* Get the function to do the casting */
     NPY_cast_info cast_info;
+    NPY_ARRAYMETHOD_FLAGS flags;
     if (PyArray_GetDTypeTransferFunction(aligned,
                         src_strides_it[0], dst_strides_it[0],
                         src_dtype, dst_dtype,
                         0,
-                        &cast_info, &needs_api) != NPY_SUCCEED) {
+                        &cast_info, &flags) != NPY_SUCCEED) {
         return -1;
     }
 
-    if (!needs_api) {
+    if (!(flags & NPY_METH_NO_FLOATINGPOINT_ERRORS)) {
+        npy_clear_floatstatus_barrier((char*)&src_data);
+    }
+    if (!(flags & NPY_METH_REQUIRES_PYAPI)) {
         NPY_BEGIN_THREADS;
     }
 
@@ -143,6 +151,14 @@ raw_array_assign_array(int ndim, npy_intp const *shape,
 
     NPY_END_THREADS;
     NPY_cast_info_xfree(&cast_info);
+
+    if (!(flags & NPY_METH_NO_FLOATINGPOINT_ERRORS)) {
+        int fpes = npy_get_floatstatus_barrier((char*)&src_data);
+        if (fpes && PyUFunc_GiveFloatingpointErrors("cast", fpes) < 0) {
+            return -1;
+        }
+    }
+
     return 0;
 fail:
     NPY_END_THREADS;
@@ -170,7 +186,7 @@ raw_array_wheremasked_assign_array(int ndim, npy_intp const *shape,
     npy_intp wheremask_strides_it[NPY_MAXDIMS];
     npy_intp coord[NPY_MAXDIMS];
 
-    int aligned, needs_api = 0;
+    int aligned;
 
     NPY_BEGIN_THREADS_DEF;
 
@@ -207,17 +223,21 @@ raw_array_wheremasked_assign_array(int ndim, npy_intp const *shape,
 
     /* Get the function to do the casting */
     NPY_cast_info cast_info;
+    NPY_ARRAYMETHOD_FLAGS flags;
     if (PyArray_GetMaskedDTypeTransferFunction(aligned,
                         src_strides_it[0],
                         dst_strides_it[0],
                         wheremask_strides_it[0],
                         src_dtype, dst_dtype, wheremask_dtype,
                         0,
-                        &cast_info, &needs_api) != NPY_SUCCEED) {
+                        &cast_info, &flags) != NPY_SUCCEED) {
         return -1;
     }
 
-    if (!needs_api) {
+    if (!(flags & NPY_METH_NO_FLOATINGPOINT_ERRORS)) {
+        npy_clear_floatstatus_barrier(src_data);
+    }
+    if (!(flags & NPY_METH_REQUIRES_PYAPI)) {
         NPY_BEGIN_THREADS;
     }
     npy_intp strides[2] = {src_strides_it[0], dst_strides_it[0]};
@@ -232,7 +252,7 @@ raw_array_wheremasked_assign_array(int ndim, npy_intp const *shape,
                 args, &shape_it[0], strides,
                 (npy_bool *)wheremask_data, wheremask_strides_it[0],
                 cast_info.auxdata) < 0) {
-            break;
+            goto fail;
         }
     } NPY_RAW_ITER_THREE_NEXT(idim, ndim, coord, shape_it,
                             dst_data, dst_strides_it,
@@ -241,7 +261,20 @@ raw_array_wheremasked_assign_array(int ndim, npy_intp const *shape,
 
     NPY_END_THREADS;
     NPY_cast_info_xfree(&cast_info);
-    return (needs_api && PyErr_Occurred()) ? -1 : 0;
+
+    if (!(flags & NPY_METH_NO_FLOATINGPOINT_ERRORS)) {
+        int fpes = npy_get_floatstatus_barrier(src_data);
+        if (fpes && PyUFunc_GiveFloatingpointErrors("cast", fpes) < 0) {
+            return -1;
+        }
+    }
+
+    return 0;
+
+fail:
+    NPY_END_THREADS;
+    NPY_cast_info_xfree(&cast_info);
+    return -1;
 }
 
 /*
diff --git a/numpy/core/src/multiarray/array_assign_scalar.c b/numpy/core/src/multiarray/array_assign_scalar.c
index 4ffef7ecc96e..ba964b86d3a9 100644
--- a/numpy/core/src/multiarray/array_assign_scalar.c
+++ b/numpy/core/src/multiarray/array_assign_scalar.c
@@ -8,11 +8,13 @@
  */
 #define NPY_NO_DEPRECATED_API NPY_API_VERSION
 #define _MULTIARRAYMODULE
+#define _UMATHMODULE
 
 #define PY_SSIZE_T_CLEAN
 #include 
 
 #include 
+#include "numpy/npy_math.h"
 
 #include "npy_config.h"
 #include "npy_pycompat.h"
@@ -25,6 +27,8 @@
 #include "array_assign.h"
 #include "dtype_transfer.h"
 
+#include "umathmodule.h"
+
 /*
  * Assigns the scalar value to every element of the destination raw array.
  *
@@ -39,7 +43,7 @@ raw_array_assign_scalar(int ndim, npy_intp const *shape,
     npy_intp shape_it[NPY_MAXDIMS], dst_strides_it[NPY_MAXDIMS];
     npy_intp coord[NPY_MAXDIMS];
 
-    int aligned, needs_api = 0;
+    int aligned;
 
     NPY_BEGIN_THREADS_DEF;
 
@@ -62,15 +66,19 @@ raw_array_assign_scalar(int ndim, npy_intp const *shape,
 
     /* Get the function to do the casting */
     NPY_cast_info cast_info;
+    NPY_ARRAYMETHOD_FLAGS flags;
     if (PyArray_GetDTypeTransferFunction(aligned,
                         0, dst_strides_it[0],
                         src_dtype, dst_dtype,
                         0,
-                        &cast_info, &needs_api) != NPY_SUCCEED) {
+                        &cast_info, &flags) != NPY_SUCCEED) {
         return -1;
     }
 
-    if (!needs_api) {
+    if (!(flags & NPY_METH_NO_FLOATINGPOINT_ERRORS)) {
+        npy_clear_floatstatus_barrier(src_data);
+    }
+    if (!(flags & NPY_METH_REQUIRES_PYAPI)) {
         npy_intp nitems = 1, i;
         for (i = 0; i < ndim; i++) {
             nitems *= shape_it[i];
@@ -92,6 +100,14 @@ raw_array_assign_scalar(int ndim, npy_intp const *shape,
 
     NPY_END_THREADS;
     NPY_cast_info_xfree(&cast_info);
+
+    if (!(flags & NPY_METH_NO_FLOATINGPOINT_ERRORS)) {
+        int fpes = npy_get_floatstatus_barrier(src_data);
+        if (fpes && PyUFunc_GiveFloatingpointErrors("cast", fpes) < 0) {
+            return -1;
+        }
+    }
+
     return 0;
 fail:
     NPY_END_THREADS;
@@ -117,7 +133,7 @@ raw_array_wheremasked_assign_scalar(int ndim, npy_intp const *shape,
     npy_intp wheremask_strides_it[NPY_MAXDIMS];
     npy_intp coord[NPY_MAXDIMS];
 
-    int aligned, needs_api = 0;
+    int aligned;
 
     NPY_BEGIN_THREADS_DEF;
 
@@ -142,15 +158,19 @@ raw_array_wheremasked_assign_scalar(int ndim, npy_intp const *shape,
 
     /* Get the function to do the casting */
     NPY_cast_info cast_info;
+    NPY_ARRAYMETHOD_FLAGS flags;
     if (PyArray_GetMaskedDTypeTransferFunction(aligned,
                         0, dst_strides_it[0], wheremask_strides_it[0],
                         src_dtype, dst_dtype, wheremask_dtype,
                         0,
-                        &cast_info, &needs_api) != NPY_SUCCEED) {
+                        &cast_info, &flags) != NPY_SUCCEED) {
         return -1;
     }
 
-    if (!needs_api) {
+    if (!(flags & NPY_METH_NO_FLOATINGPOINT_ERRORS)) {
+        npy_clear_floatstatus_barrier(src_data);
+    }
+    if (!(flags & NPY_METH_REQUIRES_PYAPI)) {
         npy_intp nitems = 1, i;
         for (i = 0; i < ndim; i++) {
             nitems *= shape_it[i];
@@ -170,7 +190,7 @@ raw_array_wheremasked_assign_scalar(int ndim, npy_intp const *shape,
                 args, &shape_it[0], strides,
                 (npy_bool *)wheremask_data, wheremask_strides_it[0],
                 cast_info.auxdata) < 0) {
-            break;
+            goto fail;
         }
     } NPY_RAW_ITER_TWO_NEXT(idim, ndim, coord, shape_it,
                             dst_data, dst_strides_it,
@@ -178,7 +198,20 @@ raw_array_wheremasked_assign_scalar(int ndim, npy_intp const *shape,
 
     NPY_END_THREADS;
     NPY_cast_info_xfree(&cast_info);
-    return (needs_api && PyErr_Occurred()) ? -1 : 0;
+
+    if (!(flags & NPY_METH_NO_FLOATINGPOINT_ERRORS)) {
+        int fpes = npy_get_floatstatus_barrier(src_data);
+        if (fpes && PyUFunc_GiveFloatingpointErrors("cast", fpes) < 0) {
+            return -1;
+        }
+    }
+
+    return 0;
+
+fail:
+    NPY_END_THREADS;
+    NPY_cast_info_xfree(&cast_info);
+    return -1;
 }
 
 /*
diff --git a/numpy/core/src/multiarray/array_coercion.c b/numpy/core/src/multiarray/array_coercion.c
index 2598e4bde6ea..0241fb82cc86 100644
--- a/numpy/core/src/multiarray/array_coercion.c
+++ b/numpy/core/src/multiarray/array_coercion.c
@@ -9,18 +9,21 @@
 
 #include "lowlevel_strided_loops.h"
 #include "numpy/arrayobject.h"
+#include "numpy/npy_math.h"
 
 #include "descriptor.h"
 #include "convert_datatype.h"
 #include "common_dtype.h"
 #include "dtypemeta.h"
 
+#include "abstractdtypes.h"
 #include "array_coercion.h"
 #include "ctors.h"
 #include "common.h"
 #include "_datetime.h"
 #include "npy_import.h"
 
+#include "umathmodule.h"
 
 /*
  * This file defines helpers for some of the ctors.c functions which
@@ -67,8 +70,8 @@
  *
  * The code here avoid multiple conversion of array-like objects (including
  * sequences). These objects are cached after conversion, which will require
- * additional memory, but can drastically speed up coercion from from array
- * like objects.
+ * additional memory, but can drastically speed up coercion from array like
+ * objects.
  */
 
 
@@ -204,7 +207,7 @@ _PyArray_MapPyTypeToDType(
  * Lookup the DType for a registered known python scalar type.
  *
  * @param pytype Python Type to look up
- * @return DType, None if it a known non-scalar, or NULL if an unknown object.
+ * @return DType, None if it is a known non-scalar, or NULL if an unknown object.
  */
 static NPY_INLINE PyArray_DTypeMeta *
 npy_discover_dtype_from_pytype(PyTypeObject *pytype)
@@ -212,24 +215,38 @@ npy_discover_dtype_from_pytype(PyTypeObject *pytype)
     PyObject *DType;
 
     if (pytype == &PyArray_Type) {
-        Py_INCREF(Py_None);
-        return (PyArray_DTypeMeta *)Py_None;
+        DType = Py_None;
     }
-
-    DType = PyDict_GetItem(_global_pytype_to_type_dict, (PyObject *)pytype);
-    if (DType == NULL) {
-        /* the python type is not known */
-        return NULL;
+    else if (pytype == &PyFloat_Type) {
+        DType = (PyObject *)&PyArray_PyFloatAbstractDType;
+    }
+    else if (pytype == &PyLong_Type) {
+        DType = (PyObject *)&PyArray_PyIntAbstractDType;
     }
+    else {
+        DType = PyDict_GetItem(_global_pytype_to_type_dict,
+                               (PyObject *)pytype);
 
-    Py_INCREF(DType);
-    if (DType == Py_None) {
-        return (PyArray_DTypeMeta *)Py_None;
+        if (DType == NULL) {
+            /* the python type is not known */
+            return NULL;
+        }
     }
-    assert(PyObject_TypeCheck(DType, (PyTypeObject *)&PyArrayDTypeMeta_Type));
+    Py_INCREF(DType);
+    assert(DType == Py_None || PyObject_TypeCheck(DType, (PyTypeObject *)&PyArrayDTypeMeta_Type));
     return (PyArray_DTypeMeta *)DType;
 }
 
+/*
+ * Note: This function never fails, but will return `NULL` for unknown scalars
+ *       and `None` for known array-likes (e.g. tuple, list, ndarray).
+ */
+NPY_NO_EXPORT PyObject *
+PyArray_DiscoverDTypeFromScalarType(PyTypeObject *pytype)
+{
+    return (PyObject *)npy_discover_dtype_from_pytype(pytype);
+}
+
 
 /**
  * Find the correct DType class for the given python type. If flags is NULL
@@ -363,6 +380,49 @@ find_scalar_descriptor(
 }
 
 
+/*
+ * Helper function for casting a raw value from one descriptor to another.
+ * This helper uses the normal casting machinery, but e.g. does not care about
+ * checking cast safety.
+ */
+static int
+cast_raw_scalar_item(
+        PyArray_Descr *from_descr, char *from_item,
+        PyArray_Descr *to_descr, char *to_item)
+{
+    NPY_cast_info cast_info;
+    NPY_ARRAYMETHOD_FLAGS flags;
+    if (PyArray_GetDTypeTransferFunction(
+            0, 0, 0, from_descr, to_descr, 0, &cast_info,
+            &flags) == NPY_FAIL) {
+        return -1;
+    }
+
+    if (!(flags & NPY_METH_NO_FLOATINGPOINT_ERRORS)) {
+        npy_clear_floatstatus_barrier(from_item);
+    }
+
+    char *args[2] = {from_item, to_item};
+    const npy_intp strides[2] = {0, 0};
+    const npy_intp length = 1;
+    if (cast_info.func(&cast_info.context,
+            args, &length, strides, cast_info.auxdata) < 0) {
+        NPY_cast_info_xfree(&cast_info);
+        return -1;
+    }
+    NPY_cast_info_xfree(&cast_info);
+
+    if (!(flags & NPY_METH_NO_FLOATINGPOINT_ERRORS)) {
+        int fpes = npy_get_floatstatus_barrier(to_item);
+        if (fpes && PyUFunc_GiveFloatingpointErrors("cast", fpes) < 0) {
+            return -1;
+        }
+    }
+
+    return 0;
+}
+
+
 /**
  * Assign a single element in an array from a python value.
  *
@@ -373,26 +433,35 @@ find_scalar_descriptor(
  * This function handles the cast, which is for example hit when assigning
  * a float128 to complex128.
  *
- * At this time, this function does not support arrays (historically we
- * mainly supported arrays through `__float__()`, etc.). Such support should
- * possibly be added (although when called from `PyArray_AssignFromCache`
- * the input cannot be an array).
- * Note that this is also problematic for some array-likes, such as
- * `astropy.units.Quantity` and `np.ma.masked`.  These are used to us calling
- * `__float__`/`__int__` for 0-D instances in many cases.
- * Eventually, we may want to define this as wrong: They must use DTypes
- * instead of (only) subclasses.  Until then, here as well as in
- * `PyArray_AssignFromCache` (which already does this), we need to special
- * case 0-D array-likes to behave like arbitrary (unknown!) Python objects.
+ * TODO: This function probably needs to be passed an "owner" for the sake of
+ *       future HPy (non CPython) support
+ *
+ * NOTE: We do support 0-D exact NumPy arrays correctly via casting here.
+ *       There be dragons, because we must NOT support generic array-likes.
+ *       The problem is that some (e.g. astropy's Quantity and our masked
+ *       arrays) have divergent behaviour for `__array__` as opposed to
+ *       `__float__`.  And they rely on that.
+ *       That is arguably bad as it limits the things that work seamlessly
+ *       because `__float__`, etc. cannot even begin to cover all of casting.
+ *       However, we have no choice.  We simply CANNOT support array-likes
+ *       here without finding a solution for this first.
+ *       And the only plausible one I see currently, is expanding protocols
+ *       in some form, either to indicate that we want a scalar or to indicate
+ *       that we want the unsafe version that `__array__` currently gives
+ *       for both objects.
+ *
+ *       If we ever figure out how to expand this to other array-likes, care
+ *       may need to be taken. `PyArray_FromAny`/`PyArray_AssignFromCache`
+ *       uses this function but know if the input is an array, array-like,
+ *       or scalar.  Relaxing things here should be OK, but looks a bit
+ *       like possible recursion, so it may make sense to make a "scalars only"
+ *       version of this function.
  *
  * @param descr
  * @param item
  * @param value
  * @return 0 on success -1 on failure.
  */
-/*
- * TODO: This function should possibly be public API.
- */
 NPY_NO_EXPORT int
 PyArray_Pack(PyArray_Descr *descr, char *item, PyObject *value)
 {
@@ -418,6 +487,29 @@ PyArray_Pack(PyArray_Descr *descr, char *item, PyObject *value)
     if (DType == NULL) {
         return -1;
     }
+    if (DType == (PyArray_DTypeMeta *)Py_None && PyArray_CheckExact(value)
+            && PyArray_NDIM((PyArrayObject *)value) == 0) {
+        /*
+         * WARNING: Do NOT relax the above `PyArray_CheckExact`, unless you
+         *          read the function doc NOTE carefully and understood it.
+         *
+         * NOTE: The ndim == 0 check should probably be an error, but
+         *       unfortunately. `arr.__float__()` works for 1 element arrays
+         *       so in some contexts we need to let it handled like a scalar.
+         *       (If we manage to deprecate the above, we can do that.)
+         */
+        Py_DECREF(DType);
+
+        PyArrayObject *arr = (PyArrayObject *)value;
+        if (PyArray_DESCR(arr) == descr && !PyDataType_REFCHK(descr)) {
+            /* light-weight fast-path for when the descrs obviously matches */
+            memcpy(item, PyArray_BYTES(arr), descr->elsize);
+            return 0;  /* success (it was an array-like) */
+        }
+        return cast_raw_scalar_item(
+                PyArray_DESCR(arr), PyArray_BYTES(arr), descr, item);
+
+    }
     if (DType == NPY_DTYPE(descr) || DType == (PyArray_DTypeMeta *)Py_None) {
         /* We can set the element directly (or at least will try to) */
         Py_XDECREF(DType);
@@ -446,30 +538,8 @@ PyArray_Pack(PyArray_Descr *descr, char *item, PyObject *value)
         Py_DECREF(tmp_descr);
         return -1;
     }
-    if (PyDataType_REFCHK(tmp_descr)) {
-        /* We could probably use move-references above */
-        PyArray_Item_INCREF(data, tmp_descr);
-    }
+    int res = cast_raw_scalar_item(tmp_descr, data, descr, item);
 
-    int res = 0;
-    int needs_api = 0;
-    NPY_cast_info cast_info;
-    if (PyArray_GetDTypeTransferFunction(
-            0, 0, 0, tmp_descr, descr, 0, &cast_info,
-            &needs_api) == NPY_FAIL) {
-        res = -1;
-        goto finish;
-    }
-    char *args[2] = {data, item};
-    const npy_intp strides[2] = {0, 0};
-    const npy_intp length = 1;
-    if (cast_info.func(&cast_info.context,
-            args, &length, strides, cast_info.auxdata) < 0) {
-        res = -1;
-    }
-    NPY_cast_info_xfree(&cast_info);
-
-  finish:
     if (PyDataType_REFCHK(tmp_descr)) {
         /* We could probably use move-references above */
         PyArray_Item_XDECREF(data, tmp_descr);
@@ -482,8 +552,8 @@ PyArray_Pack(PyArray_Descr *descr, char *item, PyObject *value)
 
 static int
 update_shape(int curr_ndim, int *max_ndim,
-             npy_intp out_shape[NPY_MAXDIMS], int new_ndim,
-             const npy_intp new_shape[NPY_MAXDIMS], npy_bool sequence,
+             npy_intp out_shape[], int new_ndim,
+             const npy_intp new_shape[], npy_bool sequence,
              enum _dtype_discovery_flags *flags)
 {
     int success = 0;  /* unsuccessful if array is ragged */
@@ -1237,95 +1307,10 @@ PyArray_DiscoverDTypeAndShape(
         /* Handle reaching the maximum depth differently: */
         int too_deep = ndim == max_dims;
 
-        if (fixed_DType == NULL) {
-            /* This is discovered as object, but deprecated */
-            static PyObject *visibleDeprecationWarning = NULL;
-            npy_cache_import(
-                    "numpy", "VisibleDeprecationWarning",
-                    &visibleDeprecationWarning);
-            if (visibleDeprecationWarning == NULL) {
-                goto fail;
-            }
-            if (!too_deep) {
-                /* NumPy 1.19, 2019-11-01 */
-                if (PyErr_WarnEx(visibleDeprecationWarning,
-                        "Creating an ndarray from ragged nested sequences (which "
-                        "is a list-or-tuple of lists-or-tuples-or ndarrays with "
-                        "different lengths or shapes) is deprecated. If you "
-                        "meant to do this, you must specify 'dtype=object' "
-                        "when creating the ndarray.", 1) < 0) {
-                    goto fail;
-                }
-            }
-            else {
-                /* NumPy 1.20, 2020-05-08 */
-                /* Note, max_dims should normally always be NPY_MAXDIMS here */
-                if (PyErr_WarnFormat(visibleDeprecationWarning, 1,
-                        "Creating an ndarray from nested sequences exceeding "
-                        "the maximum number of dimensions of %d is deprecated. "
-                        "If you mean to do this, you must specify "
-                        "'dtype=object' when creating the ndarray.",
-                        max_dims) < 0) {
-                    goto fail;
-                }
-            }
-            /* Ensure that ragged arrays always return object dtype */
-            Py_XSETREF(*out_descr, PyArray_DescrFromType(NPY_OBJECT));
-        }
-        else if (fixed_DType->type_num != NPY_OBJECT) {
+        if (fixed_DType == NULL || fixed_DType->type_num != NPY_OBJECT) {
             /* Only object DType supports ragged cases unify error */
 
-            /*
-             * We used to let certain ragged arrays pass if they also
-             * support e.g. conversion using `float(arr)`, which currently
-             * works for arrays with only one element.
-             * Thus we catch at least most of such cases here and give a
-             * DeprecationWarning instead of an error.
-             * Note that some of these will actually error later on when
-             * attempting to do the actual assign.
-             */
-            int deprecate_single_element_ragged = 0;
-            coercion_cache_obj *current = *coercion_cache_head;
-            while (current != NULL) {
-                if (current->sequence) {
-                    if (current->depth == ndim) {
-                        /*
-                         * Assume that only array-likes will allow the deprecated
-                         * behaviour
-                         */
-                        deprecate_single_element_ragged = 0;
-                        break;
-                    }
-                    /* check next converted sequence/array-like */
-                    current = current->next;
-                    continue;
-                }
-                PyArrayObject *arr = (PyArrayObject *)(current->arr_or_sequence);
-                assert(PyArray_NDIM(arr) + current->depth >= ndim);
-                if (PyArray_NDIM(arr) != ndim - current->depth) {
-                    /* This array is not compatible with the final shape */
-                    if (PyArray_SIZE(arr) != 1) {
-                        deprecate_single_element_ragged = 0;
-                        break;
-                    }
-                    deprecate_single_element_ragged = 1;
-                }
-                current = current->next;
-            }
-
-            if (deprecate_single_element_ragged) {
-                /* Deprecated 2020-07-24, NumPy 1.20 */
-                if (DEPRECATE(
-                        "setting an array element with a sequence. "
-                        "This was supported in some cases where the elements "
-                        "are arrays with a single element. For example "
-                        "`np.array([1, np.array([2])], dtype=int)`. "
-                        "In the future this will raise the same ValueError as "
-                        "`np.array([1, [2]], dtype=int)`.") < 0) {
-                    goto fail;
-                }
-            }
-            else if (!too_deep) {
+            if (!too_deep) {
                 PyObject *shape = PyArray_IntTupleFromIntp(ndim, out_shape);
                 PyErr_Format(PyExc_ValueError,
                         "setting an array element with a sequence. The "
@@ -1334,7 +1319,6 @@ PyArray_DiscoverDTypeAndShape(
                         "%R + inhomogeneous part.",
                         ndim, shape);
                 Py_DECREF(shape);
-                goto fail;
             }
             else {
                 PyErr_Format(PyExc_ValueError,
@@ -1342,8 +1326,8 @@ PyArray_DiscoverDTypeAndShape(
                         "requested array would exceed the maximum number of "
                         "dimension of %d.",
                         max_dims);
-                goto fail;
             }
+            goto fail;
         }
 
         /*
diff --git a/numpy/core/src/multiarray/array_coercion.h b/numpy/core/src/multiarray/array_coercion.h
index f2482cecc005..63d543cf7508 100644
--- a/numpy/core/src/multiarray/array_coercion.h
+++ b/numpy/core/src/multiarray/array_coercion.h
@@ -19,6 +19,9 @@ NPY_NO_EXPORT int
 _PyArray_MapPyTypeToDType(
         PyArray_DTypeMeta *DType, PyTypeObject *pytype, npy_bool userdef);
 
+NPY_NO_EXPORT PyObject *
+PyArray_DiscoverDTypeFromScalarType(PyTypeObject *pytype);
+
 NPY_NO_EXPORT int
 PyArray_Pack(PyArray_Descr *descr, char *item, PyObject *value);
 
diff --git a/numpy/core/src/multiarray/array_method.c b/numpy/core/src/multiarray/array_method.c
index d93dac506949..ff74a4530690 100644
--- a/numpy/core/src/multiarray/array_method.c
+++ b/numpy/core/src/multiarray/array_method.c
@@ -48,13 +48,19 @@
  *
  * We could allow setting the output descriptors specifically to simplify
  * this step.
+ *
+ * Note that the default version will indicate that the cast can be done
+ * as using `arr.view(new_dtype)` if the default cast-safety is
+ * set to "no-cast".  This default function cannot be used if a view may
+ * be sufficient for casting but the cast is not always "no-cast".
  */
 static NPY_CASTING
 default_resolve_descriptors(
         PyArrayMethodObject *method,
         PyArray_DTypeMeta **dtypes,
         PyArray_Descr **input_descrs,
-        PyArray_Descr **output_descrs)
+        PyArray_Descr **output_descrs,
+        npy_intp *view_offset)
 {
     int nin = method->nin;
     int nout = method->nout;
@@ -62,7 +68,7 @@ default_resolve_descriptors(
     for (int i = 0; i < nin + nout; i++) {
         PyArray_DTypeMeta *dtype = dtypes[i];
         if (input_descrs[i] != NULL) {
-            output_descrs[i] = ensure_dtype_nbo(input_descrs[i]);
+            output_descrs[i] = NPY_DT_CALL_ensure_canonical(input_descrs[i]);
         }
         else {
             output_descrs[i] = NPY_DT_CALL_default_descr(dtype);
@@ -76,6 +82,13 @@ default_resolve_descriptors(
      * abstract ones or unspecified outputs).  We can use the common-dtype
      * operation to provide a default here.
      */
+    if (method->casting == NPY_NO_CASTING) {
+        /*
+         * By (current) definition no-casting should imply viewable.  This
+         * is currently indicated for example for object to object cast.
+         */
+        *view_offset = 0;
+    }
     return method->casting;
 
   fail:
@@ -102,9 +115,10 @@ is_contiguous(
 /**
  * The default method to fetch the correct loop for a cast or ufunc
  * (at the time of writing only casts).
- * The default version can return loops explicitly registered during method
- * creation. It does specialize contiguous loops, although has to check
- * all descriptors itemsizes for this.
+ * Note that the default function provided here will only indicate that a cast
+ * can be done as a view (i.e., arr.view(new_dtype)) when this is trivially
+ * true, i.e., for cast safety "no-cast". It will not recognize view as an
+ * option for other casts (e.g., viewing '>i8' as '>i4' with an offset of 4).
  *
  * @param context
  * @param aligned
@@ -119,7 +133,7 @@ is_contiguous(
 NPY_NO_EXPORT int
 npy_default_get_strided_loop(
         PyArrayMethod_Context *context,
-        int aligned, int NPY_UNUSED(move_references), npy_intp *strides,
+        int aligned, int NPY_UNUSED(move_references), const npy_intp *strides,
         PyArrayMethod_StridedLoop **out_loop, NpyAuxData **out_transferdata,
         NPY_ARRAYMETHOD_FLAGS *flags)
 {
@@ -166,7 +180,7 @@ validate_spec(PyArrayMethod_Spec *spec)
                 "not exceed %d. (method: %s)", NPY_MAXARGS, spec->name);
         return -1;
     }
-    switch (spec->casting & ~_NPY_CAST_IS_VIEW) {
+    switch (spec->casting) {
         case NPY_NO_CASTING:
         case NPY_EQUIV_CASTING:
         case NPY_SAFE_CASTING:
@@ -247,12 +261,17 @@ fill_arraymethod_from_slots(
                 meth->resolve_descriptors = slot->pfunc;
                 continue;
             case NPY_METH_get_loop:
-                if (private) {
-                    /* Only allow override for private functions initially */
-                    meth->get_strided_loop = slot->pfunc;
-                    continue;
-                }
-                break;
+                /*
+                 * NOTE: get_loop is considered "unstable" in the public API,
+                 *       I do not like the signature, and the `move_references`
+                 *       parameter must NOT be used.
+                 *       (as in: we should not worry about changing it, but of
+                 *       course that would not break it immediately.)
+                 */
+                /* Only allow override for private functions initially */
+                meth->get_strided_loop = slot->pfunc;
+                continue;
+            /* "Typical" loops, supported used by the default `get_loop` */
             case NPY_METH_strided_loop:
                 meth->strided_loop = slot->pfunc;
                 continue;
@@ -446,6 +465,15 @@ arraymethod_dealloc(PyObject *self)
 
     PyMem_Free(meth->name);
 
+    if (meth->wrapped_meth != NULL) {
+        /* Cleanup for wrapping array method (defined in umath) */
+        Py_DECREF(meth->wrapped_meth);
+        for (int i = 0; i < meth->nin + meth->nout; i++) {
+            Py_XDECREF(meth->wrapped_dtypes[i]);
+        }
+        PyMem_Free(meth->wrapped_dtypes);
+    }
+
     Py_TYPE(self)->tp_free(self);
 }
 
@@ -454,8 +482,8 @@ NPY_NO_EXPORT PyTypeObject PyArrayMethod_Type = {
     PyVarObject_HEAD_INIT(NULL, 0)
     .tp_name = "numpy._ArrayMethod",
     .tp_basicsize = sizeof(PyArrayMethodObject),
-    .tp_flags = Py_TPFLAGS_DEFAULT,
     .tp_dealloc = arraymethod_dealloc,
+    .tp_flags = Py_TPFLAGS_DEFAULT,
 };
 
 
@@ -495,8 +523,9 @@ boundarraymethod_dealloc(PyObject *self)
 
 
 /*
- * Calls resolve_descriptors() and returns the casting level and the resolved
- * descriptors as a tuple. If the operation is impossible returns (-1, None).
+ * Calls resolve_descriptors() and returns the casting level, the resolved
+ * descriptors as a tuple, and a possible view-offset (integer or None).
+ * If the operation is impossible returns (-1, None, None).
  * May raise an error, but usually should not.
  * The function validates the casting attribute compared to the returned
  * casting level.
@@ -551,14 +580,15 @@ boundarraymethod__resolve_descripors(
         }
     }
 
+    npy_intp view_offset = NPY_MIN_INTP;
     NPY_CASTING casting = self->method->resolve_descriptors(
-            self->method, self->dtypes, given_descrs, loop_descrs);
+            self->method, self->dtypes, given_descrs, loop_descrs, &view_offset);
 
     if (casting < 0 && PyErr_Occurred()) {
         return NULL;
     }
     else if (casting < 0) {
-        return Py_BuildValue("iO", casting, Py_None);
+        return Py_BuildValue("iOO", casting, Py_None, Py_None);
     }
 
     PyObject *result_tuple = PyTuple_New(nin + nout);
@@ -570,9 +600,22 @@ boundarraymethod__resolve_descripors(
         PyTuple_SET_ITEM(result_tuple, i, (PyObject *)loop_descrs[i]);
     }
 
+    PyObject *view_offset_obj;
+    if (view_offset == NPY_MIN_INTP) {
+        Py_INCREF(Py_None);
+        view_offset_obj = Py_None;
+    }
+    else {
+        view_offset_obj = PyLong_FromSsize_t(view_offset);
+        if (view_offset_obj == NULL) {
+            Py_DECREF(result_tuple);
+            return NULL;
+        }
+    }
+
     /*
-     * The casting flags should be the most generic casting level (except the
-     * cast-is-view flag.  If no input is parametric, it must match exactly.
+     * The casting flags should be the most generic casting level.
+     * If no input is parametric, it must match exactly.
      *
      * (Note that these checks are only debugging checks.)
      */
@@ -584,7 +627,7 @@ boundarraymethod__resolve_descripors(
         }
     }
     if (self->method->casting != -1) {
-        NPY_CASTING cast = casting & ~_NPY_CAST_IS_VIEW;
+        NPY_CASTING cast = casting;
         if (self->method->casting !=
                 PyArray_MinCastSafety(cast, self->method->casting)) {
             PyErr_Format(PyExc_RuntimeError,
@@ -592,6 +635,7 @@ boundarraymethod__resolve_descripors(
                     "(set level is %d, got %d for method %s)",
                     self->method->casting, cast, self->method->name);
             Py_DECREF(result_tuple);
+            Py_DECREF(view_offset_obj);
             return NULL;
         }
         if (!parametric) {
@@ -608,12 +652,13 @@ boundarraymethod__resolve_descripors(
                         "(set level is %d, got %d for method %s)",
                         self->method->casting, cast, self->method->name);
                 Py_DECREF(result_tuple);
+                Py_DECREF(view_offset_obj);
                 return NULL;
             }
         }
     }
 
-    return Py_BuildValue("iN", casting, result_tuple);
+    return Py_BuildValue("iNN", casting, result_tuple, view_offset_obj);
 }
 
 
@@ -694,8 +739,9 @@ boundarraymethod__simple_strided_call(
         return NULL;
     }
 
+    npy_intp view_offset = NPY_MIN_INTP;
     NPY_CASTING casting = self->method->resolve_descriptors(
-            self->method, self->dtypes, descrs, out_descrs);
+            self->method, self->dtypes, descrs, out_descrs, &view_offset);
 
     if (casting < 0) {
         PyObject *err_type = NULL, *err_value = NULL, *err_traceback = NULL;
@@ -817,15 +863,17 @@ generic_masked_strided_loop(PyArrayMethod_Context *context,
 
         /* Process unmasked values */
         mask = npy_memchr(mask, 0, mask_stride, N, &subloopsize, 0);
-        int res = strided_loop(context,
-                dataptrs, &subloopsize, strides, strided_loop_auxdata);
-        if (res != 0) {
-            return res;
-        }
-        for (int i = 0; i < nargs; i++) {
-            dataptrs[i] += subloopsize * strides[i];
+        if (subloopsize > 0) {
+            int res = strided_loop(context,
+                    dataptrs, &subloopsize, strides, strided_loop_auxdata);
+            if (res != 0) {
+                return res;
+            }
+            for (int i = 0; i < nargs; i++) {
+                dataptrs[i] += subloopsize * strides[i];
+            }
+            N -= subloopsize;
         }
-        N -= subloopsize;
     } while (N > 0);
 
     return 0;
@@ -903,9 +951,9 @@ NPY_NO_EXPORT PyTypeObject PyBoundArrayMethod_Type = {
     PyVarObject_HEAD_INIT(NULL, 0)
     .tp_name = "numpy._BoundArrayMethod",
     .tp_basicsize = sizeof(PyBoundArrayMethodObject),
-    .tp_flags = Py_TPFLAGS_DEFAULT,
-    .tp_repr = (reprfunc)boundarraymethod_repr,
     .tp_dealloc = boundarraymethod_dealloc,
+    .tp_repr = (reprfunc)boundarraymethod_repr,
+    .tp_flags = Py_TPFLAGS_DEFAULT,
     .tp_methods = boundarraymethod_methods,
     .tp_getset = boundarraymethods_getters,
 };
diff --git a/numpy/core/src/multiarray/array_method.h b/numpy/core/src/multiarray/array_method.h
index 7b7372bd0b59..c9ec8903d1bb 100644
--- a/numpy/core/src/multiarray/array_method.h
+++ b/numpy/core/src/multiarray/array_method.h
@@ -7,6 +7,9 @@
 #include 
 #include 
 
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 typedef enum {
     /* Flag for whether the GIL is required */
@@ -17,7 +20,11 @@ typedef enum {
      * setup/check. No function should set error flags and ignore them
      * since it would interfere with chaining operations (e.g. casting).
      */
-    /* TODO: Change this into a positive flag */
+    /*
+     * TODO: Change this into a positive flag?  That would make "combing"
+     *       multiple methods easier. OTOH, if we add more flags, the default
+     *       would be 0 just like it is here.
+     */
     NPY_METH_NO_FLOATINGPOINT_ERRORS = 1 << 2,
     /* Whether the method supports unaligned access (not runtime) */
     NPY_METH_SUPPORTS_UNALIGNED = 1 << 3,
@@ -40,6 +47,20 @@ typedef enum {
 } NPY_ARRAYMETHOD_FLAGS;
 
 
+/*
+ * It would be nice to just | flags, but in general it seems that 0 bits
+ * probably should indicate "default".
+ * And that is not necessarily compatible with `|`.
+ *
+ * NOTE: If made public, should maybe be a function to easier add flags?
+ */
+#define PyArrayMethod_MINIMAL_FLAGS NPY_METH_NO_FLOATINGPOINT_ERRORS
+#define PyArrayMethod_COMBINED_FLAGS(flags1, flags2)  \
+        ((NPY_ARRAYMETHOD_FLAGS)(  \
+            ((flags1 | flags2) & ~PyArrayMethod_MINIMAL_FLAGS)  \
+            | (flags1 & flags2)))
+
+
 struct PyArrayMethodObject_tag;
 
 /*
@@ -70,18 +91,71 @@ typedef NPY_CASTING (resolve_descriptors_function)(
         struct PyArrayMethodObject_tag *method,
         PyArray_DTypeMeta **dtypes,
         PyArray_Descr **given_descrs,
-        PyArray_Descr **loop_descrs);
+        PyArray_Descr **loop_descrs,
+        npy_intp *view_offset);
 
 
 typedef int (get_loop_function)(
         PyArrayMethod_Context *context,
         int aligned, int move_references,
-        npy_intp *strides,
+        const npy_intp *strides,
         PyArrayMethod_StridedLoop **out_loop,
         NpyAuxData **out_transferdata,
         NPY_ARRAYMETHOD_FLAGS *flags);
 
 
+/*
+ * The following functions are only used be the wrapping array method defined
+ * in umath/wrapping_array_method.c
+ */
+
+/*
+ * The function to convert the given descriptors (passed in to
+ * `resolve_descriptors`) and translates them for the wrapped loop.
+ * The new descriptors MUST be viewable with the old ones, `NULL` must be
+ * supported (for outputs) and should normally be forwarded.
+ *
+ * The function must clean up on error.
+ *
+ * NOTE: We currently assume that this translation gives "viewable" results.
+ *       I.e. there is no additional casting related to the wrapping process.
+ *       In principle that could be supported, but not sure it is useful.
+ *       This currently also means that e.g. alignment must apply identically
+ *       to the new dtypes.
+ *
+ * TODO: Due to the fact that `resolve_descriptors` is also used for `can_cast`
+ *       there is no way to "pass out" the result of this function.  This means
+ *       it will be called twice for every ufunc call.
+ *       (I am considering including `auxdata` as an "optional" parameter to
+ *       `resolve_descriptors`, so that it can be filled there if not NULL.)
+ */
+typedef int translate_given_descrs_func(int nin, int nout,
+        PyArray_DTypeMeta *wrapped_dtypes[],
+        PyArray_Descr *given_descrs[], PyArray_Descr *new_descrs[]);
+
+/**
+ * The function to convert the actual loop descriptors (as returned by the
+ * original `resolve_descriptors` function) to the ones the output array
+ * should use.
+ * This function must return "viewable" types, it must not mutate them in any
+ * form that would break the inner-loop logic.  Does not need to support NULL.
+ *
+ * The function must clean up on error.
+ *
+ * @param nargs Number of arguments
+ * @param new_dtypes The DTypes of the output (usually probably not needed)
+ * @param given_descrs Original given_descrs to the resolver, necessary to
+ *        fetch any information related to the new dtypes from the original.
+ * @param original_descrs The `loop_descrs` returned by the wrapped loop.
+ * @param loop_descrs The output descriptors, compatible to `original_descrs`.
+ *
+ * @returns 0 on success, -1 on failure.
+ */
+typedef int translate_loop_descrs_func(int nin, int nout,
+        PyArray_DTypeMeta *new_dtypes[], PyArray_Descr *given_descrs[],
+        PyArray_Descr *original_descrs[], PyArray_Descr *loop_descrs[]);
+
+
 /*
  * This struct will be public and necessary for creating a new ArrayMethod
  * object (casting and ufuncs).
@@ -124,6 +198,11 @@ typedef struct PyArrayMethodObject_tag {
     PyArrayMethod_StridedLoop *contiguous_loop;
     PyArrayMethod_StridedLoop *unaligned_strided_loop;
     PyArrayMethod_StridedLoop *unaligned_contiguous_loop;
+    /* Chunk only used for wrapping array method defined in umath */
+    struct PyArrayMethodObject_tag *wrapped_meth;
+    PyArray_DTypeMeta **wrapped_dtypes;
+    translate_given_descrs_func *translate_given_descrs;
+    translate_loop_descrs_func *translate_loop_descrs;
 } PyArrayMethodObject;
 
 
@@ -166,7 +245,7 @@ extern NPY_NO_EXPORT PyTypeObject PyBoundArrayMethod_Type;
 NPY_NO_EXPORT int
 npy_default_get_strided_loop(
         PyArrayMethod_Context *context,
-        int aligned, int NPY_UNUSED(move_references), npy_intp *strides,
+        int aligned, int NPY_UNUSED(move_references), const npy_intp *strides,
         PyArrayMethod_StridedLoop **out_loop, NpyAuxData **out_transferdata,
         NPY_ARRAYMETHOD_FLAGS *flags);
 
@@ -191,6 +270,10 @@ PyArrayMethod_FromSpec(PyArrayMethod_Spec *spec);
  *       need better tests when a public version is exposed.
  */
 NPY_NO_EXPORT PyBoundArrayMethodObject *
-PyArrayMethod_FromSpec_int(PyArrayMethod_Spec *spec, int private);
+PyArrayMethod_FromSpec_int(PyArrayMethod_Spec *spec, int priv);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif  /* NUMPY_CORE_SRC_MULTIARRAY_ARRAY_METHOD_H_ */
diff --git a/numpy/core/src/multiarray/arrayfunction_override.c b/numpy/core/src/multiarray/arrayfunction_override.c
index 463a2d4d8724..a3d55bdc22d4 100644
--- a/numpy/core/src/multiarray/arrayfunction_override.c
+++ b/numpy/core/src/multiarray/arrayfunction_override.c
@@ -37,7 +37,7 @@ get_array_function(PyObject *obj)
         return ndarray_array_function;
     }
 
-    PyObject *array_function = PyArray_LookupSpecial(obj, "__array_function__");
+    PyObject *array_function = PyArray_LookupSpecial(obj, npy_ma_str_array_function);
     if (array_function == NULL && PyErr_Occurred()) {
         PyErr_Clear(); /* TODO[gh-14801]: propagate crashes during attribute access? */
     }
@@ -63,7 +63,7 @@ pyobject_array_insert(PyObject **array, int length, int index, PyObject *item)
  * Collects arguments with __array_function__ and their corresponding methods
  * in the order in which they should be tried (i.e., skipping redundant types).
  * `relevant_args` is expected to have been produced by PySequence_Fast.
- * Returns the number of arguments, or -1 on failure. 
+ * Returns the number of arguments, or -1 on failure.
  */
 static int
 get_implementing_args_and_methods(PyObject *relevant_args,
@@ -333,11 +333,17 @@ NPY_NO_EXPORT PyObject *
 array_implement_array_function(
     PyObject *NPY_UNUSED(dummy), PyObject *positional_args)
 {
-    PyObject *implementation, *public_api, *relevant_args, *args, *kwargs;
+    PyObject *res, *implementation, *public_api, *relevant_args, *args, *kwargs;
+    /*
+     * Very few functions use **kwargs, only check for like then (note that
+     * this is a backport only change, 1.25.x has been refactored)
+     */
+    PyObject *uses_like;
 
     if (!PyArg_UnpackTuple(
-            positional_args, "implement_array_function", 5, 5,
-            &implementation, &public_api, &relevant_args, &args, &kwargs)) {
+            positional_args, "implement_array_function", 6, 6,
+            &implementation, &public_api, &relevant_args, &args, &kwargs,
+            &uses_like)) {
         return NULL;
     }
 
@@ -346,7 +352,8 @@ array_implement_array_function(
      * in downstream libraries. If `like=` is specified but doesn't
      * implement `__array_function__`, raise a `TypeError`.
      */
-    if (kwargs != NULL && PyDict_Contains(kwargs, npy_ma_str_like)) {
+    if (uses_like == Py_True
+            && kwargs != NULL && PyDict_Contains(kwargs, npy_ma_str_like)) {
         PyObject *like_arg = PyDict_GetItem(kwargs, npy_ma_str_like);
         if (like_arg != NULL) {
             PyObject *tmp_has_override = get_array_function(like_arg);
@@ -357,10 +364,20 @@ array_implement_array_function(
             }
             Py_DECREF(tmp_has_override);
             PyDict_DelItem(kwargs, npy_ma_str_like);
+
+            /*
+             * If `like=` kwarg was removed, `implementation` points to the NumPy
+             * public API, as `public_api` is in that case the wrapper dispatcher
+             * function. For example, in the `np.full` case, `implementation` is
+             * `np.full`, whereas `public_api` is `_full_with_like`. This is done
+             * to ensure `__array_function__` implementations can do
+             * equality/identity comparisons when `like=` is present.
+             */
+            public_api = implementation;
         }
     }
 
-    PyObject *res = array_implement_array_function_internal(
+    res = array_implement_array_function_internal(
         public_api, relevant_args, args, kwargs);
 
     if (res == Py_NotImplemented) {
@@ -374,7 +391,7 @@ array_implement_array_function(
  * only. Added as an extension to NEP-18 in an effort to bring NEP-35 to
  * life with minimal dispatch overhead.
  *
- * The caller must ensure that `like != NULL`.
+ * The caller must ensure that `like != Py_None` or `like == NULL`.
  */
 NPY_NO_EXPORT PyObject *
 array_implement_c_array_function_creation(
diff --git a/numpy/core/src/multiarray/arrayobject.c b/numpy/core/src/multiarray/arrayobject.c
index 1b197d0f246b..b1302738d98d 100644
--- a/numpy/core/src/multiarray/arrayobject.c
+++ b/numpy/core/src/multiarray/arrayobject.c
@@ -75,36 +75,19 @@ PyArray_Size(PyObject *op)
     }
 }
 
-/*NUMPY_API
- *
- * Precondition: 'arr' is a copy of 'base' (though possibly with different
- * strides, ordering, etc.). This function sets the UPDATEIFCOPY flag and the
- * ->base pointer on 'arr', so that when 'arr' is destructed, it will copy any
- * changes back to 'base'. DEPRECATED, use PyArray_SetWritebackIfCopyBase
- *
- * Steals a reference to 'base'.
- *
- * Returns 0 on success, -1 on failure.
- */
+/*NUMPY_API */
 NPY_NO_EXPORT int
 PyArray_SetUpdateIfCopyBase(PyArrayObject *arr, PyArrayObject *base)
 {
-    int ret;
-    /* 2017-Nov  -10 1.14 (for PyPy only) */
-    /* 2018-April-21 1.15 (all Python implementations) */
-    if (DEPRECATE("PyArray_SetUpdateIfCopyBase is deprecated, use "
-              "PyArray_SetWritebackIfCopyBase instead, and be sure to call "
-              "PyArray_ResolveWritebackIfCopy before the array is deallocated, "
-              "i.e. before the last call to Py_DECREF. If cleaning up from an "
-              "error, PyArray_DiscardWritebackIfCopy may be called instead to "
-              "throw away the scratch buffer.") < 0)
-        return -1;
-    ret = PyArray_SetWritebackIfCopyBase(arr, base);
-    if (ret >=0) {
-        PyArray_ENABLEFLAGS(arr, NPY_ARRAY_UPDATEIFCOPY);
-        PyArray_CLEARFLAGS(arr, NPY_ARRAY_WRITEBACKIFCOPY);
-    }
-    return ret;
+    /* 2021-Dec-15 1.23*/
+    PyErr_SetString(PyExc_RuntimeError,
+        "PyArray_SetUpdateIfCopyBase is disabled, use "
+        "PyArray_SetWritebackIfCopyBase instead, and be sure to call "
+        "PyArray_ResolveWritebackIfCopy before the array is deallocated, "
+        "i.e. before the last call to Py_DECREF. If cleaning up from an "
+        "error, PyArray_DiscardWritebackIfCopy may be called instead to "
+        "throw away the scratch buffer.");
+    return -1;
 }
 
 /*NUMPY_API
@@ -377,9 +360,9 @@ PyArray_ResolveWritebackIfCopy(PyArrayObject * self)
 {
     PyArrayObject_fields *fa = (PyArrayObject_fields *)self;
     if (fa && fa->base) {
-        if ((fa->flags & NPY_ARRAY_UPDATEIFCOPY) || (fa->flags & NPY_ARRAY_WRITEBACKIFCOPY)) {
+        if (fa->flags & NPY_ARRAY_WRITEBACKIFCOPY) {
             /*
-             * UPDATEIFCOPY or WRITEBACKIFCOPY means that fa->base's data
+             * WRITEBACKIFCOPY means that fa->base's data
              * should be updated with the contents
              * of self.
              * fa->base->flags is not WRITEABLE to protect the relationship
@@ -388,7 +371,6 @@ PyArray_ResolveWritebackIfCopy(PyArrayObject * self)
             int retval = 0;
             PyArray_ENABLEFLAGS(((PyArrayObject *)fa->base),
                                                     NPY_ARRAY_WRITEABLE);
-            PyArray_CLEARFLAGS(self, NPY_ARRAY_UPDATEIFCOPY);
             PyArray_CLEARFLAGS(self, NPY_ARRAY_WRITEBACKIFCOPY);
             retval = PyArray_CopyAnyInto((PyArrayObject *)fa->base, self);
             Py_DECREF(fa->base);
@@ -462,25 +444,6 @@ array_dealloc(PyArrayObject *self)
                 PyErr_Clear();
             }
         }
-        if (PyArray_FLAGS(self) & NPY_ARRAY_UPDATEIFCOPY) {
-            /* DEPRECATED, remove once the flag is removed */
-            char const * msg = "UPDATEIFCOPY detected in array_dealloc. "
-                " Required call to PyArray_ResolveWritebackIfCopy or "
-                "PyArray_DiscardWritebackIfCopy is missing";
-            /*
-             * prevent reaching 0 twice and thus recursing into dealloc.
-             * Increasing sys.gettotalrefcount, but path should not be taken.
-             */
-            Py_INCREF(self);
-            /* 2017-Nov-10 1.14 */
-            WARN_IN_DEALLOC(PyExc_DeprecationWarning, msg);
-            retval = PyArray_ResolveWritebackIfCopy(self);
-            if (retval < 0)
-            {
-                PyErr_Print();
-                PyErr_Clear();
-            }
-        }
         /*
          * If fa->base is non-NULL, it is something
          * to DECREF -- either a view or a buffer object
@@ -493,14 +456,6 @@ array_dealloc(PyArrayObject *self)
         if (PyDataType_FLAGCHK(fa->descr, NPY_ITEM_REFCOUNT)) {
             PyArray_XDECREF(self);
         }
-        /*
-         * Allocation will never be 0, see comment in ctors.c
-         * line 820
-         */
-        size_t nbytes = PyArray_NBYTES(self);
-        if (nbytes == 0) {
-            nbytes = fa->descr->elsize ? fa->descr->elsize : 1;
-        }
         if (fa->mem_handler == NULL) {
             char *env = getenv("NUMPY_WARN_IF_NO_MEM_POLICY");
             if ((env != NULL) && (strncmp(env, "1", 1) == 0)) {
@@ -511,7 +466,12 @@ array_dealloc(PyArrayObject *self)
             }
             // Guess at malloc/free ???
             free(fa->data);
-        } else {
+        }
+        else {
+            size_t nbytes = PyArray_NBYTES(self);
+            if (nbytes == 0) {
+                nbytes = 1;
+            }
             PyDataMem_UserFREE(fa->data, nbytes, fa->mem_handler);
             Py_DECREF(fa->mem_handler);
         }
@@ -571,8 +531,6 @@ PyArray_DebugPrint(PyArrayObject *obj)
         printf(" NPY_ALIGNED");
     if (fobj->flags & NPY_ARRAY_WRITEABLE)
         printf(" NPY_WRITEABLE");
-    if (fobj->flags & NPY_ARRAY_UPDATEIFCOPY)
-        printf(" NPY_UPDATEIFCOPY");
     if (fobj->flags & NPY_ARRAY_WRITEBACKIFCOPY)
         printf(" NPY_WRITEBACKIFCOPY");
     printf("\n");
@@ -660,15 +618,15 @@ array_might_be_written(PyArrayObject *obj)
 
 /*NUMPY_API
  *
- * This function does nothing if obj is writeable, and raises an exception
- * (and returns -1) if obj is not writeable. It may also do other
- * house-keeping, such as issuing warnings on arrays which are transitioning
- * to become views. Always call this function at some point before writing to
- * an array.
+ *  This function does nothing and returns 0 if *obj* is writeable.
+ *  It raises an exception and returns -1 if *obj* is not writeable.
+ *  It may also do other house-keeping, such as issuing warnings on
+ *  arrays which are transitioning to become views. Always call this
+ *  function at some point before writing to an array.
  *
- * 'name' is a name for the array, used to give better error
- * messages. Something like "assignment destination", "output array", or even
- * just "array".
+ *  *name* is a name for the array, used to give better error messages.
+ *  It can be something like "assignment destination", "output array",
+ *  or even just "array".
  */
 NPY_NO_EXPORT int
 PyArray_FailUnlessWriteable(PyArrayObject *obj, const char *name)
@@ -683,372 +641,11 @@ PyArray_FailUnlessWriteable(PyArrayObject *obj, const char *name)
     return 0;
 }
 
-/* This also handles possibly mis-aligned data */
-/* Compare s1 and s2 which are not necessarily NULL-terminated.
-   s1 is of length len1
-   s2 is of length len2
-   If they are NULL terminated, then stop comparison.
-*/
-static int
-_myunincmp(npy_ucs4 const *s1, npy_ucs4 const *s2, int len1, int len2)
-{
-    npy_ucs4 const *sptr;
-    npy_ucs4 *s1t = NULL;
-    npy_ucs4 *s2t = NULL;
-    int val;
-    npy_intp size;
-    int diff;
-
-    /* Replace `s1` and `s2` with aligned copies if needed */
-    if ((npy_intp)s1 % sizeof(npy_ucs4) != 0) {
-        size = len1*sizeof(npy_ucs4);
-        s1t = malloc(size);
-        memcpy(s1t, s1, size);
-        s1 = s1t;
-    }
-    if ((npy_intp)s2 % sizeof(npy_ucs4) != 0) {
-        size = len2*sizeof(npy_ucs4);
-        s2t = malloc(size);
-        memcpy(s2t, s2, size);
-        s2 = s1t;
-    }
-
-    val = PyArray_CompareUCS4(s1, s2, PyArray_MIN(len1,len2));
-    if ((val != 0) || (len1 == len2)) {
-        goto finish;
-    }
-    if (len2 > len1) {
-        sptr = s2+len1;
-        val = -1;
-        diff = len2-len1;
-    }
-    else {
-        sptr = s1+len2;
-        val = 1;
-        diff=len1-len2;
-    }
-    while (diff--) {
-        if (*sptr != 0) {
-            goto finish;
-        }
-        sptr++;
-    }
-    val = 0;
-
- finish:
-    /* Cleanup the aligned copies */
-    if (s1t) {
-        free(s1t);
-    }
-    if (s2t) {
-        free(s2t);
-    }
-    return val;
-}
-
-
-
-
-/*
- * Compare s1 and s2 which are not necessarily NULL-terminated.
- * s1 is of length len1
- * s2 is of length len2
- * If they are NULL terminated, then stop comparison.
- */
-static int
-_mystrncmp(char const *s1, char const *s2, int len1, int len2)
-{
-    char const *sptr;
-    int val;
-    int diff;
-
-    val = memcmp(s1, s2, PyArray_MIN(len1, len2));
-    if ((val != 0) || (len1 == len2)) {
-        return val;
-    }
-    if (len2 > len1) {
-        sptr = s2 + len1;
-        val = -1;
-        diff = len2 - len1;
-    }
-    else {
-        sptr = s1 + len2;
-        val = 1;
-        diff = len1 - len2;
-    }
-    while (diff--) {
-        if (*sptr != 0) {
-            return val;
-        }
-        sptr++;
-    }
-    return 0; /* Only happens if NULLs are everywhere */
-}
-
-/* Borrowed from Numarray */
-
-#define SMALL_STRING 2048
-
-static void _rstripw(char *s, int n)
-{
-    int i;
-    for (i = n - 1; i >= 1; i--) { /* Never strip to length 0. */
-        int c = s[i];
-
-        if (!c || NumPyOS_ascii_isspace((int)c)) {
-            s[i] = 0;
-        }
-        else {
-            break;
-        }
-    }
-}
-
-static void _unistripw(npy_ucs4 *s, int n)
-{
-    int i;
-    for (i = n - 1; i >= 1; i--) { /* Never strip to length 0. */
-        npy_ucs4 c = s[i];
-        if (!c || NumPyOS_ascii_isspace((int)c)) {
-            s[i] = 0;
-        }
-        else {
-            break;
-        }
-    }
-}
-
-
-static char *
-_char_copy_n_strip(char const *original, char *temp, int nc)
-{
-    if (nc > SMALL_STRING) {
-        temp = malloc(nc);
-        if (!temp) {
-            PyErr_NoMemory();
-            return NULL;
-        }
-    }
-    memcpy(temp, original, nc);
-    _rstripw(temp, nc);
-    return temp;
-}
-
-static void
-_char_release(char *ptr, int nc)
-{
-    if (nc > SMALL_STRING) {
-        free(ptr);
-    }
-}
-
-static char *
-_uni_copy_n_strip(char const *original, char *temp, int nc)
-{
-    if (nc*sizeof(npy_ucs4) > SMALL_STRING) {
-        temp = malloc(nc*sizeof(npy_ucs4));
-        if (!temp) {
-            PyErr_NoMemory();
-            return NULL;
-        }
-    }
-    memcpy(temp, original, nc*sizeof(npy_ucs4));
-    _unistripw((npy_ucs4 *)temp, nc);
-    return temp;
-}
-
-static void
-_uni_release(char *ptr, int nc)
-{
-    if (nc*sizeof(npy_ucs4) > SMALL_STRING) {
-        free(ptr);
-    }
-}
-
-
-/* End borrowed from numarray */
-
-#define _rstrip_loop(CMP) {                                     \
-        void *aptr, *bptr;                                      \
-        char atemp[SMALL_STRING], btemp[SMALL_STRING];          \
-        while(size--) {                                         \
-            aptr = stripfunc(iself->dataptr, atemp, N1);        \
-            if (!aptr) return -1;                               \
-            bptr = stripfunc(iother->dataptr, btemp, N2);       \
-            if (!bptr) {                                        \
-                relfunc(aptr, N1);                              \
-                return -1;                                      \
-            }                                                   \
-            val = compfunc(aptr, bptr, N1, N2);                 \
-            *dptr = (val CMP 0);                                \
-            PyArray_ITER_NEXT(iself);                           \
-            PyArray_ITER_NEXT(iother);                          \
-            dptr += 1;                                          \
-            relfunc(aptr, N1);                                  \
-            relfunc(bptr, N2);                                  \
-        }                                                       \
-    }
-
-#define _reg_loop(CMP) {                                \
-        while(size--) {                                 \
-            val = compfunc((void *)iself->dataptr,      \
-                          (void *)iother->dataptr,      \
-                          N1, N2);                      \
-            *dptr = (val CMP 0);                        \
-            PyArray_ITER_NEXT(iself);                   \
-            PyArray_ITER_NEXT(iother);                  \
-            dptr += 1;                                  \
-        }                                               \
-    }
-
-static int
-_compare_strings(PyArrayObject *result, PyArrayMultiIterObject *multi,
-                 int cmp_op, void *func, int rstrip)
-{
-    PyArrayIterObject *iself, *iother;
-    npy_bool *dptr;
-    npy_intp size;
-    int val;
-    int N1, N2;
-    int (*compfunc)(void *, void *, int, int);
-    void (*relfunc)(char *, int);
-    char* (*stripfunc)(char const *, char *, int);
-
-    compfunc = func;
-    dptr = (npy_bool *)PyArray_DATA(result);
-    iself = multi->iters[0];
-    iother = multi->iters[1];
-    size = multi->size;
-    N1 = PyArray_DESCR(iself->ao)->elsize;
-    N2 = PyArray_DESCR(iother->ao)->elsize;
-    if ((void *)compfunc == (void *)_myunincmp) {
-        N1 >>= 2;
-        N2 >>= 2;
-        stripfunc = _uni_copy_n_strip;
-        relfunc = _uni_release;
-    }
-    else {
-        stripfunc = _char_copy_n_strip;
-        relfunc = _char_release;
-    }
-    switch (cmp_op) {
-    case Py_EQ:
-        if (rstrip) {
-            _rstrip_loop(==);
-        } else {
-            _reg_loop(==);
-        }
-        break;
-    case Py_NE:
-        if (rstrip) {
-            _rstrip_loop(!=);
-        } else {
-            _reg_loop(!=);
-        }
-        break;
-    case Py_LT:
-        if (rstrip) {
-            _rstrip_loop(<);
-        } else {
-            _reg_loop(<);
-        }
-        break;
-    case Py_LE:
-        if (rstrip) {
-            _rstrip_loop(<=);
-        } else {
-            _reg_loop(<=);
-        }
-        break;
-    case Py_GT:
-        if (rstrip) {
-            _rstrip_loop(>);
-        } else {
-            _reg_loop(>);
-        }
-        break;
-    case Py_GE:
-        if (rstrip) {
-            _rstrip_loop(>=);
-        } else {
-            _reg_loop(>=);
-        }
-        break;
-    default:
-        PyErr_SetString(PyExc_RuntimeError, "bad comparison operator");
-        return -1;
-    }
-    return 0;
-}
-
-#undef _reg_loop
-#undef _rstrip_loop
-#undef SMALL_STRING
 
+/* From umath/string_ufuncs.cpp/h */
 NPY_NO_EXPORT PyObject *
-_strings_richcompare(PyArrayObject *self, PyArrayObject *other, int cmp_op,
-                     int rstrip)
-{
-    PyArrayObject *result;
-    PyArrayMultiIterObject *mit;
-    int val;
-
-    if (PyArray_TYPE(self) != PyArray_TYPE(other)) {
-        /*
-         * Comparison between Bytes and Unicode is not defined in Py3K;
-         * we follow.
-         */
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
-    }
-    if (PyArray_ISNOTSWAPPED(self) != PyArray_ISNOTSWAPPED(other)) {
-        /* Cast `other` to the same byte order as `self` (both unicode here) */
-        PyArray_Descr* unicode = PyArray_DescrNew(PyArray_DESCR(self));
-        unicode->elsize = PyArray_DESCR(other)->elsize;
-        PyObject *new = PyArray_FromAny((PyObject *)other,
-                unicode, 0, 0, 0, NULL);
-        if (new == NULL) {
-            return NULL;
-        }
-        other = (PyArrayObject *)new;
-    }
-    else {
-        Py_INCREF(other);
-    }
-
-    /* Broad-cast the arrays to a common shape */
-    mit = (PyArrayMultiIterObject *)PyArray_MultiIterNew(2, self, other);
-    Py_DECREF(other);
-    if (mit == NULL) {
-        return NULL;
-    }
-
-    result = (PyArrayObject *)PyArray_NewFromDescr(&PyArray_Type,
-                                  PyArray_DescrFromType(NPY_BOOL),
-                                  mit->nd,
-                                  mit->dimensions,
-                                  NULL, NULL, 0,
-                                  NULL);
-    if (result == NULL) {
-        goto finish;
-    }
-
-    if (PyArray_TYPE(self) == NPY_UNICODE) {
-        val = _compare_strings(result, mit, cmp_op, _myunincmp, rstrip);
-    }
-    else {
-        val = _compare_strings(result, mit, cmp_op, _mystrncmp, rstrip);
-    }
-
-    if (val < 0) {
-        Py_DECREF(result);
-        result = NULL;
-    }
-
- finish:
-    Py_DECREF(mit);
-    return (PyObject *)result;
-}
+_umath_strings_richcompare(
+        PyArrayObject *self, PyArrayObject *other, int cmp_op, int rstrip);
 
 /*
  * VOID-type arrays can only be compared equal and not-equal
@@ -1064,35 +661,85 @@ static PyObject *
 _void_compare(PyArrayObject *self, PyArrayObject *other, int cmp_op)
 {
     if (!(cmp_op == Py_EQ || cmp_op == Py_NE)) {
-        PyErr_SetString(PyExc_ValueError,
+        PyErr_SetString(PyExc_TypeError,
                 "Void-arrays can only be compared for equality.");
         return NULL;
     }
-    if (PyArray_HASFIELDS(self)) {
-        PyObject *res = NULL, *temp, *a, *b;
-        PyObject *key, *value, *temp2;
-        PyObject *op;
-        Py_ssize_t pos = 0;
+    if (PyArray_TYPE(other) != NPY_VOID) {
+        PyErr_SetString(PyExc_TypeError,
+                "Cannot compare structured or void to non-void arrays.");
+        return NULL;
+    }
+    if (PyArray_HASFIELDS(self) && PyArray_HASFIELDS(other)) {
+        PyArray_Descr *self_descr = PyArray_DESCR(self);
+        PyArray_Descr *other_descr = PyArray_DESCR(other);
+
+        /* Use promotion to decide whether the comparison is valid */
+        PyArray_Descr *promoted = PyArray_PromoteTypes(self_descr, other_descr);
+        if (promoted == NULL) {
+            PyErr_SetString(PyExc_TypeError,
+                    "Cannot compare structured arrays unless they have a "
+                    "common dtype.  I.e. `np.result_type(arr1, arr2)` must "
+                    "be defined.");
+            return NULL;
+        }
+        Py_DECREF(promoted);
+
         npy_intp result_ndim = PyArray_NDIM(self) > PyArray_NDIM(other) ?
                             PyArray_NDIM(self) : PyArray_NDIM(other);
 
-        op = (cmp_op == Py_EQ ? n_ops.logical_and : n_ops.logical_or);
-        while (PyDict_Next(PyArray_DESCR(self)->fields, &pos, &key, &value)) {
-            if (NPY_TITLE_KEY(key, value)) {
-                continue;
-            }
-            a = array_subscript_asarray(self, key);
+        int field_count = PyTuple_GET_SIZE(self_descr->names);
+        if (field_count != PyTuple_GET_SIZE(other_descr->names)) {
+            PyErr_SetString(PyExc_TypeError,
+                    "Cannot compare structured dtypes with different number of "
+                    "fields.  (unreachable error please report to NumPy devs)");
+            return NULL;
+        }
+
+        PyObject *op = (cmp_op == Py_EQ ? n_ops.logical_and : n_ops.logical_or);
+        PyObject *res = NULL;
+        for (int i = 0; i < field_count; ++i) {
+            PyObject *fieldname, *temp, *temp2;
+
+            fieldname = PyTuple_GET_ITEM(self_descr->names, i);
+            PyArrayObject *a = (PyArrayObject *)array_subscript_asarray(
+                    self, fieldname);
             if (a == NULL) {
                 Py_XDECREF(res);
                 return NULL;
             }
-            b = array_subscript_asarray(other, key);
+            fieldname = PyTuple_GET_ITEM(other_descr->names, i);
+            PyArrayObject *b = (PyArrayObject *)array_subscript_asarray(
+                    other, fieldname);
             if (b == NULL) {
                 Py_XDECREF(res);
                 Py_DECREF(a);
                 return NULL;
             }
-            temp = array_richcompare((PyArrayObject *)a,b,cmp_op);
+            /*
+             * If the fields were subarrays, the dimensions may have changed.
+             * In that case, the new shape (subarray part) must match exactly.
+             * (If this is 0, there is no subarray.)
+             */
+            int field_dims_a = PyArray_NDIM(a) - PyArray_NDIM(self);
+            int field_dims_b = PyArray_NDIM(b) - PyArray_NDIM(other);
+            if (field_dims_a != field_dims_b || (
+                    field_dims_a != 0 &&  /* neither is subarray */
+                    /* Compare only the added (subarray) dimensions: */
+                    !PyArray_CompareLists(
+                            PyArray_DIMS(a) + PyArray_NDIM(self),
+                            PyArray_DIMS(b) + PyArray_NDIM(other),
+                            field_dims_a))) {
+                PyErr_SetString(PyExc_TypeError,
+                        "Cannot compare subarrays with different shapes. "
+                        "(unreachable error, please report to NumPy devs.)");
+                Py_DECREF(a);
+                Py_DECREF(b);
+                Py_XDECREF(res);
+                return NULL;
+            }
+
+            temp = array_richcompare(a, (PyObject *)b, cmp_op);
             Py_DECREF(a);
             Py_DECREF(b);
             if (temp == NULL) {
@@ -1119,7 +766,15 @@ _void_compare(PyArrayObject *self, PyArrayObject *other, int cmp_op)
                         memcpy(dimensions, PyArray_DIMS((PyArrayObject *)temp),
                                sizeof(npy_intp)*result_ndim);
                     }
-                    dimensions[result_ndim] = -1;
+
+                    /*
+                     * Compute the new dimension size manually, as reshaping
+                     * with -1 does not work on empty arrays.
+                     */
+                    dimensions[result_ndim] = PyArray_MultiplyList(
+                        PyArray_DIMS((PyArrayObject *)temp) + result_ndim,
+                        PyArray_NDIM((PyArrayObject *)temp) - result_ndim);
+
                     temp2 = PyArray_Newshape((PyArrayObject *)temp,
                                              &newdims, NPY_ANYORDER);
                     if (temp2 == NULL) {
@@ -1177,9 +832,26 @@ _void_compare(PyArrayObject *self, PyArrayObject *other, int cmp_op)
         }
         return res;
     }
+    else if (PyArray_HASFIELDS(self) || PyArray_HASFIELDS(other)) {
+        PyErr_SetString(PyExc_TypeError,
+                "Cannot compare structured with unstructured void arrays. "
+                "(unreachable error, please report to NumPy devs.)");
+        return NULL;
+    }
     else {
+        /*
+         * Since arrays absorb subarray descriptors, this path can only be
+         * reached when both arrays have unstructured voids "V" dtypes.
+         */
+        if (PyArray_ITEMSIZE(self) != PyArray_ITEMSIZE(other)) {
+            PyErr_SetString(PyExc_TypeError,
+                    "cannot compare unstructured voids of different length. "
+                    "Use bytes to compare. "
+                    "(This may return array of False in the future.)");
+            return NULL;
+        }
         /* compare as a string. Assumes self and other have same descr->type */
-        return _strings_richcompare(self, other, cmp_op, 0);
+        return _umath_strings_richcompare(self, other, cmp_op, 0);
     }
 }
 
@@ -1313,36 +985,6 @@ array_richcompare(PyArrayObject *self, PyObject *other, int cmp_op)
     PyObject *obj_self = (PyObject *)self;
     PyObject *result = NULL;
 
-    /* Special case for string arrays (which don't and currently can't have
-     * ufunc loops defined, so there's no point in trying).
-     */
-    if (PyArray_ISSTRING(self)) {
-        array_other = (PyArrayObject *)PyArray_FromObject(other,
-                                                          NPY_NOTYPE, 0, 0);
-        if (array_other == NULL) {
-            PyErr_Clear();
-            /* Never mind, carry on, see what happens */
-        }
-        else if (!PyArray_ISSTRING(array_other)) {
-            Py_DECREF(array_other);
-            /* Never mind, carry on, see what happens */
-        }
-        else {
-            result = _strings_richcompare(self, array_other, cmp_op, 0);
-            Py_DECREF(array_other);
-            return result;
-        }
-        /* If we reach this point, it means that we are not comparing
-         * string-to-string. It's possible that this will still work out,
-         * e.g. if the other array is an object array, then both will be cast
-         * to object or something? I don't know how that works actually, but
-         * it does, b/c this works:
-         *   l = ["a", "b"]
-         *   assert np.array(l, dtype="S1") == np.array(l, dtype="O")
-         * So we fall through and see what happens.
-         */
-    }
-
     switch (cmp_op) {
     case Py_LT:
         RICHCMP_GIVE_UP_IF_NEEDED(obj_self, other);
@@ -1362,8 +1004,6 @@ array_richcompare(PyArrayObject *self, PyObject *other, int cmp_op)
          */
 
         if (PyArray_TYPE(self) == NPY_VOID) {
-            int _res;
-
             array_other = (PyArrayObject *)PyArray_FROM_O(other);
             /*
              * If not successful, indicate that the items cannot be compared
@@ -1380,28 +1020,7 @@ array_richcompare(PyArrayObject *self, PyObject *other, int cmp_op)
                 return Py_NotImplemented;
             }
 
-            _res = PyArray_CheckCastSafety(
-                    NPY_EQUIV_CASTING,
-                    PyArray_DESCR(self), PyArray_DESCR(array_other), NULL);
-            if (_res < 0) {
-                PyErr_Clear();
-                _res = 0;
-            }
-            if (_res == 0) {
-                /* 2015-05-07, 1.10 */
-                Py_DECREF(array_other);
-                if (DEPRECATE_FUTUREWARNING(
-                        "elementwise == comparison failed and returning scalar "
-                        "instead; this will raise an error or perform "
-                        "elementwise comparison in the future.") < 0) {
-                    return NULL;
-                }
-                Py_INCREF(Py_False);
-                return Py_False;
-            }
-            else {
-                result = _void_compare(self, array_other, cmp_op);
-            }
+            result = _void_compare(self, array_other, cmp_op);
             Py_DECREF(array_other);
             return result;
         }
@@ -1417,8 +1036,6 @@ array_richcompare(PyArrayObject *self, PyObject *other, int cmp_op)
          */
 
         if (PyArray_TYPE(self) == NPY_VOID) {
-            int _res;
-
             array_other = (PyArrayObject *)PyArray_FROM_O(other);
             /*
              * If not successful, indicate that the items cannot be compared
@@ -1435,29 +1052,8 @@ array_richcompare(PyArrayObject *self, PyObject *other, int cmp_op)
                 return Py_NotImplemented;
             }
 
-            _res = PyArray_CheckCastSafety(
-                    NPY_EQUIV_CASTING,
-                    PyArray_DESCR(self), PyArray_DESCR(array_other), NULL);
-            if (_res < 0) {
-                PyErr_Clear();
-                _res = 0;
-            }
-            if (_res == 0) {
-                /* 2015-05-07, 1.10 */
-                Py_DECREF(array_other);
-                if (DEPRECATE_FUTUREWARNING(
-                        "elementwise != comparison failed and returning scalar "
-                        "instead; this will raise an error or perform "
-                        "elementwise comparison in the future.") < 0) {
-                    return NULL;
-                }
-                Py_INCREF(Py_True);
-                return Py_True;
-            }
-            else {
-                result = _void_compare(self, array_other, cmp_op);
-                Py_DECREF(array_other);
-            }
+            result = _void_compare(self, array_other, cmp_op);
+            Py_DECREF(array_other);
             return result;
         }
 
@@ -1665,7 +1261,8 @@ array_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds)
             descr = NULL;
             goto fail;
         }
-        if (PyDataType_FLAGCHK(descr, NPY_ITEM_HASOBJECT)) {
+        /* Logic shared by `empty`, `empty_like`, and `ndarray.__new__` */
+        if (PyDataType_REFCHK(PyArray_DESCR(ret))) {
             /* place Py_None in object positions */
             PyArray_FillObjectArray(ret, Py_None);
             if (PyErr_Occurred()) {
diff --git a/numpy/core/src/multiarray/arrayobject.h b/numpy/core/src/multiarray/arrayobject.h
index fb9b0bd8120f..f7d0734dbad4 100644
--- a/numpy/core/src/multiarray/arrayobject.h
+++ b/numpy/core/src/multiarray/arrayobject.h
@@ -26,4 +26,20 @@ array_might_be_written(PyArrayObject *obj);
  */
 static const int NPY_ARRAY_WARN_ON_WRITE = (1 << 31);
 
+
+/*
+ * These flags are used internally to indicate an array that was previously
+ * a Python scalar (int, float, complex).  The dtype of such an array should
+ * be considered as any integer, floating, or complex rather than the explicit
+ * dtype attached to the array.
+ *
+ * These flags must only be used in local context when the array in question
+ * is not returned.  Use three flags, to avoid having to double check the
+ * actual dtype when the flags are used.
+ */
+static const int NPY_ARRAY_WAS_PYTHON_INT = (1 << 30);
+static const int NPY_ARRAY_WAS_PYTHON_FLOAT = (1 << 29);
+static const int NPY_ARRAY_WAS_PYTHON_COMPLEX = (1 << 28);
+static const int NPY_ARRAY_WAS_PYTHON_LITERAL = (1 << 30 | 1 << 29 | 1 << 28);
+
 #endif  /* NUMPY_CORE_SRC_MULTIARRAY_ARRAYOBJECT_H_ */
diff --git a/numpy/core/src/multiarray/arraytypes.c.src b/numpy/core/src/multiarray/arraytypes.c.src
index 71808cc48aa3..56f789843811 100644
--- a/numpy/core/src/multiarray/arraytypes.c.src
+++ b/numpy/core/src/multiarray/arraytypes.c.src
@@ -7,6 +7,7 @@
 
 #define NPY_NO_DEPRECATED_API NPY_API_VERSION
 #define _MULTIARRAYMODULE
+#define _UMATHMODULE
 #define _NPY_NO_DEPRECATIONS /* for NPY_CHAR */
 
 #include "numpy/npy_common.h"
@@ -20,6 +21,7 @@
 #include "npy_sort.h"
 #include "common.h"
 #include "ctors.h"
+#include "convert_datatype.h"
 #include "dtypemeta.h"
 #include "lowlevel_strided_loops.h"
 #include "usertypes.h"
@@ -27,12 +29,6 @@
 #include "arrayobject.h"
 #include "alloc.h"
 #include "typeinfo.h"
-#if defined(__ARM_NEON__) || defined (__ARM_NEON)
-#include 
-#endif
-#ifdef NPY_HAVE_SSE2_INTRINSICS
-#include 
-#endif
 
 #include "npy_longdouble.h"
 #include "numpyos.h"
@@ -42,6 +38,9 @@
 #include "npy_cblas.h"
 #include "npy_buffer.h"
 
+#include "arraytypes.h"
+
+#include "umathmodule.h"
 
 /*
  * Define a stack allocated dummy array with only the minimum information set:
@@ -97,15 +96,37 @@ MyPyFloat_AsDouble(PyObject *obj)
     if (num == NULL) {
         return NPY_NAN;
     }
-    ret = PyFloat_AsDouble(num);
+    ret = PyFloat_AS_DOUBLE(num);
     Py_DECREF(num);
     return ret;
 }
 
+
+static float
+MyPyFloat_AsFloat(PyObject *obj)
+{
+    double d_val = MyPyFloat_AsDouble(obj);
+    float res = (float)d_val;
+    if (NPY_UNLIKELY(npy_isinf(res) && !npy_isinf(d_val))) {
+        if (PyUFunc_GiveFloatingpointErrors("cast", NPY_FPE_OVERFLOW) < 0) {
+            return -1;
+        }
+    }
+    return res;
+}
+
+
 static npy_half
 MyPyFloat_AsHalf(PyObject *obj)
 {
-    return npy_double_to_half(MyPyFloat_AsDouble(obj));
+    double d_val = MyPyFloat_AsDouble(obj);
+    npy_half res = npy_double_to_half(d_val);
+    if (NPY_UNLIKELY(npy_half_isinf(res) && !npy_isinf(d_val))) {
+        if (PyUFunc_GiveFloatingpointErrors("cast", NPY_FPE_OVERFLOW) < 0) {
+            return npy_double_to_half(-1.);
+        }
+    }
+    return res;
 }
 
 static PyObject *
@@ -154,6 +175,13 @@ MyPyLong_As@Type@ (PyObject *obj)
     return ret;
 }
 
+static @type@
+MyPyLong_As@Type@WithWrap(PyObject *obj, int *wraparound)
+{
+    *wraparound = 0;  /* Never happens within the function */
+    return MyPyLong_As@Type@(obj);
+}
+
 /**end repeat**/
 
 /**begin repeat
@@ -162,9 +190,10 @@ MyPyLong_As@Type@ (PyObject *obj)
  * #type = npy_ulong, npy_ulonglong#
  */
 static @type@
-MyPyLong_AsUnsigned@Type@ (PyObject *obj)
+MyPyLong_AsUnsigned@Type@WithWrap(PyObject *obj, int *wraparound)
 {
     @type@ ret;
+    *wraparound = 0;
     PyObject *num = PyNumber_Long(obj);
 
     if (num == NULL) {
@@ -173,12 +202,21 @@ MyPyLong_AsUnsigned@Type@ (PyObject *obj)
     ret = PyLong_AsUnsigned@Type@(num);
     if (PyErr_Occurred()) {
         PyErr_Clear();
+        *wraparound = 1;  /* negative wrapped to positive */
         ret = PyLong_As@Type@(num);
     }
     Py_DECREF(num);
     return ret;
 }
 
+static @type@
+MyPyLong_AsUnsigned@Type@(PyObject *obj)
+{
+    int wraparound;
+    return MyPyLong_AsUnsigned@Type@WithWrap(obj, &wraparound);
+}
+
+
 /**end repeat**/
 
 /*
@@ -186,8 +224,6 @@ MyPyLong_AsUnsigned@Type@ (PyObject *obj)
  **                         GETITEM AND SETITEM                             **
  *****************************************************************************
  */
-
-#define _ALIGN(type) offsetof(struct {char c; type v;}, v)
 /*
  * Disable harmless compiler warning "4116: unnamed type definition in
  * parentheses" which is caused by the _ALIGN macro.
@@ -197,6 +233,88 @@ MyPyLong_AsUnsigned@Type@ (PyObject *obj)
 #endif
 
 
+/**begin repeat
+ *
+ * #type = npy_byte, npy_short, npy_int, npy_long, npy_longlong,
+ *         npy_ubyte, npy_ushort, npy_uint, npy_ulong, npy_ulonglong#
+ * #TYPE = BYTE, SHORT, INT, LONG, LONGLONG,
+ *         UBYTE, USHORT, UINT, ULONG, ULONGLONG#
+ * #STYPE = BYTE, SHORT, INT, LONG, LONGLONG,
+ *          BYTE, SHORT, INT, LONG, LONGLONG#
+ * #conv_type = npy_long*4, npy_longlong, npy_ulong*4, npy_ulonglong#
+ * #CSTYPE = LONG*4, LONGLONG, LONG*4, LONGLONG#
+ * #func = MyPyLong_AsLong*4, MyPyLong_AsLongLong,
+ *         MyPyLong_AsLong*2, MyPyLong_AsUnsignedLong*2,
+ *         MyPyLong_AsUnsignedLongLong#
+ */
+
+/*
+ * Helper for conversion from Python integers.  This uses the same conversion
+ * function as below for compatibility (which may seem strange).
+ * However, it adds more strict integer overflow checks to prevent mainly
+ * conversion of negative integers.  These are considered deprecated, which is
+ * related to NEP 50 (but somewhat independent).
+ */
+static int
+@TYPE@_safe_pyint_setitem(PyObject *obj, @type@ *result)
+{
+    /* Input is guaranteed to be a Python integer */
+    assert(PyLong_Check(obj));
+    int wraparound;
+    @conv_type@ value = @func@WithWrap(obj, &wraparound);
+    if (value == (@conv_type@)-1 && PyErr_Occurred()) {
+        return -1;
+    }
+    *result = (@type@)value;
+
+    if (wraparound
+#if NPY_SIZEOF_@STYPE@ < NPY_SIZEOF_@CSTYPE@
+            || *result != value
+#endif
+            ) {
+        PyArray_Descr *descr = PyArray_DescrFromType(NPY_@TYPE@);
+
+        if (npy_promotion_state == NPY_USE_LEGACY_PROMOTION || (
+                    npy_promotion_state == NPY_USE_WEAK_PROMOTION_AND_WARN
+                        && !npy_give_promotion_warnings())) {
+            /*
+             * This path will be taken both for the "promotion" case such as
+             * `uint8_arr + 123` as well as the assignment case.
+             * The "legacy" path should only ever be taken for assignment
+             * (legacy promotion will prevent overflows by promoting up)
+             * so a normal deprecation makes sense.
+             * When weak promotion is active, we use "future" behavior unless
+             * warnings were explicitly opt-in.
+             */
+            if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
+                    "NumPy will stop allowing conversion of out-of-bound "
+                    "Python integers to integer arrays.  The conversion "
+                    "of %.100R to %S will fail in the future.\n"
+                    "For the old behavior, usually:\n"
+                    "    np.array(value).astype(dtype)`\n"
+                    "will give the desired result (the cast overflows).",
+                    obj, descr) < 0) {
+                Py_DECREF(descr);
+                return -1;
+            }
+            Py_DECREF(descr);
+            return 0;
+        }
+        else {
+            /* Live in the future, outright error: */
+            PyErr_Format(PyExc_OverflowError,
+                    "Python integer %R out of bounds for %S", obj, descr);
+            Py_DECREF(descr);
+            return -1;
+            }
+        assert(0);
+    }
+    return 0;
+}
+
+/**end repeat**/
+
+
 /**begin repeat
  *
  * #TYPE = BOOL, BYTE, UBYTE, SHORT, USHORT, INT, LONG, UINT, ULONG,
@@ -206,7 +324,7 @@ MyPyLong_AsUnsigned@Type@ (PyObject *obj)
  *          MyPyFloat_FromHalf, PyFloat_FromDouble*2#
  * #func2 = PyObject_IsTrue, MyPyLong_AsLong*6, MyPyLong_AsUnsignedLong*2,
  *          MyPyLong_AsLongLong, MyPyLong_AsUnsignedLongLong,
- *          MyPyFloat_AsHalf, MyPyFloat_AsDouble*2#
+ *          MyPyFloat_AsHalf, MyPyFloat_AsFloat, MyPyFloat_AsDouble#
  * #type = npy_bool,
  *         npy_byte, npy_ubyte, npy_short, npy_ushort, npy_int,
  *         npy_long, npy_uint, npy_ulong, npy_longlong, npy_ulonglong,
@@ -215,7 +333,8 @@ MyPyLong_AsUnsigned@Type@ (PyObject *obj)
  *          npy_half, npy_float, npy_double#
  * #kind = Bool, Byte, UByte, Short, UShort, Int, Long, UInt, ULong,
  *         LongLong, ULongLong, Half, Float, Double#
-*/
+ * #is_int = 0,1*10,0*3#
+ */
 static PyObject *
 @TYPE@_getitem(void *input, void *vap)
 {
@@ -233,12 +352,26 @@ static PyObject *
     }
 }
 
-static int
+NPY_NO_EXPORT int
 @TYPE@_setitem(PyObject *op, void *ov, void *vap)
 {
     PyArrayObject *ap = vap;
     @type@ temp;  /* ensures alignment */
 
+#if @is_int@
+    if (PyLong_Check(op)) {
+        /*
+         * When weak promotion is enabled (using NEP 50) we also use more
+         * strict parsing of integers:  All out-of-bound Python integer
+         * parsing fails.
+         */
+        if (@TYPE@_safe_pyint_setitem(op, &temp) < 0) {
+            return -1;
+        }
+    }
+    else  /* continue with if below */
+#endif
+
     if (PyArray_IsScalar(op, @kind@)) {
         temp = PyArrayScalar_VAL(op, @kind@);
     }
@@ -271,6 +404,7 @@ static int
 
 /**end repeat**/
 
+
 /**begin repeat
  *
  * #TYPE = CFLOAT, CDOUBLE#
@@ -308,13 +442,12 @@ static PyObject *
  * #ftype = npy_float, npy_double, npy_longdouble#
  * #kind = CFloat, CDouble, CLongDouble#
  */
-static int
+NPY_NO_EXPORT int
 @NAME@_setitem(PyObject *op, void *ov, void *vap)
 {
     PyArrayObject *ap = vap;
     Py_complex oop;
     @type@ temp;
-    int rsize;
 
     if (PyArray_IsZeroDim(op)) {
         return convert_to_scalar_and_retry(op, ov, vap, @NAME@_setitem);
@@ -369,14 +502,22 @@ static int
         }
         temp.real = (@ftype@) oop.real;
         temp.imag = (@ftype@) oop.imag;
+
+#if NPY_SIZEOF_@NAME@ < NPY_SIZEOF_CDOUBLE  /* really just float... */
+        /* Overflow could have occurred converting double to float */
+        if (NPY_UNLIKELY((npy_isinf(temp.real) && !npy_isinf(oop.real)) ||
+                         (npy_isinf(temp.imag) && !npy_isinf(oop.imag)))) {
+            if (PyUFunc_GiveFloatingpointErrors("cast", NPY_FPE_OVERFLOW) < 0) {
+                return -1;
+            }
+        }
+#endif
     }
 
-    memcpy(ov, &temp, PyArray_DESCR(ap)->elsize);
-    if (PyArray_ISBYTESWAPPED(ap)) {
+    memcpy(ov, &temp, NPY_SIZEOF_@NAME@);
+    if (ap != NULL && PyArray_ISBYTESWAPPED(ap)) {
         byte_swap_vector(ov, 2, sizeof(@ftype@));
     }
-    rsize = sizeof(@ftype@);
-    copy_and_swap(ov, &temp, rsize, 2, rsize, PyArray_ISBYTESWAPPED(ap));
     return 0;
 }
 
@@ -457,7 +598,7 @@ LONGDOUBLE_getitem(void *ip, void *ap)
     return PyArray_Scalar(ip, PyArray_DESCR((PyArrayObject *)ap), NULL);
 }
 
-static int
+NPY_NO_EXPORT int
 LONGDOUBLE_setitem(PyObject *op, void *ov, void *vap)
 {
     PyArrayObject *ap = vap;
@@ -676,6 +817,7 @@ OBJECT_getitem(void *ip, void *NPY_UNUSED(ap))
     PyObject *obj;
     memcpy(&obj, ip, sizeof(obj));
     if (obj == NULL) {
+        /* We support NULL, but still try to guarantee this never happens! */
         Py_RETURN_NONE;
     }
     else {
@@ -693,6 +835,7 @@ OBJECT_setitem(PyObject *op, void *ov, void *NPY_UNUSED(ap))
     memcpy(&obj, ov, sizeof(obj));
 
     Py_INCREF(op);
+    /* A newly created array/buffer may only be NULLed, so XDECREF */
     Py_XDECREF(obj);
 
     memcpy(ov, &op, sizeof(op));
@@ -772,7 +915,7 @@ VOID_getitem(void *input, void *vap)
          *       could have special handling.
          */
         PyObject *base = (PyObject *)ap;
-        while (Py_TYPE(base) == NULL) {
+        while (base != NULL && Py_TYPE(base) == NULL) {
             base = PyArray_BASE((PyArrayObject *)base);
         }
         ret = (PyArrayObject *)PyArray_NewFromDescrAndBase(
@@ -780,6 +923,15 @@ VOID_getitem(void *input, void *vap)
                 shape.len, shape.ptr, NULL, ip,
                 PyArray_FLAGS(ap) & ~NPY_ARRAY_F_CONTIGUOUS,
                 NULL, base);
+        if (base == NULL) {
+            /*
+             * Need to create a copy, or we may point to wrong data.  This path
+             * is taken when no "valid" array is passed.  This happens for
+             * casts.
+             */
+            PyObject *copy = PyArray_FromArray(ret, NULL, NPY_ARRAY_ENSURECOPY);
+            Py_SETREF(ret, (PyArrayObject *)copy);
+        }
         npy_free_cache_dim_obj(shape);
         return (PyObject *)ret;
     }
@@ -1157,13 +1309,22 @@ static void
     @totype@ *op = output;
 
     while (n--) {
-        @fromtype@ f = *ip++;
-        @totype@ t = (@totype@)f;
 #if @supports_nat@ && @floatingpoint@
-        /* Avoid undefined behaviour for NaN -> NaT */
+        /*
+         * volatile works around clang (and gcc sometimes) not branching
+         * correctly, leading to floating point errors in the test suite.
+         */
+        volatile @fromtype@ f = *ip++;
+        @totype@ t;
+        /* Avoid undefined behaviour and warning for NaN -> NaT */
         if (npy_isnan(f)) {
             t = (@totype@)NPY_DATETIME_NAT;
         }
+        else {
+            t = (@totype@)f;
+        }
+#else
+        @totype@ t = (@totype@)*ip++;
 #endif
         *op++ = t;
     }
@@ -1183,13 +1344,22 @@ static void
     @totype@ *op = output;
 
     while (n--) {
-        @fromtype@ f = *ip;
-        @totype@ t = (@totype@)f;
 #if @supports_nat@
-        /* Avoid undefined behaviour for NaN -> NaT */
+        /*
+         * volatile works around clang (and gcc sometimes) not branching
+         * correctly, leading to floating point errors in the test suite.
+         */
+        volatile @fromtype@ f = *ip;
+        @totype@ t;
+        /* Avoid undefined behaviour and warning for NaN -> NaT */
         if (npy_isnan(f)) {
             t = (@totype@)NPY_DATETIME_NAT;
         }
+        else {
+            t = (@totype@)f;
+        }
+#else
+        @totype@ t = (@totype@)*ip;
 #endif
         *op++ = t;
         ip += 2;
@@ -2849,7 +3019,7 @@ static int
 #define LT(a,b) ((a) < (b) || ((b) != (b) && (a) ==(a)))
 
 static int
-@TYPE@_compare(@type@ *pa, @type@ *pb)
+@TYPE@_compare(@type@ *pa, @type@ *pb, PyArrayObject *NPY_UNUSED(ap))
 {
     const @type@ a = *pa;
     const @type@ b = *pb;
@@ -2869,7 +3039,7 @@ static int
 
 
 static int
-C@TYPE@_compare(@type@ *pa, @type@ *pb)
+C@TYPE@_compare(@type@ *pa, @type@ *pb, PyArrayObject *NPY_UNUSED(ap))
 {
     const @type@ ar = pa[0];
     const @type@ ai = pa[1];
@@ -2924,7 +3094,7 @@ C@TYPE@_compare(@type@ *pa, @type@ *pb)
  */
 
 static int
-@TYPE@_compare(@type@ *pa, @type@ *pb)
+@TYPE@_compare(@type@ *pa, @type@ *pb, PyArrayObject *NPY_UNUSED(ap))
 {
     const @type@ a = *pa;
     const @type@ b = *pb;
@@ -3176,77 +3346,21 @@ finish:
  **                                 ARGFUNC                                 **
  *****************************************************************************
  */
-#if defined(__ARM_NEON__) || defined (__ARM_NEON)
-    int32_t _mm_movemask_epi8_neon(uint8x16_t input)
-    {
-        int8x8_t m0 = vcreate_s8(0x0706050403020100ULL);
-        uint8x16_t v0 = vshlq_u8(vshrq_n_u8(input, 7), vcombine_s8(m0, m0));
-        uint64x2_t v1 = vpaddlq_u32(vpaddlq_u16(vpaddlq_u8(v0)));
-        return (int)vgetq_lane_u64(v1, 0) + ((int)vgetq_lane_u64(v1, 1) << 8);
-    }
-#endif
-#define _LESS_THAN_OR_EQUAL(a,b) ((a) <= (b))
-
-static int
-BOOL_argmax(npy_bool *ip, npy_intp n, npy_intp *max_ind,
-            PyArrayObject *NPY_UNUSED(aip))
 
-{
-    npy_intp i = 0;
-    /* memcmp like logical_and on i386 is maybe slower for small arrays */
-#ifdef NPY_HAVE_SSE2_INTRINSICS
-    const __m128i zero = _mm_setzero_si128();
-    for (; i < n - (n % 32); i+=32) {
-        __m128i d1 = _mm_loadu_si128((__m128i*)&ip[i]);
-        __m128i d2 = _mm_loadu_si128((__m128i*)&ip[i + 16]);
-        d1 = _mm_cmpeq_epi8(d1, zero);
-        d2 = _mm_cmpeq_epi8(d2, zero);
-        if (_mm_movemask_epi8(_mm_min_epu8(d1, d2)) != 0xFFFF) {
-            break;
-        }
-    }
-#else
-    #if defined(__ARM_NEON__) || defined (__ARM_NEON)
-        uint8x16_t zero = vdupq_n_u8(0);
-        for(; i < n - (n % 32); i+=32) {
-            uint8x16_t d1 = vld1q_u8((uint8_t *)&ip[i]);
-            uint8x16_t d2 = vld1q_u8((uint8_t *)&ip[i + 16]);
-            d1 = vceqq_u8(d1, zero);
-            d2 = vceqq_u8(d2, zero);
-            if(_mm_movemask_epi8_neon(vminq_u8(d1, d2)) != 0xFFFF) {
-                break;
-            }
-        }
-    #endif
-#endif
-    for (; i < n; i++) {
-        if (ip[i]) {
-            *max_ind = i;
-            return 0;
-        }
-    }
-    *max_ind = 0;
-    return 0;
-}
+#define _LESS_THAN_OR_EQUAL(a,b) ((a) <= (b))
 
 /**begin repeat
  *
- * #fname = BYTE, UBYTE, SHORT, USHORT, INT, UINT,
- *          LONG, ULONG, LONGLONG, ULONGLONG,
- *          HALF, FLOAT, DOUBLE, LONGDOUBLE,
- *          CFLOAT, CDOUBLE, CLONGDOUBLE,
+ * #fname = HALF, CFLOAT, CDOUBLE, CLONGDOUBLE,
  *          DATETIME, TIMEDELTA#
- * #type = npy_byte, npy_ubyte, npy_short, npy_ushort, npy_int, npy_uint,
- *         npy_long, npy_ulong, npy_longlong, npy_ulonglong,
- *         npy_half, npy_float, npy_double, npy_longdouble,
- *         npy_float, npy_double, npy_longdouble,
+ * #type = npy_half, npy_float, npy_double, npy_longdouble,
  *         npy_datetime, npy_timedelta#
- * #isfloat = 0*10, 1*7, 0*2#
- * #isnan = nop*10, npy_half_isnan, npy_isnan*6, nop*2#
- * #le = _LESS_THAN_OR_EQUAL*10, npy_half_le, _LESS_THAN_OR_EQUAL*8#
- * #iscomplex = 0*14, 1*3, 0*2#
- * #incr = ip++*14, ip+=2*3, ip++*2#
- * #isdatetime = 0*17, 1*2#
+ * #isfloat = 1*4, 0*2#
+ * #isnan = npy_half_isnan, npy_isnan*3, nop*2#
+ * #le = npy_half_le, _LESS_THAN_OR_EQUAL*5#
+ * #iscomplex = 0, 1*3, 0*2#
+ * #incr = ip++, ip+=2*3, ip++*2#
+ * #isdatetime = 0*4, 1*2#
  */
 static int
 @fname@_argmax(@type@ *ip, npy_intp n, npy_intp *max_ind,
@@ -3337,22 +3451,16 @@ BOOL_argmin(npy_bool *ip, npy_intp n, npy_intp *min_ind,
 
 /**begin repeat
  *
- * #fname = BYTE, UBYTE, SHORT, USHORT, INT, UINT,
- *          LONG, ULONG, LONGLONG, ULONGLONG,
- *          HALF, FLOAT, DOUBLE, LONGDOUBLE,
- *          CFLOAT, CDOUBLE, CLONGDOUBLE,
+ * #fname = HALF, CFLOAT, CDOUBLE, CLONGDOUBLE,
  *          DATETIME, TIMEDELTA#
- * #type = npy_byte, npy_ubyte, npy_short, npy_ushort, npy_int, npy_uint,
- *         npy_long, npy_ulong, npy_longlong, npy_ulonglong,
- *         npy_half, npy_float, npy_double, npy_longdouble,
- *         npy_float, npy_double, npy_longdouble,
+ * #type = npy_half, npy_float, npy_double, npy_longdouble,
  *         npy_datetime, npy_timedelta#
- * #isfloat = 0*10, 1*7, 0*2#
- * #isnan = nop*10, npy_half_isnan, npy_isnan*6, nop*2#
- * #le = _LESS_THAN_OR_EQUAL*10, npy_half_le, _LESS_THAN_OR_EQUAL*8#
- * #iscomplex = 0*14, 1*3, 0*2#
- * #incr = ip++*14, ip+=2*3, ip++*2#
- * #isdatetime = 0*17, 1*2#
+ * #isfloat = 1*4, 0*2#
+ * #isnan = npy_half_isnan, npy_isnan*3, nop*2#
+ * #le = npy_half_le, _LESS_THAN_OR_EQUAL*5#
+ * #iscomplex = 0, 1*3, 0*2#
+ * #incr = ip++, ip+=2*3, ip++*2#
+ * #isdatetime = 0*4, 1*2#
  */
 static int
 @fname@_argmin(@type@ *ip, npy_intp n, npy_intp *min_ind,
@@ -3409,7 +3517,7 @@ static int
             *min_ind = i;
             break;
         }
-#endif 
+#endif
         if (!@le@(mp, *ip)) {  /* negated, for correct nan handling */
             mp = *ip;
             *min_ind = i;
@@ -3640,7 +3748,8 @@ NPY_NO_EXPORT void
             CBLAS_INT chunk = n < NPY_CBLAS_CHUNK ? n : NPY_CBLAS_CHUNK;
             @type@ tmp[2];
 
-            CBLAS_FUNC(cblas_@prefix@dotu_sub)((CBLAS_INT)n, ip1, is1b, ip2, is2b, tmp);
+            CBLAS_FUNC(cblas_@prefix@dotu_sub)(
+                    (CBLAS_INT)chunk, ip1, is1b, ip2, is2b, tmp);
             sum[0] += (double)tmp[0];
             sum[1] += (double)tmp[1];
             /* use char strides here */
@@ -3692,17 +3801,23 @@ BOOL_dot(char *ip1, npy_intp is1, char *ip2, npy_intp is2, char *op, npy_intp n,
     *((npy_bool *)op) = tmp;
 }
 
+/*
+ * `dot` does not make sense for times, for DATETIME it never worked.
+ *  For timedelta it does/did , but should probably also just be removed.
+ */
+#define DATETIME_dot NULL
+
 /**begin repeat
  *
  * #name = BYTE, UBYTE, SHORT, USHORT, INT, UINT,
  *         LONG, ULONG, LONGLONG, ULONGLONG,
- *         LONGDOUBLE, DATETIME, TIMEDELTA#
+ *         LONGDOUBLE, TIMEDELTA#
  * #type = npy_byte, npy_ubyte, npy_short, npy_ushort, npy_int, npy_uint,
  *         npy_long, npy_ulong, npy_longlong, npy_ulonglong,
- *         npy_longdouble, npy_datetime, npy_timedelta#
+ *         npy_longdouble, npy_timedelta#
  * #out = npy_long, npy_ulong, npy_long, npy_ulong, npy_long, npy_ulong,
  *        npy_long, npy_ulong, npy_longlong, npy_ulonglong,
- *        npy_longdouble, npy_datetime, npy_timedelta#
+ *        npy_longdouble, npy_timedelta#
  */
 static void
 @name@_dot(char *ip1, npy_intp is1, char *ip2, npy_intp is2, char *op, npy_intp n,
@@ -3805,7 +3920,18 @@ OBJECT_dot(char *ip1, npy_intp is1, char *ip2, npy_intp is2, char *op, npy_intp
  */
 
 
-#define BOOL_fill NULL
+/* Boolean fill never works, but define it so that it works up to length 2 */
+static int
+BOOL_fill(PyObject **buffer, npy_intp length, void *NPY_UNUSED(ignored))
+{
+    NPY_ALLOW_C_API_DEF;
+    NPY_ALLOW_C_API;
+    PyErr_SetString(PyExc_TypeError,
+            "arange() is only supported for booleans when the result has at "
+            "most length 2.");
+    NPY_DISABLE_C_API;
+    return -1;
+}
 
 /* this requires buffer to be filled with objects or NULL */
 static int
@@ -4494,6 +4620,27 @@ set_typeinfo(PyObject *dict)
     PyArray_Descr *dtype;
     PyObject *cobj, *key;
 
+    // SIMD runtime dispatching
+    #ifndef NPY_DISABLE_OPTIMIZATION
+        #include "argfunc.dispatch.h"
+    #endif
+    /**begin repeat
+     * #FROM = BYTE, UBYTE, SHORT, USHORT, INT, UINT,
+     *         LONG, ULONG, LONGLONG, ULONGLONG,
+     *         FLOAT, DOUBLE, LONGDOUBLE#
+     *
+     * #NAME = Byte, UByte, Short, UShort, Int, UInt,
+     *         Long, ULong, LongLong, ULongLong,
+     *         Float, Double, LongDouble#
+     */
+    /**begin repeat1
+     * #func = argmax, argmin#
+     */
+    NPY_CPU_DISPATCH_CALL_XB(_Py@NAME@_ArrFuncs.@func@ = (PyArray_ArgFunc*)@FROM@_@func@);
+    /**end repeat1**/
+    /**end repeat**/
+    NPY_CPU_DISPATCH_CALL_XB(_PyBool_ArrFuncs.argmax = (PyArray_ArgFunc*)BOOL_argmax);
+
     /*
      * Override the base class for all types, eventually all of this logic
      * should be defined on the class and inherited to the scalar.
diff --git a/numpy/core/src/multiarray/arraytypes.h b/numpy/core/src/multiarray/arraytypes.h
deleted file mode 100644
index b3a13b297da1..000000000000
--- a/numpy/core/src/multiarray/arraytypes.h
+++ /dev/null
@@ -1,31 +0,0 @@
-#ifndef NUMPY_CORE_SRC_MULTIARRAY_ARRAYTYPES_H_
-#define NUMPY_CORE_SRC_MULTIARRAY_ARRAYTYPES_H_
-
-#include "common.h"
-
-NPY_NO_EXPORT int
-set_typeinfo(PyObject *dict);
-
-/* needed for blasfuncs */
-NPY_NO_EXPORT void
-FLOAT_dot(char *, npy_intp, char *, npy_intp, char *, npy_intp, void *);
-
-NPY_NO_EXPORT void
-CFLOAT_dot(char *, npy_intp, char *, npy_intp, char *, npy_intp, void *);
-
-NPY_NO_EXPORT void
-DOUBLE_dot(char *, npy_intp, char *, npy_intp, char *, npy_intp, void *);
-
-NPY_NO_EXPORT void
-CDOUBLE_dot(char *, npy_intp, char *, npy_intp, char *, npy_intp, void *);
-
-
-/* for _pyarray_correlate */
-NPY_NO_EXPORT int
-small_correlate(const char * d_, npy_intp dstride,
-                npy_intp nd, enum NPY_TYPES dtype,
-                const char * k_, npy_intp kstride,
-                npy_intp nk, enum NPY_TYPES ktype,
-                char * out_, npy_intp ostride);
-
-#endif  /* NUMPY_CORE_SRC_MULTIARRAY_ARRAYTYPES_H_ */
diff --git a/numpy/core/src/multiarray/arraytypes.h.src b/numpy/core/src/multiarray/arraytypes.h.src
new file mode 100644
index 000000000000..aad464ccf95d
--- /dev/null
+++ b/numpy/core/src/multiarray/arraytypes.h.src
@@ -0,0 +1,69 @@
+#ifndef NUMPY_CORE_SRC_MULTIARRAY_ARRAYTYPES_H_
+#define NUMPY_CORE_SRC_MULTIARRAY_ARRAYTYPES_H_
+
+#include "common.h"
+
+NPY_NO_EXPORT int
+set_typeinfo(PyObject *dict);
+
+/* needed for blasfuncs */
+NPY_NO_EXPORT void
+FLOAT_dot(char *, npy_intp, char *, npy_intp, char *, npy_intp, void *);
+
+NPY_NO_EXPORT void
+CFLOAT_dot(char *, npy_intp, char *, npy_intp, char *, npy_intp, void *);
+
+NPY_NO_EXPORT void
+DOUBLE_dot(char *, npy_intp, char *, npy_intp, char *, npy_intp, void *);
+
+NPY_NO_EXPORT void
+CDOUBLE_dot(char *, npy_intp, char *, npy_intp, char *, npy_intp, void *);
+
+
+/* for _pyarray_correlate */
+NPY_NO_EXPORT int
+small_correlate(const char * d_, npy_intp dstride,
+                npy_intp nd, enum NPY_TYPES dtype,
+                const char * k_, npy_intp kstride,
+                npy_intp nk, enum NPY_TYPES ktype,
+                char * out_, npy_intp ostride);
+
+/**begin repeat
+ * #TYPE = BYTE, UBYTE, SHORT, USHORT, INT, UINT,
+ *         LONG, ULONG, LONGLONG, ULONGLONG,
+ *         HALF, FLOAT, DOUBLE, LONGDOUBLE,
+ *         CFLOAT, CDOUBLE, CLONGDOUBLE#
+ */
+/*
+ * The setitem functions are currently directly used in certain branches
+ * of the scalar-math code. (Yes, this would be nice to refactor...)
+ */
+
+NPY_NO_EXPORT int
+@TYPE@_setitem(PyObject *obj, void *data_ptr, void *arr);
+
+/**end repeat**/
+
+
+#ifndef NPY_DISABLE_OPTIMIZATION
+    #include "argfunc.dispatch.h"
+#endif
+/**begin repeat
+ * #TYPE = BYTE, UBYTE, SHORT, USHORT, INT, UINT,
+ *         LONG, ULONG, LONGLONG, ULONGLONG,
+ *         FLOAT, DOUBLE, LONGDOUBLE#
+ * #type = byte, ubyte, short, ushort, int, uint,
+ *         long, ulong, longlong, ulonglong,
+ *         float, double, longdouble#
+ */
+/**begin repeat1
+ * #func = argmax, argmin#
+ */
+NPY_CPU_DISPATCH_DECLARE(NPY_NO_EXPORT int @TYPE@_@func@,
+    (npy_@type@ *ip, npy_intp n, npy_intp *max_ind, PyArrayObject *aip))
+/**end repeat1**/
+/**end repeat**/
+NPY_CPU_DISPATCH_DECLARE(NPY_NO_EXPORT int BOOL_argmax,
+    (npy_bool *ip, npy_intp n, npy_intp *max_ind, PyArrayObject *aip))
+
+#endif  /* NUMPY_CORE_SRC_MULTIARRAY_ARRAYTYPES_H_ */
diff --git a/numpy/core/src/multiarray/buffer.c b/numpy/core/src/multiarray/buffer.c
index d10122c4f190..0307d41a8b31 100644
--- a/numpy/core/src/multiarray/buffer.c
+++ b/numpy/core/src/multiarray/buffer.c
@@ -498,14 +498,11 @@ _buffer_info_new(PyObject *obj, int flags)
             assert((size_t)info->shape % sizeof(npy_intp) == 0);
             info->strides = info->shape + PyArray_NDIM(arr);
 
-#if NPY_RELAXED_STRIDES_CHECKING
             /*
-             * When NPY_RELAXED_STRIDES_CHECKING is used, some buffer users
-             * may expect a contiguous buffer to have well formatted strides
-             * also when a dimension is 1, but we do not guarantee this
-             * internally. Thus, recalculate strides for contiguous arrays.
-             * (This is unnecessary, but has no effect in the case where
-             * NPY_RELAXED_STRIDES CHECKING is disabled.)
+             * Some buffer users may expect a contiguous buffer to have well
+             * formatted strides also when a dimension is 1, but we do not
+             * guarantee this internally. Thus, recalculate strides for
+             * contiguous arrays.
              */
             int f_contiguous = (flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS;
             if (PyArray_IS_C_CONTIGUOUS(arr) && !(
@@ -526,11 +523,6 @@ _buffer_info_new(PyObject *obj, int flags)
                 }
             }
             else {
-#else  /* NPY_RELAXED_STRIDES_CHECKING */
-            /* We can always use the arrays strides directly */
-            {
-#endif
-
                 for (k = 0; k < PyArray_NDIM(arr); ++k) {
                     info->shape[k] = PyArray_DIMS(arr)[k];
                     info->strides[k] = PyArray_STRIDES(arr)[k];
@@ -708,8 +700,8 @@ _buffer_get_info(void **buffer_info_cache_ptr, PyObject *obj, int flags)
          if (info->ndim > 1 && next_info != NULL) {
              /*
               * Some arrays are C- and F-contiguous and if they have more
-              * than one dimension, the buffer-info may differ between
-              * the two due to RELAXED_STRIDES_CHECKING.
+              * than one dimension, the buffer-info may differ between the
+              * two because strides for length 1 dimension may be adjusted.
               * If we export both buffers, the first stored one may be
               * the one for the other contiguity, so check both.
               * This is generally very unlikely in all other cases, since
@@ -1048,12 +1040,18 @@ _descriptor_from_pep3118_format_fast(char const *s, PyObject **result)
     }
 
     descr = PyArray_DescrFromType(type_num);
+    if (descr == NULL) {
+        return 0;
+    }
     if (byte_order == '=') {
         *result = (PyObject*)descr;
     }
     else {
         *result = (PyObject*)PyArray_DescrNewByteorder(descr, byte_order);
         Py_DECREF(descr);
+        if (*result == NULL) {
+            return 0;
+        }
     }
 
     return 1;
diff --git a/numpy/core/src/multiarray/calculation.c b/numpy/core/src/multiarray/calculation.c
index 327f685d4ffc..a985a2308bfb 100644
--- a/numpy/core/src/multiarray/calculation.c
+++ b/numpy/core/src/multiarray/calculation.c
@@ -175,7 +175,7 @@ _PyArray_ArgMinMaxCommon(PyArrayObject *op,
     NPY_END_THREADS_DESCR(PyArray_DESCR(ap));
 
     Py_DECREF(ap);
-    /* Trigger the UPDATEIFCOPY/WRITEBACKIFCOPY if necessary */
+    /* Trigger the WRITEBACKIFCOPY if necessary */
     if (out != NULL && out != rp) {
         PyArray_ResolveWritebackIfCopy(rp);
         Py_DECREF(rp);
diff --git a/numpy/core/src/multiarray/can_cast_table.h b/numpy/core/src/multiarray/can_cast_table.h
new file mode 100644
index 000000000000..bd9c4c48b571
--- /dev/null
+++ b/numpy/core/src/multiarray/can_cast_table.h
@@ -0,0 +1,124 @@
+/*
+ * This file defines a compile time constant casting table for use in
+ * a few situations:
+ * 1. As a fast-path in can-cast (untested how much it helps).
+ * 2. To define the actual cast safety stored on the CastingImpl/ArrayMethod
+ * 3. For scalar math, since it also needs cast safety information.
+ *
+ * It is useful to have this constant to allow writing compile time generic
+ * code based on cast safety in the scalar math code.
+ */
+
+#ifndef NUMPY_CORE_SRC_MULTIARRAY_CAN_CAST_TABLE_H_
+#define NUMPY_CORE_SRC_MULTIARRAY_CAN_CAST_TABLE_H_
+
+#include "numpy/ndarraytypes.h"
+
+
+/* The from type fits into to (it has a smaller or equal number of bits) */
+#define FITS(FROM, TO) (NPY_SIZEOF_##FROM <= NPY_SIZEOF_##TO)
+/* Unsigned "from" fits a signed integer if it is truly smaller */
+#define UFITS(FROM, TO) (NPY_SIZEOF_##FROM < NPY_SIZEOF_##TO)
+/* Integer "from" only fits a float if it is truly smaller or double... */
+#define IFITS(FROM, TO) (  \
+    NPY_SIZEOF_##FROM < NPY_SIZEOF_##TO || (  \
+            NPY_SIZEOF_##FROM == NPY_SIZEOF_##TO  \
+            && NPY_SIZEOF_##FROM >= NPY_SIZEOF_DOUBLE))
+
+/*
+ * NOTE: The Order is bool, integers (signed, unsigned) tuples, float, cfloat,
+ *       then 6 fixed ones (object, string, unicode, void, datetime, timedelta),
+ *       and finally half.
+ *       Note that in the future we may only need the numeric casts here, but
+ *       currently it fills in the others as well.
+ */
+#define CASTS_SAFELY_FROM_UINT(FROM)  \
+    {0,  \
+     UFITS(FROM, BYTE), FITS(FROM, BYTE), UFITS(FROM, SHORT), FITS(FROM, SHORT),  \
+     UFITS(FROM, INT), FITS(FROM, INT), UFITS(FROM, LONG), FITS(FROM, LONG),  \
+     UFITS(FROM, LONGLONG), FITS(FROM, LONGLONG),  \
+     IFITS(FROM, FLOAT), IFITS(FROM, DOUBLE), IFITS(FROM, LONGDOUBLE),  \
+     IFITS(FROM, FLOAT), IFITS(FROM, DOUBLE), IFITS(FROM, LONGDOUBLE),  \
+     1, 1, 1, 1, 0, NPY_SIZEOF_##FROM < NPY_SIZEOF_TIMEDELTA, IFITS(FROM, HALF)}
+
+#define CASTS_SAFELY_FROM_INT(FROM)  \
+    {0,  \
+     FITS(FROM, BYTE), 0, FITS(FROM, SHORT), 0,  \
+     FITS(FROM, INT), 0, FITS(FROM, LONG), 0,  \
+     FITS(FROM, LONGLONG), 0,  \
+     IFITS(FROM, FLOAT), IFITS(FROM, DOUBLE), IFITS(FROM, LONGDOUBLE),  \
+     IFITS(FROM, FLOAT), IFITS(FROM, DOUBLE), IFITS(FROM, LONGDOUBLE),  \
+     1, 1, 1, 1, 0, NPY_SIZEOF_##FROM <= NPY_SIZEOF_TIMEDELTA, IFITS(FROM, HALF)}
+
+/* Floats are similar to ints, but cap at double */
+#define CASTS_SAFELY_FROM_FLOAT(FROM)  \
+    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  \
+     FITS(FROM, FLOAT), FITS(FROM, DOUBLE), FITS(FROM, LONGDOUBLE),  \
+     FITS(FROM, FLOAT), FITS(FROM, DOUBLE), FITS(FROM, LONGDOUBLE),  \
+     1, 1, 1, 1, 0, 0, FITS(FROM, HALF)}
+
+#define CASTS_SAFELY_FROM_CFLOAT(FROM)  \
+    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  \
+     0, 0, 0,  \
+     FITS(FROM, FLOAT), FITS(FROM, DOUBLE), FITS(FROM, LONGDOUBLE),  \
+     1, 1, 1, 1, 0, 0, 0}
+
+static const npy_bool _npy_can_cast_safely_table[NPY_NTYPES][NPY_NTYPES] = {
+        /* Bool safely casts to anything except datetime (has no zero) */
+        {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+         1, 1, 1, 1, 1, 1,
+         1, 1, 1, 1, 0, 1, 1},
+        /* Integers in pairs of signed, unsigned */
+        CASTS_SAFELY_FROM_INT(BYTE), CASTS_SAFELY_FROM_UINT(BYTE),
+        CASTS_SAFELY_FROM_INT(SHORT), CASTS_SAFELY_FROM_UINT(SHORT),
+        CASTS_SAFELY_FROM_INT(INT), CASTS_SAFELY_FROM_UINT(INT),
+        CASTS_SAFELY_FROM_INT(LONG), CASTS_SAFELY_FROM_UINT(LONG),
+        CASTS_SAFELY_FROM_INT(LONGLONG), CASTS_SAFELY_FROM_UINT(LONGLONG),
+        /* Floats and complex */
+        CASTS_SAFELY_FROM_FLOAT(FLOAT),
+        CASTS_SAFELY_FROM_FLOAT(DOUBLE),
+        CASTS_SAFELY_FROM_FLOAT(LONGDOUBLE),
+        CASTS_SAFELY_FROM_CFLOAT(FLOAT),
+        CASTS_SAFELY_FROM_CFLOAT(DOUBLE),
+        CASTS_SAFELY_FROM_CFLOAT(LONGDOUBLE),
+        /*
+         * Following the main numeric types are:
+         * object, string, unicode, void, datetime, timedelta (and half)
+         */
+        /* object casts safely only to itself */
+        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /* bool + ints */
+         0, 0, 0, 0, 0, 0,  /* floats (without half) */
+         1, 0, 0, 0, 0, 0, 0},
+        /* String casts safely to object, unicode and void */
+        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /* bool + ints */
+         0, 0, 0, 0, 0, 0,  /* floats (without half) */
+         1, 1, 1, 1, 0, 0, 0},
+        /* Unicode casts safely to object and void */
+        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /* bool + ints */
+         0, 0, 0, 0, 0, 0,  /* floats (without half) */
+         1, 0, 1, 1, 0, 0, 0},
+        /* Void cast safely to object */
+        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /* bool + ints */
+         0, 0, 0, 0, 0, 0,  /* floats (without half) */
+         1, 0, 0, 1, 0, 0, 0},
+        /* datetime cast safely to object, string, unicode, void */
+        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /* bool + ints */
+         0, 0, 0, 0, 0, 0,  /* floats (without half) */
+         1, 1, 1, 1, 1, 0, 0},
+        /* timedelta cast safely to object, string, unicode, void */
+        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /* bool + ints */
+         0, 0, 0, 0, 0, 0,  /* floats (without half) */
+         1, 1, 1, 1, 0, 1, 0},
+        /* half */
+        CASTS_SAFELY_FROM_FLOAT(HALF),
+};
+
+#undef FITS
+#undef UFITS
+#undef IFITS
+#undef CASTS_SAFELY_TO_UINT
+#undef CASTS_SAFELY_TO_INT
+#undef CASTS_SAFELY_TO_FLOAT
+#undef CASTS_SAFELY_TO_CFLOAT
+
+#endif  /* NUMPY_CORE_SRC_MULTIARRAY_CAN_CAST_TABLE_H_ */
diff --git a/numpy/core/src/multiarray/common.c b/numpy/core/src/multiarray/common.c
index aa95d285a8ca..da8d23a262aa 100644
--- a/numpy/core/src/multiarray/common.c
+++ b/numpy/core/src/multiarray/common.c
@@ -108,8 +108,8 @@ PyArray_DTypeFromObjectStringDiscovery(
 
 /*
  * This function is now identical to the new PyArray_DiscoverDTypeAndShape
- * but only returns the the dtype. It should in most cases be slowly phased
- * out. (Which may need some refactoring to PyArray_FromAny to make it simpler)
+ * but only returns the dtype. It should in most cases be slowly phased out.
+ * (Which may need some refactoring to PyArray_FromAny to make it simpler)
  */
 NPY_NO_EXPORT int
 PyArray_DTypeFromObject(PyObject *obj, int maxdims, PyArray_Descr **out_dtype)
@@ -127,23 +127,6 @@ PyArray_DTypeFromObject(PyObject *obj, int maxdims, PyArray_Descr **out_dtype)
     return 0;
 }
 
-NPY_NO_EXPORT char *
-index2ptr(PyArrayObject *mp, npy_intp i)
-{
-    npy_intp dim0;
-
-    if (PyArray_NDIM(mp) == 0) {
-        PyErr_SetString(PyExc_IndexError, "0-d arrays can't be indexed");
-        return NULL;
-    }
-    dim0 = PyArray_DIMS(mp)[0];
-    if (check_and_adjust_index(&i, dim0, 0, NULL) < 0)
-        return NULL;
-    if (i == 0) {
-        return PyArray_DATA(mp);
-    }
-    return PyArray_BYTES(mp)+i*PyArray_STRIDES(mp)[0];
-}
 
 NPY_NO_EXPORT int
 _zerofill(PyArrayObject *ret)
@@ -153,7 +136,6 @@ _zerofill(PyArrayObject *ret)
         PyArray_FillObjectArray(ret, zero);
         Py_DECREF(zero);
         if (PyErr_Occurred()) {
-            Py_DECREF(ret);
             return -1;
         }
     }
diff --git a/numpy/core/src/multiarray/common.h b/numpy/core/src/multiarray/common.h
index b3526c4c1de2..4ea9bcf455fd 100644
--- a/numpy/core/src/multiarray/common.h
+++ b/numpy/core/src/multiarray/common.h
@@ -4,6 +4,10 @@
 #include 
 #include "numpy/npy_common.h"
 #include "numpy/ndarraytypes.h"
+#include "npy_cpu_features.h"
+#include "npy_cpu_dispatch.h"
+#include "numpy/npy_cpu.h"
+
 #include "npy_import.h"
 #include 
 
@@ -43,9 +47,6 @@ NPY_NO_EXPORT int
 PyArray_DTypeFromObject(PyObject *obj, int maxdims,
                         PyArray_Descr **out_dtype);
 
-NPY_NO_EXPORT int
-PyArray_DTypeFromObjectHelper(PyObject *obj, int maxdims,
-                              PyArray_Descr **out_dtype, int string_status);
 
 /*
  * Returns NULL without setting an exception if no scalar is matched, a
@@ -54,12 +55,6 @@ PyArray_DTypeFromObjectHelper(PyObject *obj, int maxdims,
 NPY_NO_EXPORT PyArray_Descr *
 _array_find_python_scalar_type(PyObject *op);
 
-NPY_NO_EXPORT PyArray_Descr *
-_array_typedescr_fromstr(char const *str);
-
-NPY_NO_EXPORT char *
-index2ptr(PyArrayObject *mp, npy_intp i);
-
 NPY_NO_EXPORT int
 _zerofill(PyArrayObject *ret);
 
@@ -183,7 +178,19 @@ check_and_adjust_axis(int *axis, int ndim)
 }
 
 /* used for some alignment checks */
-#define _ALIGN(type) offsetof(struct {char c; type v;}, v)
+/* 
+ * GCC releases before GCC 4.9 had a bug in _Alignof.  See GCC bug 52023
+ * .
+ * clang versions < 8.0.0 have the same bug.
+ */
+#if (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112 \
+     || (defined __GNUC__ && __GNUC__ < 4 + (__GNUC_MINOR__ < 9) \
+  && !defined __clang__) \
+     || (defined __clang__ && __clang_major__ < 8))
+# define _ALIGN(type) offsetof(struct {char c; type v;}, v)
+#else
+# define _ALIGN(type) _Alignof(type)
+#endif
 #define _UINT_ALIGN(type) npy_uint_alignment(sizeof(type))
 /*
  * Disable harmless compiler warning "4116: unnamed type definition in
@@ -248,6 +255,15 @@ npy_uint_alignment(int itemsize)
  * compared to memchr it returns one stride past end instead of NULL if needle
  * is not found.
  */
+#ifdef __clang__
+    /*
+     * The code below currently makes use of !NPY_ALIGNMENT_REQUIRED, which
+     * should be OK but causes the clang sanitizer to warn.  It may make
+     * sense to modify the code to avoid this "unaligned" access but
+     * it would be good to carefully check the performance changes.
+     */
+    __attribute__((no_sanitize("alignment")))
+#endif
 static NPY_INLINE char *
 npy_memchr(char * haystack, char needle,
            npy_intp stride, npy_intp size, npy_intp * psubloopsize, int invert)
diff --git a/numpy/core/src/multiarray/common_dtype.c b/numpy/core/src/multiarray/common_dtype.c
index ca80b1ed7002..3561a905aa7a 100644
--- a/numpy/core/src/multiarray/common_dtype.c
+++ b/numpy/core/src/multiarray/common_dtype.c
@@ -41,7 +41,7 @@
  * @param dtype2 Second DType class.
  * @return The common DType or NULL with an error set
  */
-NPY_NO_EXPORT NPY_INLINE PyArray_DTypeMeta *
+NPY_NO_EXPORT PyArray_DTypeMeta *
 PyArray_CommonDType(PyArray_DTypeMeta *dtype1, PyArray_DTypeMeta *dtype2)
 {
     if (dtype1 == dtype2) {
diff --git a/numpy/core/src/multiarray/common_dtype.h b/numpy/core/src/multiarray/common_dtype.h
index 13d38ddf816a..9f25fc14ee3c 100644
--- a/numpy/core/src/multiarray/common_dtype.h
+++ b/numpy/core/src/multiarray/common_dtype.h
@@ -7,6 +7,10 @@
 #include 
 #include "dtypemeta.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 NPY_NO_EXPORT PyArray_DTypeMeta *
 PyArray_CommonDType(PyArray_DTypeMeta *dtype1, PyArray_DTypeMeta *dtype2);
 
@@ -14,4 +18,8 @@ NPY_NO_EXPORT PyArray_DTypeMeta *
 PyArray_PromoteDTypeSequence(
         npy_intp length, PyArray_DTypeMeta **dtypes_in);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif  /* NUMPY_CORE_SRC_MULTIARRAY_COMMON_DTYPE_H_ */
diff --git a/numpy/core/src/multiarray/compiled_base.c b/numpy/core/src/multiarray/compiled_base.c
index 5853e068b0b7..82bed207b9f4 100644
--- a/numpy/core/src/multiarray/compiled_base.c
+++ b/numpy/core/src/multiarray/compiled_base.c
@@ -9,7 +9,7 @@
 #include "numpy/npy_3kcompat.h"
 #include "numpy/npy_math.h"
 #include "npy_config.h"
-#include "templ_common.h" /* for npy_mul_with_overflow_intp */
+#include "templ_common.h" /* for npy_mul_sizes_with_overflow */
 #include "lowlevel_strided_loops.h" /* for npy_bswap8 */
 #include "alloc.h"
 #include "ctors.h"
@@ -1069,7 +1069,7 @@ arr_ravel_multi_index(PyObject *self, PyObject *args, PyObject *kwds)
             s = 1;
             for (i = dimensions.len-1; i >= 0; --i) {
                 ravel_strides[i] = s;
-                if (npy_mul_with_overflow_intp(&s, s, dimensions.ptr[i])) {
+                if (npy_mul_sizes_with_overflow(&s, s, dimensions.ptr[i])) {
                     PyErr_SetString(PyExc_ValueError,
                         "invalid dims: array size defined by dims is larger "
                         "than the maximum possible size.");
@@ -1081,7 +1081,7 @@ arr_ravel_multi_index(PyObject *self, PyObject *args, PyObject *kwds)
             s = 1;
             for (i = 0; i < dimensions.len; ++i) {
                 ravel_strides[i] = s;
-                if (npy_mul_with_overflow_intp(&s, s, dimensions.ptr[i])) {
+                if (npy_mul_sizes_with_overflow(&s, s, dimensions.ptr[i])) {
                     PyErr_SetString(PyExc_ValueError,
                         "invalid dims: array size defined by dims is larger "
                         "than the maximum possible size.");
@@ -1393,11 +1393,7 @@ arr_add_docstring(PyObject *NPY_UNUSED(dummy), PyObject *args)
 {
     PyObject *obj;
     PyObject *str;
-    #if !defined(PYPY_VERSION_NUM) || PYPY_VERSION_NUM > 0x07030300
     const char *docstr;
-    #else
-    char *docstr;
-    #endif
     static char *msg = "already has a different docstring";
 
     /* Don't add docstrings */
diff --git a/numpy/core/src/multiarray/conversion_utils.c b/numpy/core/src/multiarray/conversion_utils.c
index ef101a78bc89..96afb6c00ce2 100644
--- a/numpy/core/src/multiarray/conversion_utils.c
+++ b/numpy/core/src/multiarray/conversion_utils.c
@@ -78,6 +78,27 @@ PyArray_OutputConverter(PyObject *object, PyArrayObject **address)
     }
 }
 
+
+/*
+ * Convert the given value to an integer. Replaces the error when compared
+ * to `PyArray_PyIntAsIntp`.  Exists mainly to retain old behaviour of
+ * `PyArray_IntpConverter` and `PyArray_IntpFromSequence`
+ */
+static NPY_INLINE npy_intp
+dimension_from_scalar(PyObject *ob)
+{
+    npy_intp value = PyArray_PyIntAsIntp(ob);
+
+    if (error_converting(value)) {
+        if (PyErr_ExceptionMatches(PyExc_OverflowError)) {
+            PyErr_SetString(PyExc_ValueError,
+                    "Maximum allowed dimension exceeded");
+        }
+        return -1;
+    }
+    return value;
+}
+
 /*NUMPY_API
  * Get intp chunk from sequence
  *
@@ -90,9 +111,6 @@ PyArray_OutputConverter(PyObject *object, PyArrayObject **address)
 NPY_NO_EXPORT int
 PyArray_IntpConverter(PyObject *obj, PyArray_Dims *seq)
 {
-    Py_ssize_t len;
-    int nd;
-
     seq->ptr = NULL;
     seq->len = 0;
 
@@ -110,42 +128,85 @@ PyArray_IntpConverter(PyObject *obj, PyArray_Dims *seq)
         return NPY_SUCCEED;
     }
 
-    len = PySequence_Size(obj);
-    if (len == -1) {
-        /* Check to see if it is an integer number */
-        if (PyNumber_Check(obj)) {
-            /*
-             * After the deprecation the PyNumber_Check could be replaced
-             * by PyIndex_Check.
-             * FIXME 1.9 ?
-             */
-            len = 1;
+    PyObject *seq_obj = NULL;
+
+    /*
+     * If obj is a scalar we skip all the useless computations and jump to
+     * dimension_from_scalar as soon as possible.
+     */
+    if (!PyLong_CheckExact(obj) && PySequence_Check(obj)) {
+        seq_obj = PySequence_Fast(obj,
+               "expected a sequence of integers or a single integer.");
+        if (seq_obj == NULL) {
+            /* continue attempting to parse as a single integer. */
+            PyErr_Clear();
         }
     }
-    if (len < 0) {
-        PyErr_SetString(PyExc_TypeError,
-                "expected sequence object with len >= 0 or a single integer");
-        return NPY_FAIL;
-    }
-    if (len > NPY_MAXDIMS) {
-        PyErr_Format(PyExc_ValueError, "maximum supported dimension for an ndarray is %d"
-                     ", found %d", NPY_MAXDIMS, len);
-        return NPY_FAIL;
-    }
-    if (len > 0) {
-        seq->ptr = npy_alloc_cache_dim(len);
+
+    if (seq_obj == NULL) {
+        /*
+         * obj *might* be a scalar (if dimension_from_scalar does not fail, at
+         * the moment no check have been performed to verify this hypothesis).
+         */
+        seq->ptr = npy_alloc_cache_dim(1);
         if (seq->ptr == NULL) {
             PyErr_NoMemory();
             return NPY_FAIL;
         }
+        else {
+            seq->len = 1;
+
+            seq->ptr[0] = dimension_from_scalar(obj);
+            if (error_converting(seq->ptr[0])) {
+                /*
+                 * If the error occurred is a type error (cannot convert the
+                 * value to an integer) communicate that we expected a sequence
+                 * or an integer from the user.
+                 */
+                if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+                    PyErr_Format(PyExc_TypeError,
+                            "expected a sequence of integers or a single "
+                            "integer, got '%.100R'", obj);
+                }
+                npy_free_cache_dim_obj(*seq);
+                seq->ptr = NULL;
+                return NPY_FAIL;
+            }
+        }
     }
-    seq->len = len;
-    nd = PyArray_IntpFromIndexSequence(obj, (npy_intp *)seq->ptr, len);
-    if (nd == -1 || nd != len) {
-        npy_free_cache_dim_obj(*seq);
-        seq->ptr = NULL;
-        return NPY_FAIL;
+    else {
+        /*
+         * `obj` is a sequence converted to the `PySequence_Fast` in `seq_obj`
+         */
+        Py_ssize_t len = PySequence_Fast_GET_SIZE(seq_obj);
+        if (len > NPY_MAXDIMS) {
+            PyErr_Format(PyExc_ValueError,
+                    "maximum supported dimension for an ndarray "
+                    "is %d, found %d", NPY_MAXDIMS, len);
+            Py_DECREF(seq_obj);
+            return NPY_FAIL;
+        }
+        if (len > 0) {
+            seq->ptr = npy_alloc_cache_dim(len);
+            if (seq->ptr == NULL) {
+                PyErr_NoMemory();
+                Py_DECREF(seq_obj);
+                return NPY_FAIL;
+            }
+        }
+
+        seq->len = len;
+        int nd = PyArray_IntpFromIndexSequence(seq_obj,
+                (npy_intp *)seq->ptr, len);
+        Py_DECREF(seq_obj);
+
+        if (nd == -1 || nd != len) {
+            npy_free_cache_dim_obj(*seq);
+            seq->ptr = NULL;
+            return NPY_FAIL;
+        }
     }
+
     return NPY_SUCCEED;
 }
 
@@ -172,7 +233,7 @@ PyArray_CopyConverter(PyObject *obj, _PyArray_CopyMode *copymode) {
     }
 
     int int_copymode;
-    PyObject* numpy_CopyMode = NULL;
+    static PyObject* numpy_CopyMode = NULL;
     npy_cache_import("numpy", "_CopyMode", &numpy_CopyMode);
 
     if (numpy_CopyMode != NULL && (PyObject *)Py_TYPE(obj) == numpy_CopyMode) {
@@ -182,6 +243,7 @@ PyArray_CopyConverter(PyObject *obj, _PyArray_CopyMode *copymode) {
         }
 
         int_copymode = (int)PyLong_AsLong(mode_value);
+        Py_DECREF(mode_value);
         if (error_converting(int_copymode)) {
             return NPY_FAIL;
         }
@@ -270,6 +332,15 @@ PyArray_AxisConverter(PyObject *obj, int *axis)
         if (error_converting(*axis)) {
             return NPY_FAIL;
         }
+        if (*axis == NPY_MAXDIMS){
+            /* NumPy 1.23, 2022-05-19 */
+            if (DEPRECATE("Using `axis=32` (MAXDIMS) is deprecated. "
+                          "32/MAXDIMS had the same meaning as `axis=None` which "
+                          "should be used instead.  "
+                          "(Deprecated NumPy 1.23)") < 0) {
+                return NPY_FAIL;
+            }
+        }
     }
     return NPY_SUCCEED;
 }
@@ -992,64 +1063,46 @@ PyArray_PyIntAsIntp(PyObject *o)
 }
 
 
-/*
- * PyArray_IntpFromIndexSequence
- * Returns the number of dimensions or -1 if an error occurred.
- * vals must be large enough to hold maxvals.
- * Opposed to PyArray_IntpFromSequence it uses and returns npy_intp
- * for the number of values.
+NPY_NO_EXPORT int
+PyArray_IntpFromPyIntConverter(PyObject *o, npy_intp *val)
+{
+    *val = PyArray_PyIntAsIntp(o);
+    if (error_converting(*val)) {
+        return NPY_FAIL;
+    }
+    return NPY_SUCCEED;
+}
+
+
+/**
+ * Reads values from a sequence of integers and stores them into an array.
+ *
+ * @param  seq      A sequence created using `PySequence_Fast`.
+ * @param  vals     Array used to store dimensions (must be large enough to
+ *                      hold `maxvals` values).
+ * @param  max_vals Maximum number of dimensions that can be written into `vals`.
+ * @return          Number of dimensions or -1 if an error occurred.
+ *
+ * .. note::
+ *
+ *   Opposed to PyArray_IntpFromSequence it uses and returns `npy_intp`
+ *      for the number of values.
  */
 NPY_NO_EXPORT npy_intp
 PyArray_IntpFromIndexSequence(PyObject *seq, npy_intp *vals, npy_intp maxvals)
 {
-    Py_ssize_t nd;
-    npy_intp i;
-    PyObject *op, *err;
-
     /*
-     * Check to see if sequence is a single integer first.
-     * or, can be made into one
+     * First of all, check if sequence is a scalar integer or if it can be
+     * "casted" into a scalar.
      */
-    nd = PySequence_Length(seq);
-    if (nd == -1) {
-        if (PyErr_Occurred()) {
-            PyErr_Clear();
-        }
+    Py_ssize_t nd = PySequence_Fast_GET_SIZE(seq);
+    PyObject *op;
+    for (Py_ssize_t i = 0; i < PyArray_MIN(nd, maxvals); i++) {
+        op = PySequence_Fast_GET_ITEM(seq, i);
 
-        vals[0] = PyArray_PyIntAsIntp(seq);
-        if(vals[0] == -1) {
-            err = PyErr_Occurred();
-            if (err &&
-                    PyErr_GivenExceptionMatches(err, PyExc_OverflowError)) {
-                PyErr_SetString(PyExc_ValueError,
-                        "Maximum allowed dimension exceeded");
-            }
-            if(err != NULL) {
-                return -1;
-            }
-        }
-        nd = 1;
-    }
-    else {
-        for (i = 0; i < PyArray_MIN(nd,maxvals); i++) {
-            op = PySequence_GetItem(seq, i);
-            if (op == NULL) {
-                return -1;
-            }
-
-            vals[i] = PyArray_PyIntAsIntp(op);
-            Py_DECREF(op);
-            if(vals[i] == -1) {
-                err = PyErr_Occurred();
-                if (err &&
-                        PyErr_GivenExceptionMatches(err, PyExc_OverflowError)) {
-                    PyErr_SetString(PyExc_ValueError,
-                            "Maximum allowed dimension exceeded");
-                }
-                if(err != NULL) {
-                    return -1;
-                }
-            }
+        vals[i] = dimension_from_scalar(op);
+        if (error_converting(vals[i])) {
+            return -1;
         }
     }
     return nd;
@@ -1063,7 +1116,34 @@ PyArray_IntpFromIndexSequence(PyObject *seq, npy_intp *vals, npy_intp maxvals)
 NPY_NO_EXPORT int
 PyArray_IntpFromSequence(PyObject *seq, npy_intp *vals, int maxvals)
 {
-    return PyArray_IntpFromIndexSequence(seq, vals, (npy_intp)maxvals);
+    PyObject *seq_obj = NULL;
+    if (!PyLong_CheckExact(seq) && PySequence_Check(seq)) {
+        seq_obj = PySequence_Fast(seq,
+            "expected a sequence of integers or a single integer");
+        if (seq_obj == NULL) {
+            /* continue attempting to parse as a single integer. */
+            PyErr_Clear();
+        }
+    }
+
+    if (seq_obj == NULL) {
+        vals[0] = dimension_from_scalar(seq);
+        if (error_converting(vals[0])) {
+            if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+                PyErr_Format(PyExc_TypeError,
+                        "expected a sequence of integers or a single "
+                        "integer, got '%.100R'", seq);
+            }
+            return -1;
+        }
+        return 1;
+    }
+    else {
+        int res;
+        res = PyArray_IntpFromIndexSequence(seq_obj, vals, (npy_intp)maxvals);
+        Py_DECREF(seq_obj);
+        return res;
+    }
 }
 
 
diff --git a/numpy/core/src/multiarray/conversion_utils.h b/numpy/core/src/multiarray/conversion_utils.h
index 4072841ee1c7..4d0fbb8941ba 100644
--- a/numpy/core/src/multiarray/conversion_utils.h
+++ b/numpy/core/src/multiarray/conversion_utils.h
@@ -6,6 +6,9 @@
 NPY_NO_EXPORT int
 PyArray_IntpConverter(PyObject *obj, PyArray_Dims *seq);
 
+NPY_NO_EXPORT int
+PyArray_IntpFromPyIntConverter(PyObject *o, npy_intp *val);
+
 NPY_NO_EXPORT int
 PyArray_OptionalIntpConverter(PyObject *obj, PyArray_Dims *seq);
 
diff --git a/numpy/core/src/multiarray/convert.c b/numpy/core/src/multiarray/convert.c
index 2f68db07c988..ef231587d226 100644
--- a/numpy/core/src/multiarray/convert.c
+++ b/numpy/core/src/multiarray/convert.c
@@ -20,6 +20,7 @@
 #include "array_assign.h"
 
 #include "convert.h"
+#include "array_coercion.h"
 
 int
 fallocate(int fd, int mode, off_t offset, off_t len);
@@ -304,7 +305,7 @@ PyArray_ToString(PyArrayObject *self, NPY_ORDER order)
     PyArrayIterObject *it;
 
     if (order == NPY_ANYORDER)
-        order = PyArray_ISFORTRAN(self);
+        order = PyArray_ISFORTRAN(self) ? NPY_FORTRANORDER : NPY_CORDER;
 
     /*        if (PyArray_TYPE(self) == NPY_OBJECT) {
               PyErr_SetString(PyExc_ValueError, "a string for the data" \
@@ -358,151 +359,50 @@ PyArray_ToString(PyArrayObject *self, NPY_ORDER order)
 NPY_NO_EXPORT int
 PyArray_FillWithScalar(PyArrayObject *arr, PyObject *obj)
 {
-    PyArray_Descr *dtype = NULL;
-    npy_longlong value_buffer[4];
-    char *value = NULL;
-    int retcode = 0;
 
-    /*
-     * If 'arr' is an object array, copy the object as is unless
-     * 'obj' is a zero-dimensional array, in which case we copy
-     * the element in that array instead.
-     */
-    if (PyArray_DESCR(arr)->type_num == NPY_OBJECT &&
-                        !(PyArray_Check(obj) &&
-                          PyArray_NDIM((PyArrayObject *)obj) == 0)) {
-        value = (char *)&obj;
-
-        dtype = PyArray_DescrFromType(NPY_OBJECT);
-        if (dtype == NULL) {
-            return -1;
-        }
-    }
-    /* NumPy scalar */
-    else if (PyArray_IsScalar(obj, Generic)) {
-        dtype = PyArray_DescrFromScalar(obj);
-        if (dtype == NULL) {
-            return -1;
-        }
-        value = scalar_value(obj, dtype);
-        if (value == NULL) {
-            Py_DECREF(dtype);
-            return -1;
-        }
-    }
-    /* Python boolean */
-    else if (PyBool_Check(obj)) {
-        value = (char *)value_buffer;
-        *value = (obj == Py_True);
-
-        dtype = PyArray_DescrFromType(NPY_BOOL);
-        if (dtype == NULL) {
-            return -1;
-        }
-    }
-    /* Python integer */
-    else if (PyLong_Check(obj)) {
-        /* Try long long before unsigned long long */
-        npy_longlong ll_v = PyLong_AsLongLong(obj);
-        if (error_converting(ll_v)) {
-            /* Long long failed, try unsigned long long */
-            npy_ulonglong ull_v;
-            PyErr_Clear();
-            ull_v = PyLong_AsUnsignedLongLong(obj);
-            if (ull_v == (unsigned long long)-1 && PyErr_Occurred()) {
-                return -1;
-            }
-            value = (char *)value_buffer;
-            *(npy_ulonglong *)value = ull_v;
-
-            dtype = PyArray_DescrFromType(NPY_ULONGLONG);
-            if (dtype == NULL) {
-                return -1;
-            }
-        }
-        else {
-            /* Long long succeeded */
-            value = (char *)value_buffer;
-            *(npy_longlong *)value = ll_v;
-
-            dtype = PyArray_DescrFromType(NPY_LONGLONG);
-            if (dtype == NULL) {
-                return -1;
-            }
-        }
-    }
-    /* Python float */
-    else if (PyFloat_Check(obj)) {
-        npy_double v = PyFloat_AsDouble(obj);
-        if (error_converting(v)) {
-            return -1;
-        }
-        value = (char *)value_buffer;
-        *(npy_double *)value = v;
-
-        dtype = PyArray_DescrFromType(NPY_DOUBLE);
-        if (dtype == NULL) {
-            return -1;
-        }
+    if (PyArray_FailUnlessWriteable(arr, "assignment destination") < 0) {
+        return -1;
     }
-    /* Python complex */
-    else if (PyComplex_Check(obj)) {
-        npy_double re, im;
-
-        re = PyComplex_RealAsDouble(obj);
-        if (error_converting(re)) {
-            return -1;
-        }
-        im = PyComplex_ImagAsDouble(obj);
-        if (error_converting(im)) {
-            return -1;
-        }
-        value = (char *)value_buffer;
-        ((npy_double *)value)[0] = re;
-        ((npy_double *)value)[1] = im;
 
-        dtype = PyArray_DescrFromType(NPY_CDOUBLE);
-        if (dtype == NULL) {
+    /*
+     * If we knew that the output array has at least one element, we would
+     * not actually need a helping buffer, we always null it, just in case.
+     *
+     * (The longlong here should help with alignment.)
+     */
+    npy_longlong value_buffer_stack[4] = {0};
+    char *value_buffer_heap = NULL;
+    char *value = (char *)value_buffer_stack;
+    PyArray_Descr *descr = PyArray_DESCR(arr);
+
+    if (descr->elsize > sizeof(value_buffer_stack)) {
+        /* We need a large temporary buffer... */
+        value_buffer_heap = PyObject_Calloc(1, descr->elsize);
+        if (value_buffer_heap == NULL) {
+            PyErr_NoMemory();
             return -1;
         }
+        value = value_buffer_heap;
     }
-
-    /* Use the value pointer we got if possible */
-    if (value != NULL) {
-        /* TODO: switch to SAME_KIND casting */
-        retcode = PyArray_AssignRawScalar(arr, dtype, value,
-                                NULL, NPY_UNSAFE_CASTING);
-        Py_DECREF(dtype);
-        return retcode;
+    if (PyArray_Pack(descr, value, obj) < 0) {
+        PyMem_FREE(value_buffer_heap);
+        return -1;
     }
-    /* Otherwise convert to an array to do the assignment */
-    else {
-        PyArrayObject *src_arr;
-
-        /**
-         * The dtype of the destination is used when converting
-         * from the pyobject, so that for example a tuple gets
-         * recognized as a struct scalar of the required type.
-         */
-        Py_INCREF(PyArray_DTYPE(arr));
-        src_arr = (PyArrayObject *)PyArray_FromAny(obj,
-                        PyArray_DTYPE(arr), 0, 0, 0, NULL);
-        if (src_arr == NULL) {
-            return -1;
-        }
-
-        if (PyArray_NDIM(src_arr) != 0) {
-            PyErr_SetString(PyExc_ValueError,
-                    "Input object to FillWithScalar is not a scalar");
-            Py_DECREF(src_arr);
-            return -1;
-        }
 
-        retcode = PyArray_CopyInto(arr, src_arr);
+    /*
+     * There is no cast anymore, the above already coerced using scalar
+     * coercion rules
+     */
+    int retcode = raw_array_assign_scalar(
+            PyArray_NDIM(arr), PyArray_DIMS(arr), descr,
+            PyArray_BYTES(arr), PyArray_STRIDES(arr),
+            descr, value);
 
-        Py_DECREF(src_arr);
-        return retcode;
+    if (PyDataType_REFCHK(descr)) {
+        PyArray_Item_XDECREF(value, descr);
     }
+    PyMem_FREE(value_buffer_heap);
+    return retcode;
 }
 
 /*
@@ -544,6 +444,12 @@ PyArray_NewCopy(PyArrayObject *obj, NPY_ORDER order)
 {
     PyArrayObject *ret;
 
+    if (obj == NULL) {
+        PyErr_SetString(PyExc_ValueError,
+            "obj is NULL in PyArray_NewCopy");
+        return NULL;
+    }
+
     ret = (PyArrayObject *)PyArray_NewLikeArray(obj, order, NULL, 1);
     if (ret == NULL) {
         return NULL;
diff --git a/numpy/core/src/multiarray/convert_datatype.c b/numpy/core/src/multiarray/convert_datatype.c
index 3135d69894b3..627784db3e23 100644
--- a/numpy/core/src/multiarray/convert_datatype.c
+++ b/numpy/core/src/multiarray/convert_datatype.c
@@ -15,6 +15,7 @@
 #include "numpy/npy_math.h"
 
 #include "array_coercion.h"
+#include "can_cast_table.h"
 #include "common.h"
 #include "ctors.h"
 #include "dtypemeta.h"
@@ -30,6 +31,7 @@
 #include "array_method.h"
 #include "usertypes.h"
 #include "dtype_transfer.h"
+#include "arrayobject.h"
 
 
 /*
@@ -43,6 +45,11 @@
  */
 NPY_NO_EXPORT npy_intp REQUIRED_STR_LEN[] = {0, 3, 5, 10, 10, 20, 20, 20, 20};
 
+/*
+ * Whether or not legacy value-based promotion/casting is used.
+ */
+NPY_NO_EXPORT int npy_promotion_state = NPY_USE_LEGACY_PROMOTION;
+NPY_NO_EXPORT PyObject *NO_NEP50_WARNING_CTX = NULL;
 
 static PyObject *
 PyArray_GetGenericToVoidCastingImpl(void);
@@ -57,6 +64,77 @@ static PyObject *
 PyArray_GetObjectToGenericCastingImpl(void);
 
 
+/*
+ * Return 1 if promotion warnings should be given and 0 if they are currently
+ * suppressed in the local context.
+ */
+NPY_NO_EXPORT int
+npy_give_promotion_warnings(void)
+{
+    PyObject *val;
+
+    npy_cache_import(
+            "numpy.core._ufunc_config", "NO_NEP50_WARNING",
+            &NO_NEP50_WARNING_CTX);
+    if (NO_NEP50_WARNING_CTX == NULL) {
+        PyErr_WriteUnraisable(NULL);
+        return 1;
+    }
+
+    if (PyContextVar_Get(NO_NEP50_WARNING_CTX, Py_False, &val) < 0) {
+        /* Errors should not really happen, but if it does assume we warn. */
+        PyErr_WriteUnraisable(NULL);
+        return 1;
+    }
+    Py_DECREF(val);
+    /* only when the no-warnings context is false, we give warnings */
+    return val == Py_False;
+}
+
+
+NPY_NO_EXPORT PyObject *
+npy__get_promotion_state(PyObject *NPY_UNUSED(mod), PyObject *NPY_UNUSED(arg)) {
+    if (npy_promotion_state == NPY_USE_WEAK_PROMOTION) {
+        return PyUnicode_FromString("weak");
+    }
+    else if (npy_promotion_state == NPY_USE_WEAK_PROMOTION_AND_WARN) {
+        return PyUnicode_FromString("weak_and_warn");
+    }
+    else if (npy_promotion_state == NPY_USE_LEGACY_PROMOTION) {
+        return PyUnicode_FromString("legacy");
+    }
+    PyErr_SetString(PyExc_SystemError, "invalid promotion state!");
+    return NULL;
+}
+
+
+NPY_NO_EXPORT PyObject *
+npy__set_promotion_state(PyObject *NPY_UNUSED(mod), PyObject *arg)
+{
+    if (!PyUnicode_Check(arg)) {
+        PyErr_SetString(PyExc_TypeError,
+                "_set_promotion_state() argument or NPY_PROMOTION_STATE "
+                "must be a string.");
+        return NULL;
+    }
+    if (PyUnicode_CompareWithASCIIString(arg, "weak") == 0) {
+        npy_promotion_state = NPY_USE_WEAK_PROMOTION;
+    }
+    else if (PyUnicode_CompareWithASCIIString(arg, "weak_and_warn") == 0) {
+        npy_promotion_state = NPY_USE_WEAK_PROMOTION_AND_WARN;
+    }
+    else if (PyUnicode_CompareWithASCIIString(arg, "legacy") == 0) {
+        npy_promotion_state = NPY_USE_LEGACY_PROMOTION;
+    }
+    else {
+        PyErr_Format(PyExc_TypeError,
+                "_set_promotion_state() argument or NPY_PROMOTION_STATE must be "
+                "'weak', 'legacy', or 'weak_and_warn' but got '%.100S'", arg);
+        return NULL;
+    }
+    Py_RETURN_NONE;
+}
+
 /**
  * Fetch the casting implementation from one DType to another.
  *
@@ -106,9 +184,6 @@ PyArray_GetCastingImpl(PyArray_DTypeMeta *from, PyArray_DTypeMeta *to)
         return NULL;
     }
     else {
-        if (NPY_DT_is_parametric(from) || NPY_DT_is_parametric(to)) {
-            Py_RETURN_NONE;
-        }
         /* Reject non-legacy dtypes (they need to use the new API) */
         if (!NPY_DT_is_legacy(from) || !NPY_DT_is_legacy(to)) {
             Py_RETURN_NONE;
@@ -223,14 +298,11 @@ PyArray_MinCastSafety(NPY_CASTING casting1, NPY_CASTING casting2)
     if (casting1 < 0 || casting2 < 0) {
         return -1;
     }
-    NPY_CASTING view = casting1 & casting2 & _NPY_CAST_IS_VIEW;
-    casting1 = casting1 & ~_NPY_CAST_IS_VIEW;
-    casting2 = casting2 & ~_NPY_CAST_IS_VIEW;
     /* larger casting values are less safe */
     if (casting1 > casting2) {
-        return casting1 | view;
+        return casting1;
     }
-    return casting2 | view;
+    return casting2;
 }
 
 
@@ -248,6 +320,12 @@ PyArray_CastToType(PyArrayObject *arr, PyArray_Descr *dtype, int is_f_order)
 {
     PyObject *out;
 
+    if (dtype == NULL) {
+        PyErr_SetString(PyExc_ValueError,
+            "dtype is NULL in PyArray_CastToType");
+        return NULL;
+    }
+
     Py_SETREF(dtype, PyArray_AdaptDescriptorToArray(arr, (PyObject *)dtype));
     if (dtype == NULL) {
         return NULL;
@@ -363,29 +441,41 @@ PyArray_CastAnyTo(PyArrayObject *out, PyArrayObject *mp)
 
 static NPY_CASTING
 _get_cast_safety_from_castingimpl(PyArrayMethodObject *castingimpl,
-        PyArray_DTypeMeta *dtypes[2], PyArray_Descr *from, PyArray_Descr *to)
+        PyArray_DTypeMeta *dtypes[2], PyArray_Descr *from, PyArray_Descr *to,
+        npy_intp *view_offset)
 {
     PyArray_Descr *descrs[2] = {from, to};
     PyArray_Descr *out_descrs[2];
 
+    *view_offset = NPY_MIN_INTP;
     NPY_CASTING casting = castingimpl->resolve_descriptors(
-            castingimpl, dtypes, descrs, out_descrs);
+            castingimpl, dtypes, descrs, out_descrs, view_offset);
     if (casting < 0) {
         return -1;
     }
     /* The returned descriptors may not match, requiring a second check */
     if (out_descrs[0] != descrs[0]) {
-        NPY_CASTING from_casting = PyArray_GetCastSafety(
-                descrs[0], out_descrs[0], NULL);
+        npy_intp from_offset = NPY_MIN_INTP;
+        NPY_CASTING from_casting = PyArray_GetCastInfo(
+                descrs[0], out_descrs[0], NULL, &from_offset);
         casting = PyArray_MinCastSafety(casting, from_casting);
+        if (from_offset != *view_offset) {
+            /* `view_offset` differs: The multi-step cast cannot be a view. */
+            *view_offset = NPY_MIN_INTP;
+        }
         if (casting < 0) {
             goto finish;
         }
     }
     if (descrs[1] != NULL && out_descrs[1] != descrs[1]) {
-        NPY_CASTING from_casting = PyArray_GetCastSafety(
-                descrs[1], out_descrs[1], NULL);
+        npy_intp from_offset = NPY_MIN_INTP;
+        NPY_CASTING from_casting = PyArray_GetCastInfo(
+                descrs[1], out_descrs[1], NULL, &from_offset);
         casting = PyArray_MinCastSafety(casting, from_casting);
+        if (from_offset != *view_offset) {
+            /* `view_offset` differs: The multi-step cast cannot be a view. */
+            *view_offset = NPY_MIN_INTP;
+        }
         if (casting < 0) {
             goto finish;
         }
@@ -396,15 +486,21 @@ _get_cast_safety_from_castingimpl(PyArrayMethodObject *castingimpl,
     Py_DECREF(out_descrs[1]);
     /*
      * Check for less harmful non-standard returns.  The following two returns
-     * should never happen. They would be roughly equivalent, but less precise,
-     * versions of `(NPY_NO_CASTING|_NPY_CAST_IS_VIEW)`.
-     * 1. No-casting must imply cast-is-view.
-     * 2. Equivalent-casting + cast-is-view is (currently) the definition
-     *    of a "no" cast (there may be reasons to relax this).
-     * Note that e.g. `(NPY_UNSAFE_CASTING|_NPY_CAST_IS_VIEW)` is valid.
+     * should never happen:
+     * 1. No-casting must imply a view offset of 0.
+     * 2. Equivalent-casting + 0 view offset is (usually) the definition
+     *    of a "no" cast.  However, changing the order of fields can also
+     *    create descriptors that are not equivalent but views.
+     * Note that unsafe casts can have a view offset.  For example, in
+     * principle, casting `casting` when available.  This allows for two things:
  *
  * 1. It avoids  calling `resolve_descriptors` in some cases.
@@ -493,8 +591,9 @@ PyArray_CheckCastSafety(NPY_CASTING casting,
     }
 
     PyArray_DTypeMeta *dtypes[2] = {NPY_DTYPE(from), to_dtype};
+    npy_intp view_offset;
     NPY_CASTING safety = _get_cast_safety_from_castingimpl(castingimpl,
-            dtypes, from, to);
+            dtypes, from, to, &view_offset);
     Py_DECREF(meth);
     /* If casting is the smaller (or equal) safety we match */
     if (safety < 0) {
@@ -754,6 +853,55 @@ can_cast_scalar_to(PyArray_Descr *scal_type, char *scal_data,
     return ret;
 }
 
+
+NPY_NO_EXPORT npy_bool
+can_cast_pyscalar_scalar_to(
+        int flags, PyArray_Descr *to, NPY_CASTING casting)
+{
+    /*
+     * This function only works reliably for legacy (NumPy dtypes).
+     * If we end up here for a non-legacy DType, it is a bug.
+     */
+    assert(NPY_DT_is_legacy(NPY_DTYPE(to)));
+
+    /*
+     * Quickly check for the typical numeric cases, where the casting rules
+     * can be hardcoded fairly easily.
+     */
+    if (PyDataType_ISCOMPLEX(to)) {
+        return 1;
+    }
+    else if (PyDataType_ISFLOAT(to)) {
+        if (flags & NPY_ARRAY_WAS_PYTHON_COMPLEX) {
+            return casting == NPY_UNSAFE_CASTING;
+        }
+        return 1;
+    }
+    else if (PyDataType_ISINTEGER(to)) {
+        if (!(flags & NPY_ARRAY_WAS_PYTHON_INT)) {
+            return casting == NPY_UNSAFE_CASTING;
+        }
+        return 1;
+    }
+
+    /*
+     * For all other cases we use the default dtype.
+     */
+    PyArray_Descr *from;
+    if (flags & NPY_ARRAY_WAS_PYTHON_INT) {
+        from = PyArray_DescrFromType(NPY_LONG);
+    }
+    else if (flags & NPY_ARRAY_WAS_PYTHON_FLOAT) {
+        from = PyArray_DescrFromType(NPY_DOUBLE);
+    }
+    else {
+        from = PyArray_DescrFromType(NPY_CDOUBLE);
+    }
+    int res = PyArray_CanCastTypeTo(from, to, casting);
+    Py_DECREF(from);
+    return res;
+}
+
 /*NUMPY_API
  * Returns 1 if the array object may be cast to the given data type using
  * the casting rule, 0 otherwise.  This differs from PyArray_CanCastTo in
@@ -772,12 +920,25 @@ PyArray_CanCastArrayTo(PyArrayObject *arr, PyArray_Descr *to,
         to = NULL;
     }
 
-    /*
-     * If it's a scalar, check the value.  (This only currently matters for
-     * numeric types and for `to == NULL` it can't be numeric.)
-     */
-    if (PyArray_NDIM(arr) == 0 && !PyArray_HASFIELDS(arr) && to != NULL) {
-        return can_cast_scalar_to(from, PyArray_DATA(arr), to, casting);
+    if (npy_promotion_state == NPY_USE_LEGACY_PROMOTION) {
+        /*
+         * If it's a scalar, check the value.  (This only currently matters for
+         * numeric types and for `to == NULL` it can't be numeric.)
+         */
+        if (PyArray_NDIM(arr) == 0 && !PyArray_HASFIELDS(arr) && to != NULL) {
+            return can_cast_scalar_to(from, PyArray_DATA(arr), to, casting);
+        }
+    }
+    else {
+        /*
+         * If it's a scalar, check the value.  (This only currently matters for
+         * numeric types and for `to == NULL` it can't be numeric.)
+         */
+        if (PyArray_FLAGS(arr) & NPY_ARRAY_WAS_PYTHON_LITERAL && to != NULL) {
+            return can_cast_pyscalar_scalar_to(
+                    PyArray_FLAGS(arr) & NPY_ARRAY_WAS_PYTHON_LITERAL, to,
+                    casting);
+        }
     }
 
     /* Otherwise, use the standard rules (same as `PyArray_CanCastTypeTo`) */
@@ -909,22 +1070,6 @@ promote_types(PyArray_Descr *type1, PyArray_Descr *type2,
 
 }
 
-/*
- * Returns a new reference to type if it is already NBO, otherwise
- * returns a copy converted to NBO.
- */
-NPY_NO_EXPORT PyArray_Descr *
-ensure_dtype_nbo(PyArray_Descr *type)
-{
-    if (PyArray_ISNBO(type->byteorder)) {
-        Py_INCREF(type);
-        return type;
-    }
-    else {
-        return PyArray_DescrNewByteorder(type, NPY_NATIVE);
-    }
-}
-
 
 /**
  * This function should possibly become public API eventually.  At this
@@ -971,8 +1116,9 @@ PyArray_CastDescrToDType(PyArray_Descr *descr, PyArray_DTypeMeta *given_DType)
     PyArray_Descr *loop_descrs[2];
 
     PyArrayMethodObject *meth = (PyArrayMethodObject *)tmp;
+    npy_intp view_offset = NPY_MIN_INTP;
     NPY_CASTING casting = meth->resolve_descriptors(
-            meth, dtypes, given_descrs, loop_descrs);
+            meth, dtypes, given_descrs, loop_descrs, &view_offset);
     Py_DECREF(tmp);
     if (casting < 0) {
         goto error;
@@ -1006,7 +1152,7 @@ PyArray_FindConcatenationDescriptor(
         npy_intp n, PyArrayObject **arrays, PyObject *requested_dtype)
 {
     if (requested_dtype == NULL) {
-        return PyArray_LegacyResultType(n, arrays, 0, NULL);
+        return PyArray_ResultType(n, arrays, 0, NULL);
     }
 
     PyArray_DTypeMeta *common_dtype;
@@ -1067,7 +1213,13 @@ PyArray_PromoteTypes(PyArray_Descr *type1, PyArray_Descr *type2)
     PyArray_Descr *res;
 
     /* Fast path for identical inputs (NOTE: This path preserves metadata!) */
-    if (type1 == type2 && PyArray_ISNBO(type1->byteorder)) {
+    if (type1 == type2
+            /*
+             * Short-cut for legacy/builtin dtypes except void, since void has
+             * no reliable byteorder.  Note: This path preserves metadata!
+             */
+            && NPY_DT_is_legacy(NPY_DTYPE(type1))
+            && PyArray_ISNBO(type1->byteorder) && type1->type_num != NPY_VOID) {
         Py_INCREF(type1);
         return type1;
     }
@@ -1548,40 +1700,44 @@ should_use_min_scalar(npy_intp narrs, PyArrayObject **arr,
 }
 
 
-/*
- * Utility function used only in PyArray_ResultType for value-based logic.
- * See that function for the meaning and contents of the parameters.
- */
-static PyArray_Descr *
-get_descr_from_cast_or_value(
-        npy_intp i,
-        PyArrayObject *arrs[],
-        npy_intp ndtypes,
-        PyArray_Descr *descriptor,
-        PyArray_DTypeMeta *common_dtype)
-{
-    PyArray_Descr *curr;
-    if (NPY_LIKELY(i < ndtypes ||
-            !(PyArray_FLAGS(arrs[i-ndtypes]) & _NPY_ARRAY_WAS_PYSCALAR))) {
-        curr = PyArray_CastDescrToDType(descriptor, common_dtype);
-    }
-    else {
-        /*
-         * Unlike `PyArray_CastToDTypeAndPromoteDescriptors`, deal with
-         * plain Python values "graciously". This recovers the original
-         * value the long route, but it should almost never happen...
-         */
-        PyObject *tmp = PyArray_GETITEM(arrs[i-ndtypes],
-                                        PyArray_BYTES(arrs[i-ndtypes]));
-        if (tmp == NULL) {
-            return NULL;
+NPY_NO_EXPORT int
+should_use_min_scalar_weak_literals(int narrs, PyArrayObject **arr) {
+    int all_scalars = 1;
+    int max_scalar_kind = -1;
+    int max_array_kind = -1;
+
+    for (int i = 0; i < narrs; i++) {
+        if (PyArray_FLAGS(arr[i]) & NPY_ARRAY_WAS_PYTHON_INT) {
+            /* A Python integer could be `u` so is effectively that: */
+            int new = dtype_kind_to_simplified_ordering('u');
+            if (new > max_scalar_kind) {
+                max_scalar_kind = new;
+            }
+        }
+        /* For the new logic, only complex or not matters: */
+        else if (PyArray_FLAGS(arr[i]) & NPY_ARRAY_WAS_PYTHON_FLOAT) {
+            max_scalar_kind = dtype_kind_to_simplified_ordering('f');
+        }
+        else if (PyArray_FLAGS(arr[i]) & NPY_ARRAY_WAS_PYTHON_COMPLEX) {
+            max_scalar_kind = dtype_kind_to_simplified_ordering('f');
+        }
+        else {
+            all_scalars = 0;
+            int kind = dtype_kind_to_simplified_ordering(
+                    PyArray_DESCR(arr[i])->kind);
+            if (kind > max_array_kind) {
+                max_array_kind = kind;
+            }
         }
-        curr = NPY_DT_CALL_discover_descr_from_pyobject(common_dtype, tmp);
-        Py_DECREF(tmp);
     }
-    return curr;
+    if (!all_scalars && max_array_kind >= max_scalar_kind) {
+        return 1;
+    }
+
+    return 0;
 }
 
+
 /*NUMPY_API
  *
  * Produces the result type of a bunch of inputs, using the same rules
@@ -1617,7 +1773,7 @@ PyArray_ResultType(
                     "no arrays or types available to calculate result type");
             return NULL;
         }
-        return ensure_dtype_nbo(result);
+        return NPY_DT_CALL_ensure_canonical(result);
     }
 
     void **info_on_heap = NULL;
@@ -1654,39 +1810,32 @@ PyArray_ResultType(
             at_least_one_scalar = 1;
         }
 
-        if (!(PyArray_FLAGS(arrs[i]) & _NPY_ARRAY_WAS_PYSCALAR)) {
-            /* This was not a scalar with an abstract DType */
-            all_descriptors[i_all] = PyArray_DTYPE(arrs[i]);
-            all_DTypes[i_all] = NPY_DTYPE(all_descriptors[i_all]);
-            Py_INCREF(all_DTypes[i_all]);
-            all_pyscalar = 0;
-            continue;
-        }
-
         /*
-         * The original was a Python scalar with an abstract DType.
-         * In a future world, this type of code may need to work on the
-         * DType level first and discover those from the original value.
-         * But, right now we limit the logic to int, float, and complex
-         * and do it here to allow for a transition without losing all of
-         * our remaining sanity.
+         * If the original was a Python scalar/literal, we use only the
+         * corresponding abstract DType (and no descriptor) below.
+         * Otherwise, we propagate the descriptor as well.
          */
-        if (PyArray_ISFLOAT(arrs[i])) {
+        all_descriptors[i_all] = NULL;  /* no descriptor for py-scalars */
+        if (PyArray_FLAGS(arrs[i]) & NPY_ARRAY_WAS_PYTHON_INT) {
+            /* This could even be an object dtype here for large ints */
+            all_DTypes[i_all] = &PyArray_PyIntAbstractDType;
+            if (PyArray_TYPE(arrs[i]) != NPY_LONG) {
+                /* Not a "normal" scalar, so we cannot avoid the legacy path */
+                all_pyscalar = 0;
+            }
+        }
+        else if (PyArray_FLAGS(arrs[i]) & NPY_ARRAY_WAS_PYTHON_FLOAT) {
             all_DTypes[i_all] = &PyArray_PyFloatAbstractDType;
         }
-        else if (PyArray_ISCOMPLEX(arrs[i])) {
+        else if (PyArray_FLAGS(arrs[i]) & NPY_ARRAY_WAS_PYTHON_COMPLEX) {
             all_DTypes[i_all] = &PyArray_PyComplexAbstractDType;
         }
         else {
-            /* N.B.: Could even be an object dtype here for large ints */
-            all_DTypes[i_all] = &PyArray_PyIntAbstractDType;
+            all_descriptors[i_all] = PyArray_DTYPE(arrs[i]);
+            all_DTypes[i_all] = NPY_DTYPE(all_descriptors[i_all]);
+            all_pyscalar = 0;
         }
         Py_INCREF(all_DTypes[i_all]);
-        /*
-         * Leave the descriptor empty, if we need it, we will have to go
-         * to more extreme lengths unfortunately.
-         */
-        all_descriptors[i_all] = NULL;
     }
 
     PyArray_DTypeMeta *common_dtype = PyArray_PromoteDTypeSequence(
@@ -1713,23 +1862,20 @@ PyArray_ResultType(
      * NOTE: Code duplicates `PyArray_CastToDTypeAndPromoteDescriptors`, but
      *       supports special handling of the abstract values.
      */
-    if (!NPY_DT_is_parametric(common_dtype)) {
-        /* Note that this "fast" path loses all metadata */
-        result = NPY_DT_CALL_default_descr(common_dtype);
-    }
-    else {
-        result = get_descr_from_cast_or_value(
-                    0, arrs, ndtypes, all_descriptors[0], common_dtype);
-        if (result == NULL) {
-            goto error;
-        }
-
-        for (npy_intp i = 1; i < ndtypes+narrs; i++) {
-            PyArray_Descr *curr = get_descr_from_cast_or_value(
-                    i, arrs, ndtypes, all_descriptors[i], common_dtype);
+    if (NPY_DT_is_parametric(common_dtype)) {
+        for (npy_intp i = 0; i < ndtypes+narrs; i++) {
+            if (all_descriptors[i] == NULL) {
+                continue;  /* originally a python scalar/literal */
+            }
+            PyArray_Descr *curr = PyArray_CastDescrToDType(
+                    all_descriptors[i], common_dtype);
             if (curr == NULL) {
                 goto error;
             }
+            if (result == NULL) {
+                result = curr;
+                continue;
+            }
             Py_SETREF(result, NPY_DT_SLOTS(common_dtype)->common_instance(result, curr));
             Py_DECREF(curr);
             if (result == NULL) {
@@ -1737,27 +1883,33 @@ PyArray_ResultType(
             }
         }
     }
+    if (result == NULL) {
+        /*
+         * If the DType is not parametric, or all were weak scalars,
+         * a result may not yet be set.
+         */
+        result = NPY_DT_CALL_default_descr(common_dtype);
+        if (result == NULL) {
+            goto error;
+        }
+    }
 
     /*
-     * Unfortunately, when 0-D "scalar" arrays are involved and mixed, we
-     * have to use the value-based logic.  The intention is to move away from
-     * the complex logic arising from it.  We thus fall back to the legacy
-     * version here.
-     * It may be possible to micro-optimize this to skip some of the above
-     * logic when this path is necessary.
+     * Unfortunately, when 0-D "scalar" arrays are involved and mixed, we *may*
+     * have to use the value-based logic.
+     * `PyArray_CheckLegacyResultType` may behave differently based on the
+     * current value of `npy_legacy_promotion`:
+     * 1. It does nothing (we use the "new" behavior)
+     * 2. It does nothing, but warns if there the result would differ.
+     * 3. It replaces the result based on the legacy value-based logic.
      */
     if (at_least_one_scalar && !all_pyscalar && result->type_num < NPY_NTYPES) {
-        PyArray_Descr *legacy_result = PyArray_LegacyResultType(
-                narrs, arrs, ndtypes, descrs);
-        if (legacy_result == NULL) {
-            /*
-             * Going from error to success should not really happen, but is
-             * probably OK if it does.
-             */
-            goto error;
+        if (PyArray_CheckLegacyResultType(
+                &result, narrs, arrs, ndtypes, descrs) < 0) {
+            Py_DECREF(common_dtype);
+            Py_DECREF(result);
+            return NULL;
         }
-        /* Return the old "legacy" result (could warn here if different) */
-        Py_SETREF(result, legacy_result);
     }
 
     Py_DECREF(common_dtype);
@@ -1785,38 +1937,39 @@ PyArray_ResultType(
  * of all the inputs.  Data types passed directly are treated as array
  * types.
  */
-NPY_NO_EXPORT PyArray_Descr *
-PyArray_LegacyResultType(
+NPY_NO_EXPORT int
+PyArray_CheckLegacyResultType(
+        PyArray_Descr **new_result,
         npy_intp narrs, PyArrayObject **arr,
         npy_intp ndtypes, PyArray_Descr **dtypes)
 {
+    PyArray_Descr *ret = NULL;
+    if (npy_promotion_state == NPY_USE_WEAK_PROMOTION) {
+        return 0;
+    }
+    if (npy_promotion_state == NPY_USE_WEAK_PROMOTION_AND_WARN
+            && !npy_give_promotion_warnings()) {
+        return 0;
+    }
+
     npy_intp i;
 
-    /* If there's just one type, pass it through */
+    /* If there's just one type, results must match */
     if (narrs + ndtypes == 1) {
-        PyArray_Descr *ret = NULL;
-        if (narrs == 1) {
-            ret = PyArray_DESCR(arr[0]);
-        }
-        else {
-            ret = dtypes[0];
-        }
-        Py_INCREF(ret);
-        return ret;
+        return 0;
     }
 
     int use_min_scalar = should_use_min_scalar(narrs, arr, ndtypes, dtypes);
 
     /* Loop through all the types, promoting them */
     if (!use_min_scalar) {
-        PyArray_Descr *ret;
 
         /* Build a single array of all the dtypes */
         PyArray_Descr **all_dtypes = PyArray_malloc(
             sizeof(*all_dtypes) * (narrs + ndtypes));
         if (all_dtypes == NULL) {
             PyErr_NoMemory();
-            return NULL;
+            return -1;
         }
         for (i = 0; i < narrs; ++i) {
             all_dtypes[i] = PyArray_DESCR(arr[i]);
@@ -1826,11 +1979,9 @@ PyArray_LegacyResultType(
         }
         ret = PyArray_PromoteTypeSequence(all_dtypes, narrs + ndtypes);
         PyArray_free(all_dtypes);
-        return ret;
     }
     else {
         int ret_is_small_unsigned = 0;
-        PyArray_Descr *ret = NULL;
 
         for (i = 0; i < narrs; ++i) {
             int tmp_is_small_unsigned;
@@ -1838,7 +1989,7 @@ PyArray_LegacyResultType(
                 arr[i], &tmp_is_small_unsigned);
             if (tmp == NULL) {
                 Py_XDECREF(ret);
-                return NULL;
+                return -1;
             }
             /* Combine it with the existing type */
             if (ret == NULL) {
@@ -1852,7 +2003,7 @@ PyArray_LegacyResultType(
                 Py_DECREF(ret);
                 ret = tmpret;
                 if (ret == NULL) {
-                    return NULL;
+                    return -1;
                 }
 
                 ret_is_small_unsigned = tmp_is_small_unsigned &&
@@ -1873,7 +2024,7 @@ PyArray_LegacyResultType(
                 Py_DECREF(ret);
                 ret = tmpret;
                 if (ret == NULL) {
-                    return NULL;
+                    return -1;
                 }
             }
         }
@@ -1882,9 +2033,32 @@ PyArray_LegacyResultType(
             PyErr_SetString(PyExc_TypeError,
                     "no arrays or types available to calculate result type");
         }
+    }
+
+    if (ret == NULL) {
+        return -1;
+    }
+
+    int unchanged_result = PyArray_EquivTypes(*new_result, ret);
+    if (unchanged_result) {
+        Py_DECREF(ret);
+        return 0;
+    }
+    if (npy_promotion_state == NPY_USE_LEGACY_PROMOTION) {
+        Py_SETREF(*new_result, ret);
+        return 0;
+    }
 
-        return ret;
+    assert(npy_promotion_state == NPY_USE_WEAK_PROMOTION_AND_WARN);
+    if (PyErr_WarnFormat(PyExc_UserWarning, 1,
+            "result dtype changed due to the removal of value-based "
+            "promotion from NumPy. Changed from %S to %S.",
+            ret, *new_result) < 0) {
+        Py_DECREF(ret);
+        return -1;
     }
+    Py_DECREF(ret);
+    return 0;
 }
 
 /**
@@ -2289,13 +2463,14 @@ legacy_same_dtype_resolve_descriptors(
         PyArrayMethodObject *NPY_UNUSED(self),
         PyArray_DTypeMeta *NPY_UNUSED(dtypes[2]),
         PyArray_Descr *given_descrs[2],
-        PyArray_Descr *loop_descrs[2])
+        PyArray_Descr *loop_descrs[2],
+        npy_intp *view_offset)
 {
     Py_INCREF(given_descrs[0]);
     loop_descrs[0] = given_descrs[0];
 
     if (given_descrs[1] == NULL) {
-        loop_descrs[1] = ensure_dtype_nbo(loop_descrs[0]);
+        loop_descrs[1] = NPY_DT_CALL_ensure_canonical(loop_descrs[0]);
         if (loop_descrs[1] == NULL) {
             Py_DECREF(loop_descrs[0]);
             return -1;
@@ -2315,7 +2490,8 @@ legacy_same_dtype_resolve_descriptors(
      */
     if (PyDataType_ISNOTSWAPPED(loop_descrs[0]) ==
                 PyDataType_ISNOTSWAPPED(loop_descrs[1])) {
-        return NPY_NO_CASTING | _NPY_CAST_IS_VIEW;
+        *view_offset = 0;
+        return NPY_NO_CASTING;
     }
     return NPY_EQUIV_CASTING;
 }
@@ -2354,16 +2530,17 @@ simple_cast_resolve_descriptors(
         PyArrayMethodObject *self,
         PyArray_DTypeMeta *dtypes[2],
         PyArray_Descr *given_descrs[2],
-        PyArray_Descr *loop_descrs[2])
+        PyArray_Descr *loop_descrs[2],
+        npy_intp *view_offset)
 {
     assert(NPY_DT_is_legacy(dtypes[0]) && NPY_DT_is_legacy(dtypes[1]));
 
-    loop_descrs[0] = ensure_dtype_nbo(given_descrs[0]);
+    loop_descrs[0] = NPY_DT_CALL_ensure_canonical(given_descrs[0]);
     if (loop_descrs[0] == NULL) {
         return -1;
     }
     if (given_descrs[1] != NULL) {
-        loop_descrs[1] = ensure_dtype_nbo(given_descrs[1]);
+        loop_descrs[1] = NPY_DT_CALL_ensure_canonical(given_descrs[1]);
         if (loop_descrs[1] == NULL) {
             Py_DECREF(loop_descrs[0]);
             return -1;
@@ -2378,7 +2555,8 @@ simple_cast_resolve_descriptors(
     }
     if (PyDataType_ISNOTSWAPPED(loop_descrs[0]) ==
             PyDataType_ISNOTSWAPPED(loop_descrs[1])) {
-        return NPY_NO_CASTING | _NPY_CAST_IS_VIEW;
+        *view_offset = 0;
+        return NPY_NO_CASTING;
     }
     return NPY_EQUIV_CASTING;
 }
@@ -2429,7 +2607,7 @@ get_byteswap_loop(
 NPY_NO_EXPORT int
 complex_to_noncomplex_get_loop(
         PyArrayMethod_Context *context,
-        int aligned, int move_references, npy_intp *strides,
+        int aligned, int move_references, const npy_intp *strides,
         PyArrayMethod_StridedLoop **out_loop, NpyAuxData **out_transferdata,
         NPY_ARRAYMETHOD_FLAGS *flags)
 {
@@ -2461,8 +2639,8 @@ add_numeric_cast(PyArray_DTypeMeta *from, PyArray_DTypeMeta *to)
             .nin = 1,
             .nout = 1,
             .flags = NPY_METH_SUPPORTS_UNALIGNED,
-            .slots = slots,
             .dtypes = dtypes,
+            .slots = slots,
     };
 
     npy_intp from_itemsize = from->singleton->elsize;
@@ -2572,7 +2750,8 @@ cast_to_string_resolve_descriptors(
         PyArrayMethodObject *self,
         PyArray_DTypeMeta *dtypes[2],
         PyArray_Descr *given_descrs[2],
-        PyArray_Descr *loop_descrs[2])
+        PyArray_Descr *loop_descrs[2],
+        npy_intp *NPY_UNUSED(view_offset))
 {
     /*
      * NOTE: The following code used to be part of PyArray_AdaptFlexibleDType
@@ -2648,14 +2827,14 @@ cast_to_string_resolve_descriptors(
     }
     else {
         /* The legacy loop can handle mismatching itemsizes */
-        loop_descrs[1] = ensure_dtype_nbo(given_descrs[1]);
+        loop_descrs[1] = NPY_DT_CALL_ensure_canonical(given_descrs[1]);
         if (loop_descrs[1] == NULL) {
             return -1;
         }
     }
 
     /* Set the input one as well (late for easier error management) */
-    loop_descrs[0] = ensure_dtype_nbo(given_descrs[0]);
+    loop_descrs[0] = NPY_DT_CALL_ensure_canonical(given_descrs[0]);
     if (loop_descrs[0] == NULL) {
         return -1;
     }
@@ -2702,7 +2881,7 @@ add_other_to_and_from_string_cast(
         .name = "legacy_cast_to_string",
         .nin = 1,
         .nout = 1,
-        .flags = NPY_METH_REQUIRES_PYAPI,
+        .flags = NPY_METH_REQUIRES_PYAPI | NPY_METH_NO_FLOATINGPOINT_ERRORS,
         .dtypes = dtypes,
         .slots = slots,
     };
@@ -2723,13 +2902,14 @@ string_to_string_resolve_descriptors(
         PyArrayMethodObject *NPY_UNUSED(self),
         PyArray_DTypeMeta *NPY_UNUSED(dtypes[2]),
         PyArray_Descr *given_descrs[2],
-        PyArray_Descr *loop_descrs[2])
+        PyArray_Descr *loop_descrs[2],
+        npy_intp *view_offset)
 {
     Py_INCREF(given_descrs[0]);
     loop_descrs[0] = given_descrs[0];
 
     if (given_descrs[1] == NULL) {
-        loop_descrs[1] = ensure_dtype_nbo(loop_descrs[0]);
+        loop_descrs[1] = NPY_DT_CALL_ensure_canonical(loop_descrs[0]);
         if (loop_descrs[1] == NULL) {
             return -1;
         }
@@ -2739,26 +2919,36 @@ string_to_string_resolve_descriptors(
         loop_descrs[1] = given_descrs[1];
     }
 
-    if (loop_descrs[0]->elsize == loop_descrs[1]->elsize) {
-        if (PyDataType_ISNOTSWAPPED(loop_descrs[0]) ==
-                PyDataType_ISNOTSWAPPED(loop_descrs[1])) {
-            return NPY_NO_CASTING | _NPY_CAST_IS_VIEW;
+    if (loop_descrs[0]->elsize < loop_descrs[1]->elsize) {
+        /* New string is longer: safe but cannot be a view */
+        return NPY_SAFE_CASTING;
+    }
+    else {
+        /* New string fits into old: if the byte-order matches can be a view */
+        int not_swapped = (PyDataType_ISNOTSWAPPED(loop_descrs[0])
+                           == PyDataType_ISNOTSWAPPED(loop_descrs[1]));
+        if (not_swapped) {
+            *view_offset = 0;
+        }
+
+        if (loop_descrs[0]->elsize > loop_descrs[1]->elsize) {
+            return NPY_SAME_KIND_CASTING;
+        }
+        /* The strings have the same length: */
+        if (not_swapped) {
+            return NPY_NO_CASTING;
         }
         else {
             return NPY_EQUIV_CASTING;
         }
     }
-    else if (loop_descrs[0]->elsize <= loop_descrs[1]->elsize) {
-        return NPY_SAFE_CASTING;
-    }
-    return NPY_SAME_KIND_CASTING;
 }
 
 
 NPY_NO_EXPORT int
 string_to_string_get_loop(
         PyArrayMethod_Context *context,
-        int aligned, int NPY_UNUSED(move_references), npy_intp *strides,
+        int aligned, int NPY_UNUSED(move_references), const npy_intp *strides,
         PyArrayMethod_StridedLoop **out_loop, NpyAuxData **out_transferdata,
         NPY_ARRAYMETHOD_FLAGS *flags)
 {
@@ -2828,9 +3018,9 @@ PyArray_InitializeStringCasts(void)
             {0, NULL}};
     PyArrayMethod_Spec spec = {
             .name = "string_to_string_cast",
-            .casting = NPY_UNSAFE_CASTING,
             .nin = 1,
             .nout = 1,
+            .casting = NPY_UNSAFE_CASTING,
             .flags = (NPY_METH_REQUIRES_PYAPI |
                       NPY_METH_NO_FLOATINGPOINT_ERRORS |
                       NPY_METH_SUPPORTS_UNALIGNED),
@@ -2866,7 +3056,8 @@ PyArray_InitializeStringCasts(void)
  */
 static NPY_CASTING
 cast_to_void_dtype_class(
-        PyArray_Descr **given_descrs, PyArray_Descr **loop_descrs)
+        PyArray_Descr **given_descrs, PyArray_Descr **loop_descrs,
+        npy_intp *view_offset)
 {
     /* `dtype="V"` means unstructured currently (compare final path) */
     loop_descrs[1] = PyArray_DescrNewFromType(NPY_VOID);
@@ -2876,11 +3067,13 @@ cast_to_void_dtype_class(
     loop_descrs[1]->elsize = given_descrs[0]->elsize;
     Py_INCREF(given_descrs[0]);
     loop_descrs[0] = given_descrs[0];
+
+    *view_offset = 0;
     if (loop_descrs[0]->type_num == NPY_VOID &&
             loop_descrs[0]->subarray == NULL && loop_descrs[1]->names == NULL) {
-        return NPY_NO_CASTING | _NPY_CAST_IS_VIEW;
+        return NPY_NO_CASTING;
     }
-    return NPY_SAFE_CASTING | _NPY_CAST_IS_VIEW;
+    return NPY_SAFE_CASTING;
 }
 
 
@@ -2889,12 +3082,13 @@ nonstructured_to_structured_resolve_descriptors(
         PyArrayMethodObject *NPY_UNUSED(self),
         PyArray_DTypeMeta *NPY_UNUSED(dtypes[2]),
         PyArray_Descr *given_descrs[2],
-        PyArray_Descr *loop_descrs[2])
+        PyArray_Descr *loop_descrs[2],
+        npy_intp *view_offset)
 {
     NPY_CASTING casting;
 
     if (given_descrs[1] == NULL) {
-        return cast_to_void_dtype_class(given_descrs, loop_descrs);
+        return cast_to_void_dtype_class(given_descrs, loop_descrs, view_offset);
     }
 
     if (given_descrs[1]->subarray != NULL) {
@@ -2903,12 +3097,18 @@ nonstructured_to_structured_resolve_descriptors(
          * possible to allow a view if the field has exactly one element.
          */
         casting = NPY_SAFE_CASTING;
+        npy_intp sub_view_offset = NPY_MIN_INTP;
         /* Subarray dtype */
-        NPY_CASTING base_casting = PyArray_GetCastSafety(
-                given_descrs[0], given_descrs[1]->subarray->base, NULL);
+        NPY_CASTING base_casting = PyArray_GetCastInfo(
+                given_descrs[0], given_descrs[1]->subarray->base, NULL,
+                &sub_view_offset);
         if (base_casting < 0) {
             return -1;
         }
+        if (given_descrs[1]->elsize == given_descrs[1]->subarray->base->elsize) {
+            /* A single field, view is OK if sub-view is */
+            *view_offset = sub_view_offset;
+        }
         casting = PyArray_MinCastSafety(casting, base_casting);
     }
     else if (given_descrs[1]->names != NULL) {
@@ -2920,21 +3120,32 @@ nonstructured_to_structured_resolve_descriptors(
         else {
             /* Considered at most unsafe casting (but this could be changed) */
             casting = NPY_UNSAFE_CASTING;
-            if (PyTuple_Size(given_descrs[1]->names) == 1) {
-                /* A view may be acceptable */
-                casting |= _NPY_CAST_IS_VIEW;
-            }
 
             Py_ssize_t pos = 0;
             PyObject *key, *tuple;
             while (PyDict_Next(given_descrs[1]->fields, &pos, &key, &tuple)) {
                 PyArray_Descr *field_descr = (PyArray_Descr *)PyTuple_GET_ITEM(tuple, 0);
-                NPY_CASTING field_casting = PyArray_GetCastSafety(
-                        given_descrs[0], field_descr, NULL);
+                npy_intp field_view_off = NPY_MIN_INTP;
+                NPY_CASTING field_casting = PyArray_GetCastInfo(
+                        given_descrs[0], field_descr, NULL, &field_view_off);
                 casting = PyArray_MinCastSafety(casting, field_casting);
                 if (casting < 0) {
                     return -1;
                 }
+                if (field_view_off != NPY_MIN_INTP) {
+                    npy_intp to_off = PyLong_AsSsize_t(PyTuple_GET_ITEM(tuple, 1));
+                    if (error_converting(to_off)) {
+                        return -1;
+                    }
+                    *view_offset = field_view_off - to_off;
+                }
+            }
+            if (PyTuple_Size(given_descrs[1]->names) != 1 || *view_offset < 0) {
+                /*
+                 * Assume that a view is impossible when there is more than one
+                 * field.  (Fields could overlap, but that seems weird...)
+                 */
+                *view_offset = NPY_MIN_INTP;
             }
         }
     }
@@ -2944,15 +3155,20 @@ nonstructured_to_structured_resolve_descriptors(
                 !PyDataType_REFCHK(given_descrs[0])) {
             /*
              * A simple view, at the moment considered "safe" (the refcheck is
-             * probably not necessary, but more future proof
+             * probably not necessary, but more future proof)
              */
-            casting = NPY_SAFE_CASTING | _NPY_CAST_IS_VIEW;
+            *view_offset = 0;
+            casting = NPY_SAFE_CASTING;
         }
         else if (given_descrs[0]->elsize <= given_descrs[1]->elsize) {
             casting = NPY_SAFE_CASTING;
         }
         else {
             casting = NPY_UNSAFE_CASTING;
+            /* new elsize is smaller so a view is OK (reject refs for now) */
+            if (!PyDataType_REFCHK(given_descrs[0])) {
+                *view_offset = 0;
+            }
         }
     }
 
@@ -2981,32 +3197,28 @@ static int
 nonstructured_to_structured_get_loop(
         PyArrayMethod_Context *context,
         int aligned, int move_references,
-        npy_intp *strides,
+        const npy_intp *strides,
         PyArrayMethod_StridedLoop **out_loop,
         NpyAuxData **out_transferdata,
         NPY_ARRAYMETHOD_FLAGS *flags)
 {
     if (context->descriptors[1]->names != NULL) {
-        int needs_api = 0;
         if (get_fields_transfer_function(
                 aligned, strides[0], strides[1],
                 context->descriptors[0], context->descriptors[1],
                 move_references, out_loop, out_transferdata,
-                &needs_api) == NPY_FAIL) {
+                flags) == NPY_FAIL) {
             return -1;
         }
-        *flags = needs_api ? NPY_METH_REQUIRES_PYAPI : 0;
     }
     else if (context->descriptors[1]->subarray != NULL) {
-        int needs_api = 0;
         if (get_subarray_transfer_function(
                 aligned, strides[0], strides[1],
                 context->descriptors[0], context->descriptors[1],
                 move_references, out_loop, out_transferdata,
-                &needs_api) == NPY_FAIL) {
+                flags) == NPY_FAIL) {
             return -1;
         }
-        *flags = needs_api ? NPY_METH_REQUIRES_PYAPI : 0;
     }
     else {
         /*
@@ -3048,6 +3260,8 @@ PyArray_GetGenericToVoidCastingImpl(void)
     method->casting = -1;
     method->resolve_descriptors = &nonstructured_to_structured_resolve_descriptors;
     method->get_strided_loop = &nonstructured_to_structured_get_loop;
+    method->nin = 1;
+    method->nout = 1;
 
     return (PyObject *)method;
 }
@@ -3058,12 +3272,19 @@ structured_to_nonstructured_resolve_descriptors(
         PyArrayMethodObject *NPY_UNUSED(self),
         PyArray_DTypeMeta *dtypes[2],
         PyArray_Descr *given_descrs[2],
-        PyArray_Descr *loop_descrs[2])
+        PyArray_Descr *loop_descrs[2],
+        npy_intp *view_offset)
 {
     PyArray_Descr *base_descr;
+    /* The structured part may allow a view (and have its own offset): */
+    npy_intp struct_view_offset = NPY_MIN_INTP;
 
     if (given_descrs[0]->subarray != NULL) {
         base_descr = given_descrs[0]->subarray->base;
+        /* A view is possible if the subarray has exactly one element: */
+        if (given_descrs[0]->elsize == given_descrs[0]->subarray->base->elsize) {
+            struct_view_offset = 0;
+        }
     }
     else if (given_descrs[0]->names != NULL) {
         if (PyTuple_Size(given_descrs[0]->names) != 1) {
@@ -3073,6 +3294,10 @@ structured_to_nonstructured_resolve_descriptors(
         PyObject *key = PyTuple_GetItem(given_descrs[0]->names, 0);
         PyObject *base_tup = PyDict_GetItem(given_descrs[0]->fields, key);
         base_descr = (PyArray_Descr *)PyTuple_GET_ITEM(base_tup, 0);
+        struct_view_offset = PyLong_AsSsize_t(PyTuple_GET_ITEM(base_tup, 1));
+        if (error_converting(struct_view_offset)) {
+            return -1;
+        }
     }
     else {
         /*
@@ -3080,20 +3305,29 @@ structured_to_nonstructured_resolve_descriptors(
          * at this time they go back to legacy behaviour using getitem/setitem.
          */
         base_descr = NULL;
+        struct_view_offset = 0;
     }
 
     /*
-     * The cast is always considered unsafe, so the PyArray_GetCastSafety
-     * result currently does not matter.
+     * The cast is always considered unsafe, so the PyArray_GetCastInfo
+     * result currently only matters for the view_offset.
      */
-    if (base_descr != NULL && PyArray_GetCastSafety(
-            base_descr, given_descrs[1], dtypes[1]) < 0) {
+    npy_intp base_view_offset = NPY_MIN_INTP;
+    if (base_descr != NULL && PyArray_GetCastInfo(
+            base_descr, given_descrs[1], dtypes[1], &base_view_offset) < 0) {
         return -1;
     }
+    if (base_view_offset != NPY_MIN_INTP
+            && struct_view_offset != NPY_MIN_INTP) {
+        *view_offset = base_view_offset + struct_view_offset;
+    }
 
     /* Void dtypes always do the full cast. */
     if (given_descrs[1] == NULL) {
         loop_descrs[1] = NPY_DT_CALL_default_descr(dtypes[1]);
+        if (loop_descrs[1] == NULL) {
+            return -1;
+        }
         /*
          * Special case strings here, it should be useless (and only actually
          * work for empty arrays).  Possibly this should simply raise for
@@ -3121,32 +3355,28 @@ static int
 structured_to_nonstructured_get_loop(
         PyArrayMethod_Context *context,
         int aligned, int move_references,
-        npy_intp *strides,
+        const npy_intp *strides,
         PyArrayMethod_StridedLoop **out_loop,
         NpyAuxData **out_transferdata,
         NPY_ARRAYMETHOD_FLAGS *flags)
 {
     if (context->descriptors[0]->names != NULL) {
-        int needs_api = 0;
         if (get_fields_transfer_function(
                 aligned, strides[0], strides[1],
                 context->descriptors[0], context->descriptors[1],
                 move_references, out_loop, out_transferdata,
-                &needs_api) == NPY_FAIL) {
+                flags) == NPY_FAIL) {
             return -1;
         }
-        *flags = needs_api ? NPY_METH_REQUIRES_PYAPI : 0;
     }
     else if (context->descriptors[0]->subarray != NULL) {
-        int needs_api = 0;
         if (get_subarray_transfer_function(
                 aligned, strides[0], strides[1],
                 context->descriptors[0], context->descriptors[1],
                 move_references, out_loop, out_transferdata,
-                &needs_api) == NPY_FAIL) {
+                flags) == NPY_FAIL) {
             return -1;
         }
-        *flags = needs_api ? NPY_METH_REQUIRES_PYAPI : 0;
     }
     else {
         /*
@@ -3187,6 +3417,8 @@ PyArray_GetVoidToGenericCastingImpl(void)
     method->casting = -1;
     method->resolve_descriptors = &structured_to_nonstructured_resolve_descriptors;
     method->get_strided_loop = &structured_to_nonstructured_get_loop;
+    method->nin = 1;
+    method->nout = 1;
 
     return (PyObject *)method;
 }
@@ -3201,73 +3433,106 @@ PyArray_GetVoidToGenericCastingImpl(void)
  *       implementations on the dtype, to avoid duplicate work.
  */
 static NPY_CASTING
-can_cast_fields_safety(PyArray_Descr *from, PyArray_Descr *to)
+can_cast_fields_safety(
+        PyArray_Descr *from, PyArray_Descr *to, npy_intp *view_offset)
 {
-    NPY_CASTING casting = NPY_NO_CASTING | _NPY_CAST_IS_VIEW;
-
     Py_ssize_t field_count = PyTuple_Size(from->names);
     if (field_count != PyTuple_Size(to->names)) {
-        /* TODO: This should be rejected! */
-        return NPY_UNSAFE_CASTING;
+        return -1;
     }
+
+    NPY_CASTING casting = NPY_NO_CASTING;
+    *view_offset = 0;  /* if there are no fields, a view is OK. */
     for (Py_ssize_t i = 0; i < field_count; i++) {
+        npy_intp field_view_off = NPY_MIN_INTP;
         PyObject *from_key = PyTuple_GET_ITEM(from->names, i);
         PyObject *from_tup = PyDict_GetItemWithError(from->fields, from_key);
         if (from_tup == NULL) {
             return give_bad_field_error(from_key);
         }
-        PyArray_Descr *from_base = (PyArray_Descr*)PyTuple_GET_ITEM(from_tup, 0);
+        PyArray_Descr *from_base = (PyArray_Descr *) PyTuple_GET_ITEM(from_tup, 0);
 
-        /*
-         * TODO: This should use to_key (order), compare gh-15509 by
-         *       by Allan Haldane.  And raise an error on failure.
-         *       (Fixing that may also requires fixing/changing promotion.)
-         */
-        PyObject *to_tup = PyDict_GetItem(to->fields, from_key);
+        /* Check whether the field names match */
+        PyObject *to_key = PyTuple_GET_ITEM(to->names, i);
+        PyObject *to_tup = PyDict_GetItem(to->fields, to_key);
         if (to_tup == NULL) {
-            return NPY_UNSAFE_CASTING;
+            return give_bad_field_error(from_key);
+        }
+        PyArray_Descr *to_base = (PyArray_Descr *) PyTuple_GET_ITEM(to_tup, 0);
+
+        int cmp = PyUnicode_Compare(from_key, to_key);
+        if (error_converting(cmp)) {
+            return -1;
+        }
+        if (cmp != 0) {
+            /* Field name mismatch, consider this at most SAFE. */
+            casting = PyArray_MinCastSafety(casting, NPY_SAFE_CASTING);
         }
-        PyArray_Descr *to_base = (PyArray_Descr*)PyTuple_GET_ITEM(to_tup, 0);
 
-        NPY_CASTING field_casting = PyArray_GetCastSafety(from_base, to_base, NULL);
+        /* Also check the title (denote mismatch as SAFE only) */
+        PyObject *from_title = from_key;
+        PyObject *to_title = to_key;
+        if (PyTuple_GET_SIZE(from_tup) > 2) {
+            from_title = PyTuple_GET_ITEM(from_tup, 2);
+        }
+        if (PyTuple_GET_SIZE(to_tup) > 2) {
+            to_title = PyTuple_GET_ITEM(to_tup, 2);
+        }
+        cmp = PyObject_RichCompareBool(from_title, to_title, Py_EQ);
+        if (error_converting(cmp)) {
+            return -1;
+        }
+        if (!cmp) {
+            casting = PyArray_MinCastSafety(casting, NPY_SAFE_CASTING);
+        }
+
+        NPY_CASTING field_casting = PyArray_GetCastInfo(
+                from_base, to_base, NULL, &field_view_off);
         if (field_casting < 0) {
             return -1;
         }
         casting = PyArray_MinCastSafety(casting, field_casting);
-    }
-    if (!(casting & _NPY_CAST_IS_VIEW)) {
-        assert((casting & ~_NPY_CAST_IS_VIEW) != NPY_NO_CASTING);
-        return casting;
-    }
 
-    /*
-     * If the itemsize (includes padding at the end), fields, or names
-     * do not match, this cannot be a view and also not a "no" cast
-     * (identical dtypes).
-     * It may be possible that this can be relaxed in some cases.
-     */
-    if (from->elsize != to->elsize) {
+        /* Adjust the "view offset" by the field offsets: */
+        if (field_view_off != NPY_MIN_INTP) {
+            npy_intp to_off = PyLong_AsSsize_t(PyTuple_GET_ITEM(to_tup, 1));
+            if (error_converting(to_off)) {
+                return -1;
+            }
+            npy_intp from_off = PyLong_AsSsize_t(PyTuple_GET_ITEM(from_tup, 1));
+            if (error_converting(from_off)) {
+                return -1;
+            }
+            field_view_off = field_view_off - to_off + from_off;
+        }
+
         /*
-         * The itemsize may mismatch even if all fields and formats match
-         * (due to additional padding).
+         * If there is one field, use its field offset.  After that propagate
+         * the view offset if they match and set to "invalid" if not.
          */
-        return PyArray_MinCastSafety(casting, NPY_EQUIV_CASTING);
+        if (i == 0) {
+            *view_offset = field_view_off;
+        }
+        else if (*view_offset != field_view_off) {
+            *view_offset = NPY_MIN_INTP;
+        }
     }
 
-    int cmp = PyObject_RichCompareBool(from->fields, to->fields, Py_EQ);
-    if (cmp != 1) {
-        if (cmp == -1) {
-            PyErr_Clear();
-        }
-        return PyArray_MinCastSafety(casting, NPY_EQUIV_CASTING);
+    if (*view_offset != 0 || from->elsize != to->elsize) {
+        /* Can never be considered "no" casting. */
+        casting = PyArray_MinCastSafety(casting, NPY_EQUIV_CASTING);
     }
-    cmp = PyObject_RichCompareBool(from->names, to->names, Py_EQ);
-    if (cmp != 1) {
-        if (cmp == -1) {
-            PyErr_Clear();
-        }
-        return PyArray_MinCastSafety(casting, NPY_EQUIV_CASTING);
+
+    /* The new dtype may have access outside the old one due to padding: */
+    if (*view_offset < 0) {
+        /* negative offsets would give indirect access before original dtype */
+        *view_offset = NPY_MIN_INTP;
     }
+    if (from->elsize < to->elsize + *view_offset) {
+        /* new dtype has indirect access outside of the original dtype */
+        *view_offset = NPY_MIN_INTP;
+    }
+
     return casting;
 }
 
@@ -3277,38 +3542,45 @@ void_to_void_resolve_descriptors(
         PyArrayMethodObject *self,
         PyArray_DTypeMeta *dtypes[2],
         PyArray_Descr *given_descrs[2],
-        PyArray_Descr *loop_descrs[2])
+        PyArray_Descr *loop_descrs[2],
+        npy_intp *view_offset)
 {
     NPY_CASTING casting;
 
     if (given_descrs[1] == NULL) {
         /* This is weird, since it doesn't return the original descr, but... */
-        return cast_to_void_dtype_class(given_descrs, loop_descrs);
+        return cast_to_void_dtype_class(given_descrs, loop_descrs, view_offset);
     }
 
     if (given_descrs[0]->names != NULL && given_descrs[1]->names != NULL) {
         /* From structured to structured, need to check fields */
-        casting = can_cast_fields_safety(given_descrs[0], given_descrs[1]);
+        casting = can_cast_fields_safety(
+                given_descrs[0], given_descrs[1], view_offset);
+        if (casting < 0) {
+            return -1;
+        }
     }
     else if (given_descrs[0]->names != NULL) {
         return structured_to_nonstructured_resolve_descriptors(
-                self, dtypes, given_descrs, loop_descrs);
+                self, dtypes, given_descrs, loop_descrs, view_offset);
     }
     else if (given_descrs[1]->names != NULL) {
         return nonstructured_to_structured_resolve_descriptors(
-                self, dtypes, given_descrs, loop_descrs);
+                self, dtypes, given_descrs, loop_descrs, view_offset);
     }
     else if (given_descrs[0]->subarray == NULL &&
                 given_descrs[1]->subarray == NULL) {
         /* Both are plain void dtypes */
         if (given_descrs[0]->elsize == given_descrs[1]->elsize) {
-            casting = NPY_NO_CASTING | _NPY_CAST_IS_VIEW;
+            casting = NPY_NO_CASTING;
+            *view_offset = 0;
         }
         else if (given_descrs[0]->elsize < given_descrs[1]->elsize) {
             casting = NPY_SAFE_CASTING;
         }
         else {
             casting = NPY_SAME_KIND_CASTING;
+            *view_offset = 0;
         }
     }
     else {
@@ -3322,20 +3594,51 @@ void_to_void_resolve_descriptors(
 
         /* If the shapes do not match, this is at most an unsafe cast */
         casting = NPY_UNSAFE_CASTING;
+        /*
+         * We can use a view in two cases:
+         * 1. The shapes and elsizes matches, so any view offset applies to
+         *    each element of the subarray identically.
+         *    (in practice this probably implies the `view_offset` will be 0)
+         * 2. There is exactly one element and the subarray has no effect
+         *    (can be tested by checking if the itemsizes of the base matches)
+         */
+        npy_bool subarray_layout_supports_view = NPY_FALSE;
         if (from_sub && to_sub) {
             int res = PyObject_RichCompareBool(from_sub->shape, to_sub->shape, Py_EQ);
             if (res < 0) {
                 return -1;
             }
             else if (res) {
-                /* Both are subarrays and the shape matches */
-                casting = NPY_NO_CASTING | _NPY_CAST_IS_VIEW;
+                /* Both are subarrays and the shape matches, could be no cast */
+                casting = NPY_NO_CASTING;
+                /* May be a view if there is one element or elsizes match */
+                if (from_sub->base->elsize == to_sub->base->elsize
+                        || given_descrs[0]->elsize == from_sub->base->elsize) {
+                    subarray_layout_supports_view = NPY_TRUE;
+                }
+            }
+        }
+        else if (from_sub) {
+            /* May use a view if "from" has only a single element: */
+            if (given_descrs[0]->elsize == from_sub->base->elsize) {
+                subarray_layout_supports_view = NPY_TRUE;
+            }
+        }
+        else {
+            /* May use a view if "from" has only a single element: */
+            if (given_descrs[1]->elsize == to_sub->base->elsize) {
+                subarray_layout_supports_view = NPY_TRUE;
             }
         }
 
         PyArray_Descr *from_base = (from_sub == NULL) ? given_descrs[0] : from_sub->base;
         PyArray_Descr *to_base = (to_sub == NULL) ? given_descrs[1] : to_sub->base;
-        NPY_CASTING field_casting = PyArray_GetCastSafety(from_base, to_base, NULL);
+        /* An offset for  */
+        NPY_CASTING field_casting = PyArray_GetCastInfo(
+                from_base, to_base, NULL, view_offset);
+        if (!subarray_layout_supports_view) {
+            *view_offset = NPY_MIN_INTP;
+        }
         if (field_casting < 0) {
             return -1;
         }
@@ -3356,34 +3659,30 @@ NPY_NO_EXPORT int
 void_to_void_get_loop(
         PyArrayMethod_Context *context,
         int aligned, int move_references,
-        npy_intp *strides,
+        const npy_intp *strides,
         PyArrayMethod_StridedLoop **out_loop,
         NpyAuxData **out_transferdata,
         NPY_ARRAYMETHOD_FLAGS *flags)
 {
     if (context->descriptors[0]->names != NULL ||
             context->descriptors[1]->names != NULL) {
-        int needs_api = 0;
         if (get_fields_transfer_function(
                 aligned, strides[0], strides[1],
                 context->descriptors[0], context->descriptors[1],
                 move_references, out_loop, out_transferdata,
-                &needs_api) == NPY_FAIL) {
+                flags) == NPY_FAIL) {
             return -1;
         }
-        *flags = needs_api ? NPY_METH_REQUIRES_PYAPI : 0;
     }
     else if (context->descriptors[0]->subarray != NULL ||
              context->descriptors[1]->subarray != NULL) {
-        int needs_api = 0;
         if (get_subarray_transfer_function(
                 aligned, strides[0], strides[1],
                 context->descriptors[0], context->descriptors[1],
                 move_references, out_loop, out_transferdata,
-                &needs_api) == NPY_FAIL) {
+                flags) == NPY_FAIL) {
             return -1;
         }
-        *flags = needs_api ? NPY_METH_REQUIRES_PYAPI : 0;
     }
     else {
         /*
@@ -3396,7 +3695,7 @@ void_to_void_get_loop(
                 out_loop, out_transferdata) == NPY_FAIL) {
             return -1;
         }
-        *flags = 0;
+        *flags = PyArrayMethod_MINIMAL_FLAGS;
     }
     return 0;
 }
@@ -3418,9 +3717,9 @@ PyArray_InitializeVoidToVoidCast(void)
             {0, NULL}};
     PyArrayMethod_Spec spec = {
             .name = "void_to_void_cast",
-            .casting = -1,  /* may not cast at all */
             .nin = 1,
             .nout = 1,
+            .casting = -1,  /* may not cast at all */
             .flags = NPY_METH_REQUIRES_PYAPI | NPY_METH_SUPPORTS_UNALIGNED,
             .dtypes = dtypes,
             .slots = slots,
@@ -3443,7 +3742,8 @@ object_to_any_resolve_descriptors(
         PyArrayMethodObject *NPY_UNUSED(self),
         PyArray_DTypeMeta *dtypes[2],
         PyArray_Descr *given_descrs[2],
-        PyArray_Descr *loop_descrs[2])
+        PyArray_Descr *loop_descrs[2],
+        npy_intp *NPY_UNUSED(view_offset))
 {
     if (given_descrs[1] == NULL) {
         /*
@@ -3507,13 +3807,14 @@ PyArray_GetObjectToGenericCastingImpl(void)
 
 
 
-/* Any object object is simple (could even use the default) */
+/* Any object is simple (could even use the default) */
 static NPY_CASTING
 any_to_object_resolve_descriptors(
         PyArrayMethodObject *NPY_UNUSED(self),
         PyArray_DTypeMeta *dtypes[2],
         PyArray_Descr *given_descrs[2],
-        PyArray_Descr *loop_descrs[2])
+        PyArray_Descr *loop_descrs[2],
+        npy_intp *NPY_UNUSED(view_offset))
 {
     if (given_descrs[1] == NULL) {
         loop_descrs[1] = NPY_DT_CALL_default_descr(dtypes[1]);
@@ -3570,7 +3871,7 @@ static int
 object_to_object_get_loop(
         PyArrayMethod_Context *NPY_UNUSED(context),
         int NPY_UNUSED(aligned), int move_references,
-        npy_intp *NPY_UNUSED(strides),
+        const npy_intp *NPY_UNUSED(strides),
         PyArrayMethod_StridedLoop **out_loop,
         NpyAuxData **out_transferdata,
         NPY_ARRAYMETHOD_FLAGS *flags)
@@ -3591,10 +3892,6 @@ object_to_object_get_loop(
 static int
 PyArray_InitializeObjectToObjectCast(void)
 {
-    /*
-     * The object dtype does not support byte order changes, so its cast
-     * is always a direct view.
-     */
     PyArray_DTypeMeta *Object = PyArray_DTypeFromTypeNum(NPY_OBJECT);
     PyArray_DTypeMeta *dtypes[2] = {Object, Object};
     PyType_Slot slots[] = {
@@ -3602,9 +3899,9 @@ PyArray_InitializeObjectToObjectCast(void)
             {0, NULL}};
     PyArrayMethod_Spec spec = {
             .name = "object_to_object_cast",
-            .casting = NPY_NO_CASTING | _NPY_CAST_IS_VIEW,
             .nin = 1,
             .nout = 1,
+            .casting = NPY_NO_CASTING,
             .flags = NPY_METH_REQUIRES_PYAPI | NPY_METH_SUPPORTS_UNALIGNED,
             .dtypes = dtypes,
             .slots = slots,
diff --git a/numpy/core/src/multiarray/convert_datatype.h b/numpy/core/src/multiarray/convert_datatype.h
index 5e0682f2267d..b6bc7d8a74b2 100644
--- a/numpy/core/src/multiarray/convert_datatype.h
+++ b/numpy/core/src/multiarray/convert_datatype.h
@@ -3,8 +3,27 @@
 
 #include "array_method.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 extern NPY_NO_EXPORT npy_intp REQUIRED_STR_LEN[];
 
+#define NPY_USE_LEGACY_PROMOTION 0
+#define NPY_USE_WEAK_PROMOTION 1
+#define NPY_USE_WEAK_PROMOTION_AND_WARN 2
+extern NPY_NO_EXPORT int npy_promotion_state;
+extern NPY_NO_EXPORT PyObject *NO_NEP50_WARNING_CTX;
+
+NPY_NO_EXPORT int
+npy_give_promotion_warnings(void);
+
+NPY_NO_EXPORT PyObject *
+npy__get_promotion_state(PyObject *NPY_UNUSED(mod), PyObject *NPY_UNUSED(arg));
+
+NPY_NO_EXPORT PyObject *
+npy__set_promotion_state(PyObject *NPY_UNUSED(mod), PyObject *arg);
+
 NPY_NO_EXPORT PyObject *
 PyArray_GetCastingImpl(PyArray_DTypeMeta *from, PyArray_DTypeMeta *to);
 
@@ -20,8 +39,9 @@ PyArray_ObjectType(PyObject *op, int minimum_type);
 NPY_NO_EXPORT PyArrayObject **
 PyArray_ConvertToCommonType(PyObject *op, int *retn);
 
-NPY_NO_EXPORT PyArray_Descr *
-PyArray_LegacyResultType(
+NPY_NO_EXPORT int
+PyArray_CheckLegacyResultType(
+        PyArray_Descr **new_result,
         npy_intp narrs, PyArrayObject **arr,
         npy_intp ndtypes, PyArray_Descr **dtypes);
 
@@ -34,15 +54,19 @@ dtype_kind_to_ordering(char kind);
 /* Used by PyArray_CanCastArrayTo and in the legacy ufunc type resolution */
 NPY_NO_EXPORT npy_bool
 can_cast_scalar_to(PyArray_Descr *scal_type, char *scal_data,
-                    PyArray_Descr *to, NPY_CASTING casting);
+                   PyArray_Descr *to, NPY_CASTING casting);
 
-NPY_NO_EXPORT PyArray_Descr *
-ensure_dtype_nbo(PyArray_Descr *type);
+NPY_NO_EXPORT npy_bool
+can_cast_pyscalar_scalar_to(
+        int flags, PyArray_Descr *to, NPY_CASTING casting);
 
 NPY_NO_EXPORT int
 should_use_min_scalar(npy_intp narrs, PyArrayObject **arr,
                       npy_intp ndtypes, PyArray_Descr **dtypes);
 
+NPY_NO_EXPORT int
+should_use_min_scalar_weak_literals(int narrs, PyArrayObject **arr);
+
 NPY_NO_EXPORT const char *
 npy_casting_to_string(NPY_CASTING casting);
 
@@ -62,14 +86,15 @@ NPY_NO_EXPORT int
 PyArray_AddCastingImplementation(PyBoundArrayMethodObject *meth);
 
 NPY_NO_EXPORT int
-PyArray_AddCastingImplementation_FromSpec(PyArrayMethod_Spec *spec, int private);
+PyArray_AddCastingImplementation_FromSpec(PyArrayMethod_Spec *spec, int private_);
 
 NPY_NO_EXPORT NPY_CASTING
 PyArray_MinCastSafety(NPY_CASTING casting1, NPY_CASTING casting2);
 
 NPY_NO_EXPORT NPY_CASTING
-PyArray_GetCastSafety(
-        PyArray_Descr *from, PyArray_Descr *to, PyArray_DTypeMeta *to_dtype);
+PyArray_GetCastInfo(
+        PyArray_Descr *from, PyArray_Descr *to, PyArray_DTypeMeta *to_dtype,
+        npy_intp *view_offset);
 
 NPY_NO_EXPORT int
 PyArray_CheckCastSafety(NPY_CASTING casting,
@@ -80,7 +105,8 @@ legacy_same_dtype_resolve_descriptors(
         PyArrayMethodObject *self,
         PyArray_DTypeMeta *dtypes[2],
         PyArray_Descr *given_descrs[2],
-        PyArray_Descr *loop_descrs[2]);
+        PyArray_Descr *loop_descrs[2],
+        npy_intp *view_offset);
 
 NPY_NO_EXPORT int
 legacy_cast_get_strided_loop(
@@ -94,9 +120,14 @@ simple_cast_resolve_descriptors(
         PyArrayMethodObject *self,
         PyArray_DTypeMeta *dtypes[2],
         PyArray_Descr *input_descrs[2],
-        PyArray_Descr *loop_descrs[2]);
+        PyArray_Descr *loop_descrs[2],
+        npy_intp *view_offset);
 
 NPY_NO_EXPORT int
 PyArray_InitializeCasts(void);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif  /* NUMPY_CORE_SRC_MULTIARRAY_CONVERT_DATATYPE_H_ */
diff --git a/numpy/core/src/multiarray/ctors.c b/numpy/core/src/multiarray/ctors.c
index b6242685447b..43fff6786c6d 100644
--- a/numpy/core/src/multiarray/ctors.c
+++ b/numpy/core/src/multiarray/ctors.c
@@ -1,5 +1,6 @@
 #define NPY_NO_DEPRECATED_API NPY_API_VERSION
 #define _MULTIARRAYMODULE
+#define _UMATHMODULE
 
 #define PY_SSIZE_T_CLEAN
 #include 
@@ -26,13 +27,15 @@
 #include "datetime_strings.h"
 #include "array_assign.h"
 #include "mapping.h" /* for array_item_asarray */
-#include "templ_common.h" /* for npy_mul_with_overflow_intp */
+#include "templ_common.h" /* for npy_mul_sizes_with_overflow */
 #include "alloc.h"
 #include 
 
 #include "get_attr_string.h"
 #include "array_coercion.h"
 
+#include "umathmodule.h"
+
 /*
  * Reading from a file or a string.
  *
@@ -465,55 +468,12 @@ PyArray_AssignFromCache_Recursive(
         PyArrayObject *self, const int ndim, coercion_cache_obj **cache)
 {
     /* Consume first cache element by extracting information and freeing it */
-    PyObject *original_obj = (*cache)->converted_obj;
     PyObject *obj = (*cache)->arr_or_sequence;
     Py_INCREF(obj);
     npy_bool sequence = (*cache)->sequence;
     int depth = (*cache)->depth;
     *cache = npy_unlink_coercion_cache(*cache);
 
-    /*
-     * The maximum depth is special (specifically for objects), but usually
-     * unrolled in the sequence branch below.
-     */
-    if (NPY_UNLIKELY(depth == ndim)) {
-        /*
-         * We have reached the maximum depth. We should simply assign to the
-         * element in principle. There is one exception. If this is a 0-D
-         * array being stored into a 0-D array (but we do not reach here then).
-         */
-        if (PyArray_ISOBJECT(self)) {
-            assert(ndim != 0);  /* guaranteed by PyArray_AssignFromCache */
-            assert(PyArray_NDIM(self) == 0);
-            Py_DECREF(obj);
-            return PyArray_Pack(PyArray_DESCR(self), PyArray_BYTES(self),
-                                original_obj);
-        }
-        if (sequence) {
-            /*
-             * Sanity check which may be removed, the error is raised already
-             * in `PyArray_DiscoverDTypeAndShape`.
-             */
-            assert(0);
-            PyErr_SetString(PyExc_RuntimeError,
-                    "setting an array element with a sequence");
-            goto fail;
-        }
-        else if (original_obj != obj || !PyArray_CheckExact(obj)) {
-            /*
-             * If the leave node is an array-like, but not a numpy array,
-             * we pretend it is an arbitrary scalar.  This means that in
-             * most cases (where the dtype is int or float), we will end
-             * up using float(array-like), or int(array-like).  That does
-             * not support general casting, but helps Quantity and masked
-             * arrays, because it allows them to raise an error when
-             * `__float__()` or `__int__()` is called.
-             */
-            Py_DECREF(obj);
-            return PyArray_SETITEM(self, PyArray_BYTES(self), original_obj);
-        }
-    }
-
     /* The element is either a sequence, or an array */
     if (!sequence) {
         /* Straight forward array assignment */
@@ -535,20 +495,24 @@ PyArray_AssignFromCache_Recursive(
         for (npy_intp i = 0; i < length; i++) {
             PyObject *value = PySequence_Fast_GET_ITEM(obj, i);
 
-            if (*cache == NULL || (*cache)->converted_obj != value ||
-                        (*cache)->depth != depth + 1) {
-                if (ndim != depth + 1) {
-                    PyErr_SetString(PyExc_RuntimeError,
-                            "Inconsistent object during array creation? "
-                            "Content of sequences changed (now too shallow).");
-                    goto fail;
-                }
-                /* Straight forward assignment of elements */
+            if (ndim == depth + 1) {
+                /*
+                 * Straight forward assignment of elements.  Note that it is
+                 * possible for such an element to be a 0-D array or array-like.
+                 * `PyArray_Pack` supports arrays as well as we want: We
+                 * support exact NumPy arrays, but at this point ignore others.
+                 * (Please see the `PyArray_Pack` function comment if this
+                 * rightly confuses you.)
+                 */
                 char *item;
                 item = (PyArray_BYTES(self) + i * PyArray_STRIDES(self)[0]);
                 if (PyArray_Pack(PyArray_DESCR(self), item, value) < 0) {
                     goto fail;
                 }
+                /* If this was an array(-like) we still need to unlike int: */
+                if (*cache != NULL && (*cache)->converted_obj == value) {
+                    *cache = npy_unlink_coercion_cache(*cache);
+                }
             }
             else {
                 PyArrayObject *view;
@@ -668,6 +632,9 @@ PyArray_NewFromDescr_int(
     PyArrayObject_fields *fa;
     npy_intp nbytes;
 
+    if (descr == NULL) {
+        return NULL;
+    }
     if (nd > NPY_MAXDIMS || nd < 0) {
         PyErr_Format(PyExc_ValueError,
                 "number of dimensions must be within [0, %d]", NPY_MAXDIMS);
@@ -740,7 +707,6 @@ PyArray_NewFromDescr_int(
     }
     else {
         fa->flags = (flags & ~NPY_ARRAY_WRITEBACKIFCOPY);
-        fa->flags &= ~NPY_ARRAY_UPDATEIFCOPY;
     }
     fa->descr = descr;
     fa->base = (PyObject *)NULL;
@@ -754,15 +720,19 @@ PyArray_NewFromDescr_int(
         }
         fa->strides = fa->dimensions + nd;
 
-        /* Copy dimensions, check them, and find total array size `nbytes` */
+        /*
+         * Copy dimensions, check them, and find total array size `nbytes`
+         */
+        int is_zero = 0;
         for (int i = 0; i < nd; i++) {
             fa->dimensions[i] = dims[i];
 
             if (fa->dimensions[i] == 0) {
                 /*
-                 * Compare to PyArray_OverflowMultiplyList that
-                 * returns 0 in this case.
+                 * Continue calculating the max size "as if" this were 1
+                 * to get the proper overflow error
                  */
+                is_zero = 1;
                 continue;
             }
 
@@ -776,13 +746,16 @@ PyArray_NewFromDescr_int(
              * Care needs to be taken to avoid integer overflow when multiplying
              * the dimensions together to get the total size of the array.
              */
-            if (npy_mul_with_overflow_intp(&nbytes, nbytes, fa->dimensions[i])) {
+            if (npy_mul_sizes_with_overflow(&nbytes, nbytes, fa->dimensions[i])) {
                 PyErr_SetString(PyExc_ValueError,
                         "array is too big; `arr.size * arr.dtype.itemsize` "
                         "is larger than the maximum possible size.");
                 goto fail;
             }
         }
+        if (is_zero) {
+            nbytes = 0;
+        }
 
         /* Fill the strides (or copy them if they were passed in) */
         if (strides == NULL) {
@@ -817,11 +790,13 @@ PyArray_NewFromDescr_int(
          * Allocate something even for zero-space arrays
          * e.g. shape=(0,) -- otherwise buffer exposure
          * (a.data) doesn't work as it should.
-         * Could probably just allocate a few bytes here. -- Chuck
-         * Note: always sync this with calls to PyDataMem_UserFREE
          */
         if (nbytes == 0) {
-            nbytes = descr->elsize ? descr->elsize : 1;
+            nbytes = 1;
+            /* Make sure all the strides are 0 */
+            for (int i = 0; i < nd; i++) {
+                fa->strides[i] = 0;
+            }
         }
         /*
          * It is bad to have uninitialized OBJECT pointers
@@ -870,16 +845,39 @@ PyArray_NewFromDescr_int(
     /*
      * call the __array_finalize__ method if a subtype was requested.
      * If obj is NULL use Py_None for the Python callback.
+     * For speed, we skip if __array_finalize__ is inherited from ndarray
+     * (since that function does nothing), or, for backward compatibility,
+     * if it is None.
      */
     if (subtype != &PyArray_Type) {
         PyObject *res, *func;
-
-        func = PyObject_GetAttr((PyObject *)fa, npy_ma_str_array_finalize);
+        static PyObject *ndarray_array_finalize = NULL;
+        /* First time, cache ndarray's __array_finalize__ */
+        if (ndarray_array_finalize == NULL) {
+            ndarray_array_finalize = PyObject_GetAttr(
+                (PyObject *)&PyArray_Type, npy_ma_str_array_finalize);
+        }
+        func = PyObject_GetAttr((PyObject *)subtype, npy_ma_str_array_finalize);
         if (func == NULL) {
             goto fail;
         }
+        else if (func == ndarray_array_finalize) {
+            Py_DECREF(func);
+        }
         else if (func == Py_None) {
             Py_DECREF(func);
+            /*
+             * 2022-01-08, NumPy 1.23; when deprecation period is over, remove this
+             * whole stanza so one gets a "NoneType object is not callable" TypeError.
+             */
+            if (DEPRECATE(
+                    "Setting __array_finalize__ = None to indicate no finalization"
+                    "should be done is deprecated.  Instead, just inherit from "
+                    "ndarray or, if that is not possible, explicitly set to "
+                    "ndarray.__array_function__; this will raise a TypeError "
+                    "in the future. (Deprecated since NumPy 1.23)") < 0) {
+                goto fail;
+            }
         }
         else {
             if (PyCapsule_CheckExact(func)) {
@@ -898,7 +896,7 @@ PyArray_NewFromDescr_int(
                 if (obj == NULL) {
                     obj = Py_None;
                 }
-                res = PyObject_CallFunctionObjArgs(func, obj, NULL);
+                res = PyObject_CallFunctionObjArgs(func, (PyObject *)fa, obj, NULL);
                 Py_DECREF(func);
                 if (res == NULL) {
                     goto fail;
@@ -930,6 +928,18 @@ PyArray_NewFromDescr(
         int nd, npy_intp const *dims, npy_intp const *strides, void *data,
         int flags, PyObject *obj)
 {
+    if (subtype == NULL) {
+        PyErr_SetString(PyExc_ValueError,
+            "subtype is NULL in PyArray_NewFromDescr");
+        return NULL;
+    }
+
+    if (descr == NULL) {
+        PyErr_SetString(PyExc_ValueError,
+            "descr is NULL in PyArray_NewFromDescr");
+        return NULL;
+    }
+
     return PyArray_NewFromDescrAndBase(
             subtype, descr,
             nd, dims, strides, data,
@@ -1058,6 +1068,18 @@ PyArray_NewLikeArrayWithShape(PyArrayObject *prototype, NPY_ORDER order,
                                         0,
                                         subok ? (PyObject *)prototype : NULL);
     }
+    if (ret == NULL) {
+        return NULL;
+    }
+
+    /* Logic shared by `empty`, `empty_like`, and `ndarray.__new__` */
+    if (PyDataType_REFCHK(PyArray_DESCR((PyArrayObject *)ret))) {
+        PyArray_FillObjectArray((PyArrayObject *)ret, Py_None);
+        if (PyErr_Occurred()) {
+            Py_DECREF(ret);
+            return NULL;
+        }
+    }
 
     return ret;
 }
@@ -1082,6 +1104,11 @@ NPY_NO_EXPORT PyObject *
 PyArray_NewLikeArray(PyArrayObject *prototype, NPY_ORDER order,
                      PyArray_Descr *dtype, int subok)
 {
+    if (prototype == NULL) {
+        PyErr_SetString(PyExc_ValueError,
+            "prototype is NULL in PyArray_NewLikeArray");
+        return NULL;
+    }
     return PyArray_NewLikeArrayWithShape(prototype, order, dtype, -1, NULL, subok);
 }
 
@@ -1097,6 +1124,12 @@ PyArray_New(
     PyArray_Descr *descr;
     PyObject *new;
 
+    if (subtype == NULL) {
+        PyErr_SetString(PyExc_ValueError,
+            "subtype is NULL in PyArray_New");
+        return NULL;
+    }
+
     descr = PyArray_DescrFromType(type_num);
     if (descr == NULL) {
         return NULL;
@@ -1109,6 +1142,9 @@ PyArray_New(
             return NULL;
         }
         PyArray_DESCR_REPLACE(descr);
+        if (descr == NULL) {
+            return NULL;
+        }
         descr->elsize = itemsize;
     }
     new = PyArray_NewFromDescr(subtype, descr, nd, dims, strides,
@@ -1134,6 +1170,9 @@ _dtype_from_buffer_3118(PyObject *memoryview)
          *       terminate.
          */
         descr = PyArray_DescrNewFromType(NPY_STRING);
+        if (descr == NULL) {
+            return NULL;
+        }
         descr->elsize = view->itemsize;
     }
     return descr;
@@ -1152,6 +1191,16 @@ _array_from_buffer_3118(PyObject *memoryview)
     npy_intp shape[NPY_MAXDIMS], strides[NPY_MAXDIMS];
 
     view = PyMemoryView_GET_BUFFER(memoryview);
+
+    if (view->suboffsets != NULL) {
+        PyErr_SetString(PyExc_BufferError,
+                "NumPy currently does not support importing buffers which "
+                "include suboffsets as they are not compatible with the NumPy"
+                "memory layout without a copy.  Consider copying the original "
+                "before trying to convert it to a NumPy array.");
+        return NULL;
+    }
+
     nd = view->ndim;
     descr = _dtype_from_buffer_3118(memoryview);
 
@@ -1301,9 +1350,10 @@ _array_from_array_like(PyObject *op,
      * We skip bytes and unicode since they are considered scalars. Unicode
      * would fail but bytes would be incorrectly converted to a uint8 array.
      */
-    if (!PyBytes_Check(op) && !PyUnicode_Check(op)) {
+    if (PyObject_CheckBuffer(op) && !PyBytes_Check(op) && !PyUnicode_Check(op)) {
         PyObject *memoryview = PyMemoryView_FromObject(op);
         if (memoryview == NULL) {
+            /* TODO: Should probably not blanket ignore errors. */
             PyErr_Clear();
         }
         else {
@@ -1598,8 +1648,8 @@ PyArray_FromAny(PyObject *op, PyArray_Descr *newtype, int min_depth,
          * Thus, we check if there is an array included, in that case we
          * give a FutureWarning.
          * When the warning is removed, PyArray_Pack will have to ensure
-         * that that it does not append the dimensions when creating the
-         * subarrays to assign `arr[0] = obj[0]`.
+         * that it does not append the dimensions when creating the subarrays
+         * to assign `arr[0] = obj[0]`.
          */
         int includes_array = 0;
         if (cache != NULL) {
@@ -1710,11 +1760,14 @@ PyArray_FromAny(PyObject *op, PyArray_Descr *newtype, int min_depth,
     if (flags & NPY_ARRAY_ENSURENOCOPY ) {
         PyErr_SetString(PyExc_ValueError,
                 "Unable to avoid copy while creating an array.");
+        Py_DECREF(dtype);
+        npy_free_coercion_cache(cache);
         return NULL;
     }
 
-    if (cache == 0 && newtype != NULL &&
-            PyDataType_ISSIGNED(newtype) && PyArray_IsScalar(op, Generic)) {
+    if (cache == NULL && newtype != NULL &&
+            PyDataType_ISSIGNED(dtype) &&
+            PyArray_IsScalar(op, Generic)) {
         assert(ndim == 0);
         /*
          * This is an (possible) inconsistency where:
@@ -1740,8 +1793,7 @@ PyArray_FromAny(PyObject *op, PyArray_Descr *newtype, int min_depth,
     }
 
     /* There was no array (or array-like) passed in directly. */
-    if ((flags & NPY_ARRAY_WRITEBACKIFCOPY) ||
-            (flags & NPY_ARRAY_UPDATEIFCOPY)) {
+    if (flags & NPY_ARRAY_WRITEBACKIFCOPY) {
         PyErr_SetString(PyExc_TypeError,
                         "WRITEBACKIFCOPY used for non-array input.");
         Py_DECREF(dtype);
@@ -1810,7 +1862,6 @@ PyArray_FromAny(PyObject *op, PyArray_Descr *newtype, int min_depth,
  * NPY_ARRAY_WRITEABLE,
  * NPY_ARRAY_NOTSWAPPED,
  * NPY_ARRAY_ENSURECOPY,
- * NPY_ARRAY_UPDATEIFCOPY,
  * NPY_ARRAY_WRITEBACKIFCOPY,
  * NPY_ARRAY_FORCECAST,
  * NPY_ARRAY_ENSUREARRAY,
@@ -1837,9 +1888,6 @@ PyArray_FromAny(PyObject *op, PyArray_Descr *newtype, int min_depth,
  * Fortran arrays are always behaved (aligned,
  * notswapped, and writeable) and not (C) CONTIGUOUS (if > 1d).
  *
- * NPY_ARRAY_UPDATEIFCOPY is deprecated in favor of
- * NPY_ARRAY_WRITEBACKIFCOPY in 1.14
-
  * NPY_ARRAY_WRITEBACKIFCOPY flag sets this flag in the returned
  * array if a copy is made and the base argument points to the (possibly)
  * misbehaved array. Before returning to python, PyArray_ResolveWritebackIfCopy
@@ -1863,6 +1911,9 @@ PyArray_CheckFromAny(PyObject *op, PyArray_Descr *descr, int min_depth,
         if (!descr && PyArray_Check(op) &&
                 PyArray_ISBYTESWAPPED((PyArrayObject* )op)) {
             descr = PyArray_DescrNew(PyArray_DESCR((PyArrayObject *)op));
+            if (descr == NULL) {
+                return NULL;
+            }
         }
         else if (descr && !PyArray_ISNBO(descr->byteorder)) {
             PyArray_DESCR_REPLACE(descr);
@@ -1962,6 +2013,7 @@ PyArray_FromArray(PyArrayObject *arr, PyArray_Descr *newtype, int flags)
         if (flags & NPY_ARRAY_ENSURENOCOPY ) {
             PyErr_SetString(PyExc_ValueError,
                     "Unable to avoid copy while creating an array from given array.");
+            Py_DECREF(newtype);
             return NULL;
         }
 
@@ -1990,31 +2042,8 @@ PyArray_FromArray(PyArrayObject *arr, PyArray_Descr *newtype, int flags)
             return NULL;
         }
 
-        if (flags & NPY_ARRAY_UPDATEIFCOPY) {
-            /* This is the ONLY place the NPY_ARRAY_UPDATEIFCOPY flag
-             * is still used.
-             * Can be deleted once the flag itself is removed
-             */
 
-            /* 2017-Nov-10 1.14 */
-            if (DEPRECATE(
-                    "NPY_ARRAY_UPDATEIFCOPY, NPY_ARRAY_INOUT_ARRAY, and "
-                    "NPY_ARRAY_INOUT_FARRAY are deprecated, use NPY_WRITEBACKIFCOPY, "
-                    "NPY_ARRAY_INOUT_ARRAY2, or NPY_ARRAY_INOUT_FARRAY2 respectively "
-                    "instead, and call PyArray_ResolveWritebackIfCopy before the "
-                    "array is deallocated, i.e. before the last call to Py_DECREF.") < 0) {
-                Py_DECREF(ret);
-                return NULL;
-            }
-            Py_INCREF(arr);
-            if (PyArray_SetWritebackIfCopyBase(ret, arr) < 0) {
-                Py_DECREF(ret);
-                return NULL;
-            }
-            PyArray_ENABLEFLAGS(ret, NPY_ARRAY_UPDATEIFCOPY);
-            PyArray_CLEARFLAGS(ret, NPY_ARRAY_WRITEBACKIFCOPY);
-        }
-        else if (flags & NPY_ARRAY_WRITEBACKIFCOPY) {
+        if (flags & NPY_ARRAY_WRITEBACKIFCOPY) {
             Py_INCREF(arr);
             if (PyArray_SetWritebackIfCopyBase(ret, arr) < 0) {
                 Py_DECREF(ret);
@@ -2060,7 +2089,7 @@ PyArray_FromStructInterface(PyObject *input)
     PyObject *attr;
     char endian = NPY_NATBYTE;
 
-    attr = PyArray_LookupSpecial_OnInstance(input, "__array_struct__");
+    attr = PyArray_LookupSpecial_OnInstance(input, npy_ma_str_array_struct);
     if (attr == NULL) {
         if (PyErr_Occurred()) {
             return NULL;
@@ -2114,11 +2143,31 @@ PyArray_FromStructInterface(PyObject *input)
         }
     }
 
+    /* a tuple to hold references */
+    PyObject *refs = PyTuple_New(2);
+    if (!refs) {
+        Py_DECREF(attr);
+        return NULL;
+    }
+
+    /* add a reference to the object sharing the data */
+    Py_INCREF(input);
+    PyTuple_SET_ITEM(refs, 0, input);
+
+    /* take a reference to the PyCapsule containing the PyArrayInterface
+     * structure. When the PyCapsule reference is released the PyCapsule
+     * destructor will free any resources that need to persist while numpy has
+     * access to the data. */
+    PyTuple_SET_ITEM(refs, 1,  attr);
+
+    /* create the numpy array, this call adds a reference to refs */
     PyObject *ret = PyArray_NewFromDescrAndBase(
             &PyArray_Type, thetype,
             inter->nd, inter->shape, inter->strides, inter->data,
-            inter->flags, NULL, input);
-    Py_DECREF(attr);
+            inter->flags, NULL, refs);
+
+    Py_DECREF(refs);
+
     return ret;
 
  fail:
@@ -2149,38 +2198,6 @@ _is_default_descr(PyObject *descr, PyObject *typestr) {
 }
 
 
-/*
- * A helper function to transition away from ignoring errors during
- * special attribute lookups during array coercion.
- */
-static NPY_INLINE int
-deprecated_lookup_error_clearing(PyTypeObject *type, char *attribute)
-{
-    PyObject *exc_type, *exc_value, *traceback;
-    PyErr_Fetch(&exc_type, &exc_value, &traceback);
-
-    /* DEPRECATED 2021-05-12, NumPy 1.21. */
-    int res = PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
-            "An exception was ignored while fetching the attribute `%s` from "
-            "an object of type '%s'.  With the exception of `AttributeError` "
-            "NumPy will always raise this exception in the future.  Raise this "
-            "deprecation warning to see the original exception. "
-            "(Warning added NumPy 1.21)", attribute, type->tp_name);
-
-    if (res < 0) {
-        npy_PyErr_ChainExceptionsCause(exc_type, exc_value, traceback);
-        return -1;
-    }
-    else {
-        /* `PyErr_Fetch` cleared the original error, delete the references */
-        Py_DECREF(exc_type);
-        Py_XDECREF(exc_value);
-        Py_XDECREF(traceback);
-        return 0;
-    }
-}
-
-
 /*NUMPY_API*/
 NPY_NO_EXPORT PyObject *
 PyArray_FromInterface(PyObject *origin)
@@ -2196,19 +2213,11 @@ PyArray_FromInterface(PyObject *origin)
     npy_intp dims[NPY_MAXDIMS], strides[NPY_MAXDIMS];
     int dataflags = NPY_ARRAY_BEHAVED;
 
-    iface = PyArray_LookupSpecial_OnInstance(origin, "__array_interface__");
+    iface = PyArray_LookupSpecial_OnInstance(origin, npy_ma_str_array_interface);
 
     if (iface == NULL) {
         if (PyErr_Occurred()) {
-            if (PyErr_ExceptionMatches(PyExc_RecursionError) ||
-                    PyErr_ExceptionMatches(PyExc_MemoryError)) {
-                /* RecursionError and MemoryError are considered fatal */
-                return NULL;
-            }
-            if (deprecated_lookup_error_clearing(
-                    Py_TYPE(origin), "__array_interface__") < 0) {
-                return NULL;
-            }
+            return NULL;
         }
         return Py_NotImplemented;
     }
@@ -2485,18 +2494,10 @@ PyArray_FromArrayAttr_int(
     PyObject *new;
     PyObject *array_meth;
 
-    array_meth = PyArray_LookupSpecial_OnInstance(op, "__array__");
+    array_meth = PyArray_LookupSpecial_OnInstance(op, npy_ma_str_array);
     if (array_meth == NULL) {
         if (PyErr_Occurred()) {
-            if (PyErr_ExceptionMatches(PyExc_RecursionError) ||
-                PyErr_ExceptionMatches(PyExc_MemoryError)) {
-                /* RecursionError and MemoryError are considered fatal */
-                return NULL;
-            }
-            if (deprecated_lookup_error_clearing(
-                    Py_TYPE(op), "__array__") < 0) {
-                return NULL;
-            }
+            return NULL;
         }
         return Py_NotImplemented;
     }
@@ -2756,18 +2757,22 @@ PyArray_CopyAsFlat(PyArrayObject *dst, PyArrayObject *src, NPY_ORDER order)
      * contiguous strides, etc.
      */
     NPY_cast_info cast_info;
+    NPY_ARRAYMETHOD_FLAGS flags;
     if (PyArray_GetDTypeTransferFunction(
                     IsUintAligned(src) && IsAligned(src) &&
                     IsUintAligned(dst) && IsAligned(dst),
                     src_stride, dst_stride,
                     PyArray_DESCR(src), PyArray_DESCR(dst),
                     0,
-                    &cast_info, &needs_api) != NPY_SUCCEED) {
+                    &cast_info, &flags) != NPY_SUCCEED) {
         NpyIter_Deallocate(dst_iter);
         NpyIter_Deallocate(src_iter);
         return -1;
     }
-
+    needs_api |= (flags & NPY_METH_REQUIRES_PYAPI) != 0;
+    if (!(flags & NPY_METH_NO_FLOATINGPOINT_ERRORS)) {
+        npy_clear_floatstatus_barrier((char *)src_iter);
+    }
     if (!needs_api) {
         NPY_BEGIN_THREADS;
     }
@@ -2819,8 +2824,20 @@ PyArray_CopyAsFlat(PyArrayObject *dst, PyArrayObject *src, NPY_ORDER order)
     NPY_END_THREADS;
 
     NPY_cast_info_xfree(&cast_info);
-    NpyIter_Deallocate(dst_iter);
-    NpyIter_Deallocate(src_iter);
+    if (!NpyIter_Deallocate(dst_iter)) {
+        res = -1;
+    }
+    if (!NpyIter_Deallocate(src_iter)) {
+        res = -1;
+    }
+
+    if (res == 0 && !(flags & NPY_METH_NO_FLOATINGPOINT_ERRORS)) {
+        int fpes = npy_get_floatstatus_barrier((char *)&src_iter);
+        if (fpes && PyUFunc_GiveFloatingpointErrors("cast", fpes) < 0) {
+            return -1;
+        }
+    }
+
     return res;
 }
 
@@ -2975,22 +2992,23 @@ PyArray_Empty(int nd, npy_intp const *dims, PyArray_Descr *type, int is_f_order)
      * PyArray_NewFromDescr steals a ref,
      * but we need to look at type later.
      * */
-    Py_INCREF(type);
-
     ret = (PyArrayObject *)PyArray_NewFromDescr(&PyArray_Type,
                                                 type, nd, dims,
                                                 NULL, NULL,
                                                 is_f_order, NULL);
-    if (ret != NULL && PyDataType_REFCHK(type)) {
+    if (ret == NULL) {
+        return NULL;
+    }
+
+    /* Logic shared by `empty`, `empty_like`, and `ndarray.__new__` */
+    if (PyDataType_REFCHK(PyArray_DESCR(ret))) {
         PyArray_FillObjectArray(ret, Py_None);
         if (PyErr_Occurred()) {
             Py_DECREF(ret);
-            Py_DECREF(type);
             return NULL;
         }
     }
 
-    Py_DECREF(type);
     return (PyObject *)ret;
 }
 
@@ -3225,11 +3243,11 @@ _calc_length(PyObject *start, PyObject *stop, PyObject *step, PyObject **next, i
 NPY_NO_EXPORT PyObject *
 PyArray_ArangeObj(PyObject *start, PyObject *stop, PyObject *step, PyArray_Descr *dtype)
 {
-    PyArrayObject *range;
+    PyArrayObject *range = NULL;
     PyArray_ArrFuncs *funcs;
-    PyObject *next, *err;
-    npy_intp length;
+    PyObject *next = NULL;
     PyArray_Descr *native = NULL;
+    npy_intp length;
     int swap;
     NPY_BEGIN_THREADS_DEF;
 
@@ -3242,94 +3260,100 @@ PyArray_ArangeObj(PyObject *start, PyObject *stop, PyObject *step, PyArray_Descr
         return (PyObject *)datetime_arange(start, stop, step, dtype);
     }
 
-    if (!dtype) {
-        PyArray_Descr *deftype;
-        PyArray_Descr *newtype;
+    /* We need to replace many of these, so hold on for easier cleanup */
+    Py_XINCREF(start);
+    Py_XINCREF(stop);
+    Py_XINCREF(step);
+    Py_XINCREF(dtype);
 
+    if (!dtype) {
         /* intentionally made to be at least NPY_LONG */
-        deftype = PyArray_DescrFromType(NPY_LONG);
-        newtype = PyArray_DescrFromObject(start, deftype);
-        Py_DECREF(deftype);
-        if (newtype == NULL) {
-            return NULL;
+        dtype = PyArray_DescrFromType(NPY_LONG);
+        Py_SETREF(dtype, PyArray_DescrFromObject(start, dtype));
+        if (dtype == NULL) {
+            goto fail;
         }
-        deftype = newtype;
         if (stop && stop != Py_None) {
-            newtype = PyArray_DescrFromObject(stop, deftype);
-            Py_DECREF(deftype);
-            if (newtype == NULL) {
-                return NULL;
+            Py_SETREF(dtype, PyArray_DescrFromObject(stop, dtype));
+            if (dtype == NULL) {
+                goto fail;
             }
-            deftype = newtype;
         }
         if (step && step != Py_None) {
-            newtype = PyArray_DescrFromObject(step, deftype);
-            Py_DECREF(deftype);
-            if (newtype == NULL) {
-                return NULL;
+            Py_SETREF(dtype, PyArray_DescrFromObject(step, dtype));
+            if (dtype == NULL) {
+                goto fail;
             }
-            deftype = newtype;
         }
-        dtype = deftype;
+    }
+
+    /*
+     * If dtype is not in native byte-order then get native-byte
+     * order version.  And then swap on the way out.
+     */
+    if (!PyArray_ISNBO(dtype->byteorder)) {
+        native = PyArray_DescrNewByteorder(dtype, NPY_NATBYTE);
+        if (native == NULL) {
+            goto fail;
+        }
+        swap = 1;
     }
     else {
         Py_INCREF(dtype);
+        native = dtype;
+        swap = 0;
     }
-    if (!step || step == Py_None) {
-        step = PyLong_FromLong(1);
+
+    funcs = native->f;
+    if (!funcs->fill) {
+        /* This effectively forbids subarray types as well... */
+        PyErr_Format(PyExc_TypeError,
+                "arange() not supported for inputs with DType %S.",
+                Py_TYPE(dtype));
+        goto fail;
     }
-    else {
-        Py_XINCREF(step);
+
+    if (!step || step == Py_None) {
+        Py_XSETREF(step, PyLong_FromLong(1));
+        if (step == NULL) {
+            goto fail;
+        }
     }
     if (!stop || stop == Py_None) {
-        stop = start;
+        Py_XSETREF(stop, start);
         start = PyLong_FromLong(0);
+        if (start == NULL) {
+            goto fail;
+        }
     }
-    else {
-        Py_INCREF(start);
-    }
+
     /* calculate the length and next = start + step*/
     length = _calc_length(start, stop, step, &next,
                           PyTypeNum_ISCOMPLEX(dtype->type_num));
-    err = PyErr_Occurred();
+    PyObject *err = PyErr_Occurred();
     if (err) {
-        Py_DECREF(dtype);
-        if (err && PyErr_GivenExceptionMatches(err, PyExc_OverflowError)) {
+        if (PyErr_GivenExceptionMatches(err, PyExc_OverflowError)) {
             PyErr_SetString(PyExc_ValueError, "Maximum allowed size exceeded");
         }
         goto fail;
     }
     if (length <= 0) {
         length = 0;
-        range = (PyArrayObject *)PyArray_SimpleNewFromDescr(1, &length, dtype);
-        Py_DECREF(step);
-        Py_DECREF(start);
-        return (PyObject *)range;
-    }
-
-    /*
-     * If dtype is not in native byte-order then get native-byte
-     * order version.  And then swap on the way out.
-     */
-    if (!PyArray_ISNBO(dtype->byteorder)) {
-        native = PyArray_DescrNewByteorder(dtype, NPY_NATBYTE);
-        swap = 1;
-    }
-    else {
-        native = dtype;
-        swap = 0;
     }
 
+    Py_INCREF(native);
     range = (PyArrayObject *)PyArray_SimpleNewFromDescr(1, &length, native);
     if (range == NULL) {
         goto fail;
     }
 
+    if (length == 0) {
+        goto finish;
+    }
     /*
      * place start in the buffer and the next value in the second position
      * if length > 2, then call the inner loop, otherwise stop
      */
-    funcs = PyArray_DESCR(range)->f;
     if (funcs->setitem(start, PyArray_DATA(range), range) < 0) {
         goto fail;
     }
@@ -3343,11 +3367,7 @@ PyArray_ArangeObj(PyObject *start, PyObject *stop, PyObject *step, PyArray_Descr
     if (length == 2) {
         goto finish;
     }
-    if (!funcs->fill) {
-        PyErr_SetString(PyExc_ValueError, "no fill-function for data-type.");
-        Py_DECREF(range);
-        goto fail;
-    }
+
     NPY_BEGIN_THREADS_DESCR(PyArray_DESCR(range));
     funcs->fill(PyArray_DATA(range), length, range);
     NPY_END_THREADS;
@@ -3359,20 +3379,31 @@ PyArray_ArangeObj(PyObject *start, PyObject *stop, PyObject *step, PyArray_Descr
     if (swap) {
         PyObject *new;
         new = PyArray_Byteswap(range, 1);
+        if (new == NULL) {
+            goto fail;
+        }
         Py_DECREF(new);
+        /* Replace dtype after swapping in-place above: */
         Py_DECREF(PyArray_DESCR(range));
-        /* steals the reference */
+        Py_INCREF(dtype);
         ((PyArrayObject_fields *)range)->descr = dtype;
     }
+    Py_DECREF(dtype);
+    Py_DECREF(native);
     Py_DECREF(start);
+    Py_DECREF(stop);
     Py_DECREF(step);
-    Py_DECREF(next);
+    Py_XDECREF(next);
     return (PyObject *)range;
 
  fail:
-    Py_DECREF(start);
-    Py_DECREF(step);
+    Py_XDECREF(dtype);
+    Py_XDECREF(native);
+    Py_XDECREF(start);
+    Py_XDECREF(stop);
+    Py_XDECREF(step);
     Py_XDECREF(next);
+    Py_XDECREF(range);
     return NULL;
 }
 
@@ -3573,6 +3604,10 @@ PyArray_FromFile(FILE *fp, PyArray_Descr *dtype, npy_intp num, char *sep)
     PyArrayObject *ret;
     size_t nread = 0;
 
+    if (dtype == NULL) {
+        return NULL;
+    }
+
     if (PyDataType_REFCHK(dtype)) {
         PyErr_SetString(PyExc_ValueError,
                 "Cannot read into object array");
@@ -3640,6 +3675,9 @@ PyArray_FromBuffer(PyObject *buf, PyArray_Descr *type,
     int itemsize;
     int writeable = 1;
 
+    if (type == NULL) {
+        return NULL;
+    }
 
     if (PyDataType_REFCHK(type)) {
         PyErr_SetString(PyExc_ValueError,
@@ -3655,28 +3693,45 @@ PyArray_FromBuffer(PyObject *buf, PyArray_Descr *type,
         return NULL;
     }
 
+    /*
+     * If the object supports `releasebuffer`, the new buffer protocol allows
+     * tying the memories lifetime to the `Py_buffer view`.
+     * NumPy cannot hold on to the view itself (it is not an object) so it
+     * has to wrap the original object in a Python `memoryview` which deals
+     * with the lifetime management for us.
+     * For backwards compatibility of `arr.base` we try to avoid this when
+     * possible.  (For example, NumPy arrays will never get wrapped here!)
+     */
+    if (Py_TYPE(buf)->tp_as_buffer
+            && Py_TYPE(buf)->tp_as_buffer->bf_releasebuffer) {
+        buf = PyMemoryView_FromObject(buf);
+        if (buf == NULL) {
+            return NULL;
+        }
+    }
+    else {
+        Py_INCREF(buf);
+    }
+
     if (PyObject_GetBuffer(buf, &view, PyBUF_WRITABLE|PyBUF_SIMPLE) < 0) {
         writeable = 0;
         PyErr_Clear();
         if (PyObject_GetBuffer(buf, &view, PyBUF_SIMPLE) < 0) {
+            Py_DECREF(buf);
             Py_DECREF(type);
             return NULL;
         }
     }
     data = (char *)view.buf;
     ts = view.len;
-    /*
-     * In Python 3 both of the deprecated functions PyObject_AsWriteBuffer and
-     * PyObject_AsReadBuffer that this code replaces release the buffer. It is
-     * up to the object that supplies the buffer to guarantee that the buffer
-     * sticks around after the release.
-     */
+    /* `buf` is an array or a memoryview; so we know `view` does not own data */
     PyBuffer_Release(&view);
 
     if ((offset < 0) || (offset > ts)) {
         PyErr_Format(PyExc_ValueError,
                      "offset must be non-negative and no greater than buffer "\
                      "length (%" NPY_INTP_FMT ")", (npy_intp)ts);
+        Py_DECREF(buf);
         Py_DECREF(type);
         return NULL;
     }
@@ -3689,6 +3744,7 @@ PyArray_FromBuffer(PyObject *buf, PyArray_Descr *type,
         if (itemsize == 0) {
             PyErr_SetString(PyExc_ValueError,
                             "cannot determine count if itemsize is 0");
+            Py_DECREF(buf);
             Py_DECREF(type);
             return NULL;
         }
@@ -3696,6 +3752,7 @@ PyArray_FromBuffer(PyObject *buf, PyArray_Descr *type,
             PyErr_SetString(PyExc_ValueError,
                             "buffer size must be a multiple"\
                             " of element size");
+            Py_DECREF(buf);
             Py_DECREF(type);
             return NULL;
         }
@@ -3706,6 +3763,7 @@ PyArray_FromBuffer(PyObject *buf, PyArray_Descr *type,
             PyErr_SetString(PyExc_ValueError,
                             "buffer is smaller than requested"\
                             " size");
+            Py_DECREF(buf);
             Py_DECREF(type);
             return NULL;
         }
@@ -3715,6 +3773,7 @@ PyArray_FromBuffer(PyObject *buf, PyArray_Descr *type,
             &PyArray_Type, type,
             1, &n, NULL, data,
             NPY_ARRAY_DEFAULT, NULL, buf);
+    Py_DECREF(buf);
     if (ret == NULL) {
         return NULL;
     }
@@ -3846,16 +3905,21 @@ PyArray_FromString(char *data, npy_intp slen, PyArray_Descr *dtype,
 NPY_NO_EXPORT PyObject *
 PyArray_FromIter(PyObject *obj, PyArray_Descr *dtype, npy_intp count)
 {
-    PyObject *value;
-    PyObject *iter = PyObject_GetIter(obj);
+    PyObject *iter = NULL;
     PyArrayObject *ret = NULL;
     npy_intp i, elsize, elcount;
-    char *item, *new_data;
 
+    if (dtype == NULL) {
+        return NULL;
+    }
+
+    iter = PyObject_GetIter(obj);
     if (iter == NULL) {
         goto done;
     }
+
     if (PyDataType_ISUNSIZED(dtype)) {
+        /* If this error is removed, the `ret` allocation may need fixing */
         PyErr_SetString(PyExc_ValueError,
                 "Must specify length when using variable-size data-type.");
         goto done;
@@ -3873,38 +3937,43 @@ PyArray_FromIter(PyObject *obj, PyArray_Descr *dtype, npy_intp count)
     elsize = dtype->elsize;
 
     /*
-     * We would need to alter the memory RENEW code to decrement any
-     * reference counts before throwing away any memory.
+     * Note that PyArray_DESCR(ret) may not match dtype.  There are exactly
+     * two cases where this can happen: empty strings/bytes/void (rejected
+     * above) and subarray dtypes (supported by sticking with `dtype`).
      */
-    if (PyDataType_REFCHK(dtype)) {
-        PyErr_SetString(PyExc_ValueError,
-                "cannot create object arrays from iterator");
-        goto done;
-    }
-
+    Py_INCREF(dtype);
     ret = (PyArrayObject *)PyArray_NewFromDescr(&PyArray_Type, dtype, 1,
                                                 &elcount, NULL,NULL, 0, NULL);
-    dtype = NULL;
     if (ret == NULL) {
         goto done;
     }
-    for (i = 0; (i < count || count == -1) &&
-             (value = PyIter_Next(iter)); i++) {
-        if (i >= elcount && elsize != 0) {
+
+    char *item = PyArray_BYTES(ret);
+    for (i = 0; i < count || count == -1; i++, item += elsize) {
+        PyObject *value = PyIter_Next(iter);
+        if (value == NULL) {
+            if (PyErr_Occurred()) {
+                /* Fetching next item failed perhaps due to exhausting iterator */
+                goto done;
+            }
+            break;
+        }
+
+        if (NPY_UNLIKELY(i >= elcount) && elsize != 0) {
+            char *new_data = NULL;
             npy_intp nbytes;
             /*
               Grow PyArray_DATA(ret):
               this is similar for the strategy for PyListObject, but we use
               50% overallocation => 0, 4, 8, 14, 23, 36, 56, 86 ...
+              TODO: The loadtxt code now uses a `growth` helper that would
+                    be suitable to reuse here.
             */
             elcount = (i >> 1) + (i < 4 ? 4 : 2) + i;
-            if (!npy_mul_with_overflow_intp(&nbytes, elcount, elsize)) {
+            if (!npy_mul_sizes_with_overflow(&nbytes, elcount, elsize)) {
                 /* The handler is always valid */
-                new_data = PyDataMem_UserRENEW(PyArray_DATA(ret), nbytes,
-                                  PyArray_HANDLER(ret));
-            }
-            else {
-                new_data = NULL;
+                new_data = PyDataMem_UserRENEW(
+                        PyArray_BYTES(ret), nbytes, PyArray_HANDLER(ret));
             }
             if (new_data == NULL) {
                 PyErr_SetString(PyExc_MemoryError,
@@ -3913,44 +3982,66 @@ PyArray_FromIter(PyObject *obj, PyArray_Descr *dtype, npy_intp count)
                 goto done;
             }
             ((PyArrayObject_fields *)ret)->data = new_data;
+            /* resize array for cleanup: */
+            PyArray_DIMS(ret)[0] = elcount;
+            /* Reset `item` pointer to point into realloc'd chunk */
+            item = new_data + i * elsize;
+            if (PyDataType_FLAGCHK(dtype, NPY_NEEDS_INIT)) {
+                /* Initialize new chunk: */
+                memset(item, 0, nbytes - i * elsize);
+            }
         }
-        PyArray_DIMS(ret)[0] = i + 1;
 
-        if (((item = index2ptr(ret, i)) == NULL) ||
-                PyArray_SETITEM(ret, item, value) == -1) {
+        if (PyArray_Pack(dtype, item, value) < 0) {
             Py_DECREF(value);
             goto done;
         }
         Py_DECREF(value);
     }
 
-
-    if (PyErr_Occurred()) {
-        goto done;
-    }
     if (i < count) {
-        PyErr_SetString(PyExc_ValueError,
-                "iterator too short");
+        PyErr_Format(PyExc_ValueError,
+                "iterator too short: Expected %zd but iterator had only %zd "
+                "items.", (Py_ssize_t)count, (Py_ssize_t)i);
         goto done;
     }
 
     /*
-     * Realloc the data so that don't keep extra memory tied up
-     * (assuming realloc is reasonably good about reusing space...)
+     * Realloc the data so that don't keep extra memory tied up and fix
+     * the arrays first dimension (there could be more than one).
      */
     if (i == 0 || elsize == 0) {
         /* The size cannot be zero for realloc. */
-        goto done;
     }
-    /* The handler is always valid */
-    new_data = PyDataMem_UserRENEW(PyArray_DATA(ret), i * elsize,
-                                   PyArray_HANDLER(ret));
-    if (new_data == NULL) {
-        PyErr_SetString(PyExc_MemoryError,
-                "cannot allocate array memory");
-        goto done;
+    else {
+        /* Resize array to actual final size (it may be too large) */
+        /* The handler is always valid */
+        char *new_data = PyDataMem_UserRENEW(
+                PyArray_DATA(ret), i * elsize, PyArray_HANDLER(ret));
+
+        if (new_data == NULL) {
+            PyErr_SetString(PyExc_MemoryError,
+                    "cannot allocate array memory");
+            goto done;
+        }
+        ((PyArrayObject_fields *)ret)->data = new_data;
+
+        if (count < 0 || NPY_RELAXED_STRIDES_DEBUG) {
+            /*
+             * If the count was smaller than zero or NPY_RELAXED_STRIDES_DEBUG
+             * was active, the strides may be all 0 or intentionally mangled
+             * (even in the later dimensions for `count < 0`!
+             * Thus, fix all strides here again for C-contiguity.
+             */
+            int oflags;
+            _array_fill_strides(
+                    PyArray_STRIDES(ret), PyArray_DIMS(ret), PyArray_NDIM(ret),
+                    PyArray_ITEMSIZE(ret), NPY_ARRAY_C_CONTIGUOUS, &oflags);
+            PyArray_STRIDES(ret)[0] = elsize;
+            assert(oflags & NPY_ARRAY_C_CONTIGUOUS);
+        }
     }
-    ((PyArrayObject_fields *)ret)->data = new_data;
+    PyArray_DIMS(ret)[0] = i;
 
  done:
     Py_XDECREF(iter);
@@ -3986,7 +4077,6 @@ _array_fill_strides(npy_intp *strides, npy_intp const *dims, int nd, size_t item
                     int inflag, int *objflags)
 {
     int i;
-#if NPY_RELAXED_STRIDES_CHECKING
     npy_bool not_cf_contig = 0;
     npy_bool nod = 0; /* A dim != 1 was found */
 
@@ -4000,7 +4090,6 @@ _array_fill_strides(npy_intp *strides, npy_intp const *dims, int nd, size_t item
             nod = 1;
         }
     }
-#endif /* NPY_RELAXED_STRIDES_CHECKING */
 
     /* Only make Fortran strides if not contiguous as well */
     if ((inflag & (NPY_ARRAY_F_CONTIGUOUS|NPY_ARRAY_C_CONTIGUOUS)) ==
@@ -4010,7 +4099,6 @@ _array_fill_strides(npy_intp *strides, npy_intp const *dims, int nd, size_t item
             if (dims[i]) {
                 itemsize *= dims[i];
             }
-#if NPY_RELAXED_STRIDES_CHECKING
             else {
                 not_cf_contig = 0;
             }
@@ -4020,13 +4108,8 @@ _array_fill_strides(npy_intp *strides, npy_intp const *dims, int nd, size_t item
                 strides[i] = NPY_MAX_INTP;
             }
 #endif /* NPY_RELAXED_STRIDES_DEBUG */
-#endif /* NPY_RELAXED_STRIDES_CHECKING */
         }
-#if NPY_RELAXED_STRIDES_CHECKING
         if (not_cf_contig) {
-#else /* not NPY_RELAXED_STRIDES_CHECKING */
-        if ((nd > 1) && ((strides[0] != strides[nd-1]) || (dims[nd-1] > 1))) {
-#endif /* not NPY_RELAXED_STRIDES_CHECKING */
             *objflags = ((*objflags)|NPY_ARRAY_F_CONTIGUOUS) &
                                             ~NPY_ARRAY_C_CONTIGUOUS;
         }
@@ -4040,7 +4123,6 @@ _array_fill_strides(npy_intp *strides, npy_intp const *dims, int nd, size_t item
             if (dims[i]) {
                 itemsize *= dims[i];
             }
-#if NPY_RELAXED_STRIDES_CHECKING
             else {
                 not_cf_contig = 0;
             }
@@ -4050,13 +4132,8 @@ _array_fill_strides(npy_intp *strides, npy_intp const *dims, int nd, size_t item
                 strides[i] = NPY_MAX_INTP;
             }
 #endif /* NPY_RELAXED_STRIDES_DEBUG */
-#endif /* NPY_RELAXED_STRIDES_CHECKING */
         }
-#if NPY_RELAXED_STRIDES_CHECKING
         if (not_cf_contig) {
-#else /* not NPY_RELAXED_STRIDES_CHECKING */
-        if ((nd > 1) && ((strides[0] != strides[nd-1]) || (dims[0] > 1))) {
-#endif /* not NPY_RELAXED_STRIDES_CHECKING */
             *objflags = ((*objflags)|NPY_ARRAY_C_CONTIGUOUS) &
                                             ~NPY_ARRAY_F_CONTIGUOUS;
         }
diff --git a/numpy/core/src/multiarray/datetime.c b/numpy/core/src/multiarray/datetime.c
index e0064c017361..2abd68ca23f9 100644
--- a/numpy/core/src/multiarray/datetime.c
+++ b/numpy/core/src/multiarray/datetime.c
@@ -1633,7 +1633,7 @@ incompatible_units: {
             return -1;
         }
         PyErr_Format(PyExc_TypeError,
-            "Cannot get a common metadata divisor for Numpy datatime "
+            "Cannot get a common metadata divisor for Numpy datetime "
             "metadata %S and %S because they have incompatible nonlinear "
             "base time units.", umeta1, umeta2);
         Py_DECREF(umeta1);
@@ -3746,8 +3746,6 @@ find_object_datetime_type(PyObject *obj, int type_num)
 }
 
 
-
-
 /*
  * Describes casting within datetimes or timedelta
  */
@@ -3756,13 +3754,14 @@ time_to_time_resolve_descriptors(
         PyArrayMethodObject *NPY_UNUSED(self),
         PyArray_DTypeMeta *NPY_UNUSED(dtypes[2]),
         PyArray_Descr *given_descrs[2],
-        PyArray_Descr *loop_descrs[2])
+        PyArray_Descr *loop_descrs[2],
+        npy_intp *view_offset)
 {
     /* This is a within-dtype cast, which currently must handle byteswapping */
     Py_INCREF(given_descrs[0]);
     loop_descrs[0] = given_descrs[0];
     if (given_descrs[1] == NULL) {
-        loop_descrs[1] = ensure_dtype_nbo(given_descrs[0]);
+        loop_descrs[1] = NPY_DT_CALL_ensure_canonical(given_descrs[0]);
     }
     else {
         Py_INCREF(given_descrs[1]);
@@ -3772,14 +3771,14 @@ time_to_time_resolve_descriptors(
     int is_timedelta = given_descrs[0]->type_num == NPY_TIMEDELTA;
 
     if (given_descrs[0] == given_descrs[1]) {
-        return NPY_NO_CASTING | _NPY_CAST_IS_VIEW;
+        *view_offset = 0;
+        return NPY_NO_CASTING;
     }
 
-    NPY_CASTING byteorder_may_allow_view = 0;
-    if (PyDataType_ISNOTSWAPPED(loop_descrs[0]) ==
-            PyDataType_ISNOTSWAPPED(loop_descrs[1])) {
-        byteorder_may_allow_view = _NPY_CAST_IS_VIEW;
-    }
+    npy_bool byteorder_may_allow_view = (
+            PyDataType_ISNOTSWAPPED(loop_descrs[0])
+            == PyDataType_ISNOTSWAPPED(loop_descrs[1]));
+
     PyArray_DatetimeMetaData *meta1, *meta2;
     meta1 = get_datetime_metadata_from_dtype(loop_descrs[0]);
     assert(meta1 != NULL);
@@ -3798,12 +3797,16 @@ time_to_time_resolve_descriptors(
             ((meta2->base >= 7) && (meta1->base - meta2->base == 3)
               && ((meta1->num / meta2->num) == 1000000000))) {
         if (byteorder_may_allow_view) {
-            return NPY_NO_CASTING | byteorder_may_allow_view;
+            *view_offset = 0;
+            return NPY_NO_CASTING;
         }
         return NPY_EQUIV_CASTING;
     }
     else if (meta1->base == NPY_FR_GENERIC) {
-        return NPY_SAFE_CASTING | byteorder_may_allow_view;
+        if (byteorder_may_allow_view) {
+            *view_offset = 0;
+        }
+        return NPY_SAFE_CASTING ;
     }
     else if (meta2->base == NPY_FR_GENERIC) {
         /* TODO: This is actually an invalid cast (casting will error) */
@@ -3877,8 +3880,8 @@ time_to_time_get_loop(
         return 0;
     }
 
-    PyArray_Descr *src_wrapped_dtype = ensure_dtype_nbo(descrs[0]);
-    PyArray_Descr *dst_wrapped_dtype = ensure_dtype_nbo(descrs[1]);
+    PyArray_Descr *src_wrapped_dtype = NPY_DT_CALL_ensure_canonical(descrs[0]);
+    PyArray_Descr *dst_wrapped_dtype = NPY_DT_CALL_ensure_canonical(descrs[1]);
 
     int needs_api = 0;
     int res = wrap_aligned_transferfunction(
@@ -3901,9 +3904,10 @@ datetime_to_timedelta_resolve_descriptors(
         PyArrayMethodObject *NPY_UNUSED(self),
         PyArray_DTypeMeta *dtypes[2],
         PyArray_Descr *given_descrs[2],
-        PyArray_Descr *loop_descrs[2])
+        PyArray_Descr *loop_descrs[2],
+        npy_intp *NPY_UNUSED(view_offset))
 {
-    loop_descrs[0] = ensure_dtype_nbo(given_descrs[0]);
+    loop_descrs[0] = NPY_DT_CALL_ensure_canonical(given_descrs[0]);
     if (loop_descrs[0] == NULL) {
         return -1;
     }
@@ -3913,7 +3917,7 @@ datetime_to_timedelta_resolve_descriptors(
         loop_descrs[1] = create_datetime_dtype(dtypes[1]->type_num, meta);
     }
     else {
-        loop_descrs[1] = ensure_dtype_nbo(given_descrs[1]);
+        loop_descrs[1] = NPY_DT_CALL_ensure_canonical(given_descrs[1]);
     }
     if (loop_descrs[1] == NULL) {
         Py_DECREF(loop_descrs[0]);
@@ -3931,10 +3935,11 @@ datetime_to_timedelta_resolve_descriptors(
 /* In the current setup both strings and unicode casts support all outputs */
 static NPY_CASTING
 time_to_string_resolve_descriptors(
-        PyArrayMethodObject *self,
+        PyArrayMethodObject *NPY_UNUSED(self),
         PyArray_DTypeMeta *dtypes[2],
         PyArray_Descr **given_descrs,
-        PyArray_Descr **loop_descrs)
+        PyArray_Descr **loop_descrs,
+        npy_intp *NPY_UNUSED(view_offset))
 {
     if (given_descrs[1] != NULL && dtypes[0]->type_num == NPY_DATETIME) {
         /*
@@ -3969,7 +3974,7 @@ time_to_string_resolve_descriptors(
         loop_descrs[1]->elsize = size;
     }
 
-    loop_descrs[0] = ensure_dtype_nbo(given_descrs[0]);
+    loop_descrs[0] = NPY_DT_CALL_ensure_canonical(given_descrs[0]);
     if (loop_descrs[0] == NULL) {
         Py_DECREF(loop_descrs[1]);
         return -1;
@@ -4013,7 +4018,8 @@ string_to_datetime_cast_resolve_descriptors(
         PyArrayMethodObject *NPY_UNUSED(self),
         PyArray_DTypeMeta *dtypes[2],
         PyArray_Descr *given_descrs[2],
-        PyArray_Descr *loop_descrs[2])
+        PyArray_Descr *loop_descrs[2],
+        npy_intp *NPY_UNUSED(view_offset))
 {
     if (given_descrs[1] == NULL) {
         /* NOTE: This doesn't actually work, and will error during the cast */
@@ -4023,7 +4029,7 @@ string_to_datetime_cast_resolve_descriptors(
         }
     }
     else {
-        loop_descrs[1] = ensure_dtype_nbo(given_descrs[1]);
+        loop_descrs[1] = NPY_DT_CALL_ensure_canonical(given_descrs[1]);
         if (loop_descrs[1] == NULL) {
             return -1;
         }
@@ -4083,8 +4089,8 @@ PyArray_InitializeDatetimeCasts()
         .nout = 1,
         .casting = NPY_UNSAFE_CASTING,
         .flags = NPY_METH_SUPPORTS_UNALIGNED,
-        .slots = slots,
         .dtypes = dtypes,
+        .slots = slots,
     };
     slots[0].slot = NPY_METH_resolve_descriptors;
     slots[0].pfunc = &time_to_time_resolve_descriptors;
diff --git a/numpy/core/src/multiarray/descriptor.c b/numpy/core/src/multiarray/descriptor.c
index 0c539053c9e7..d1973442a68a 100644
--- a/numpy/core/src/multiarray/descriptor.c
+++ b/numpy/core/src/multiarray/descriptor.c
@@ -15,25 +15,13 @@
 
 #include "_datetime.h"
 #include "common.h"
-#include "templ_common.h" /* for npy_mul_with_overflow_intp */
+#include "templ_common.h" /* for npy_mul_sizes_with_overflow */
 #include "descriptor.h"
 #include "alloc.h"
 #include "assert.h"
 #include "npy_buffer.h"
 #include "dtypemeta.h"
 
-/*
- * offset:    A starting offset.
- * alignment: A power-of-two alignment.
- *
- * This macro returns the smallest value >= 'offset'
- * that is divisible by 'alignment'. Because 'alignment'
- * is a power of two and integers are twos-complement,
- * it is possible to use some simple bit-fiddling to do this.
- */
-#define NPY_NEXT_ALIGNED_OFFSET(offset, alignment) \
-                (((offset) + (alignment) - 1) & (-(alignment)))
-
 #ifndef PyDictProxy_Check
 #define PyDictProxy_Check(obj) (Py_TYPE(obj) == &PyDictProxy_Type)
 #endif
@@ -597,9 +585,7 @@ _convert_from_array_descr(PyObject *obj, int align)
 
     PyArray_Descr *new = PyArray_DescrNewFromType(NPY_VOID);
     if (new == NULL) {
-        Py_XDECREF(fields);
-        Py_XDECREF(nameslist);
-        return NULL;
+        goto fail;
     }
     new->fields = fields;
     new->names = nameslist;
@@ -703,6 +689,9 @@ _convert_from_list(PyObject *obj, int align)
         totalsize += conv->elsize;
     }
     PyArray_Descr *new = PyArray_DescrNewFromType(NPY_VOID);
+    if (new == NULL) {
+        goto fail;
+    }
     new->fields = fields;
     new->names = nameslist;
     new->flags = dtypeflags;
@@ -1381,6 +1370,9 @@ PyArray_DescrNewFromType(int type_num)
     PyArray_Descr *new;
 
     old = PyArray_DescrFromType(type_num);
+    if (old == NULL) {
+        return NULL;
+    }
     new = PyArray_DescrNew(old);
     Py_DECREF(old);
     return new;
@@ -2172,6 +2164,7 @@ arraydescr_names_set(
 
     N = PyTuple_GET_SIZE(self->names);
     if (!PySequence_Check(val) || PyObject_Size((PyObject *)val) != N) {
+        /* Should be a TypeError, but this should be deprecated anyway. */
         PyErr_Format(PyExc_ValueError,
                 "must replace all names at once with a sequence of length %d",
                 N);
@@ -2180,16 +2173,17 @@ arraydescr_names_set(
     /* Make sure all entries are strings */
     for (i = 0; i < N; i++) {
         PyObject *item;
-        int valid = 1;
+        int valid;
         item = PySequence_GetItem(val, i);
         valid = PyUnicode_Check(item);
-        Py_DECREF(item);
         if (!valid) {
             PyErr_Format(PyExc_ValueError,
                     "item #%d of names is of type %s and not string",
                     i, Py_TYPE(item)->tp_name);
+            Py_DECREF(item);
             return -1;
         }
+        Py_DECREF(item);
     }
     /* Invalidate cached hash value */
     self->hash = -1;
@@ -2341,7 +2335,7 @@ arraydescr_new(PyTypeObject *subtype,
     }
 
     PyObject *odescr, *metadata=NULL;
-    PyArray_Descr *descr, *conv;
+    PyArray_Descr *conv;
     npy_bool align = NPY_FALSE;
     npy_bool copy = NPY_FALSE;
     npy_bool copied = NPY_FALSE;
@@ -2363,9 +2357,10 @@ arraydescr_new(PyTypeObject *subtype,
 
     /* Get a new copy of it unless it's already a copy */
     if (copy && conv->fields == Py_None) {
-        descr = PyArray_DescrNew(conv);
-        Py_DECREF(conv);
-        conv = descr;
+        PyArray_DESCR_REPLACE(conv);
+        if (conv == NULL) {
+            return NULL;
+        }
         copied = NPY_TRUE;
     }
 
@@ -2375,10 +2370,11 @@ arraydescr_new(PyTypeObject *subtype,
          * underlying dictionary
          */
         if (!copied) {
+            PyArray_DESCR_REPLACE(conv);
+            if (conv == NULL) {
+                return NULL;
+            }
             copied = NPY_TRUE;
-            descr = PyArray_DescrNew(conv);
-            Py_DECREF(conv);
-            conv = descr;
         }
         if ((conv->metadata != NULL)) {
             /*
@@ -3047,6 +3043,9 @@ PyArray_DescrNewByteorder(PyArray_Descr *self, char newendian)
     char endian;
 
     new = PyArray_DescrNew(self);
+    if (new == NULL) {
+        return NULL;
+    }
     endian = new->byteorder;
     if (endian != NPY_IGNORE) {
         if (newendian == NPY_SWAP) {
@@ -3073,6 +3072,10 @@ PyArray_DescrNewByteorder(PyArray_Descr *self, char newendian)
         int len, i;
 
         newfields = PyDict_New();
+        if (newfields == NULL) {
+            Py_DECREF(new);
+            return NULL;
+        }
         /* make new dictionary with replaced PyArray_Descr Objects */
         while (PyDict_Next(self->fields, &pos, &key, &value)) {
             if (NPY_TITLE_KEY(key, value)) {
@@ -3114,6 +3117,10 @@ PyArray_DescrNewByteorder(PyArray_Descr *self, char newendian)
         Py_DECREF(new->subarray->base);
         new->subarray->base = PyArray_DescrNewByteorder(
                 self->subarray->base, newendian);
+        if (new->subarray->base == NULL) {
+            Py_DECREF(new);
+            return NULL;
+        }
     }
     return new;
 }
@@ -3586,8 +3593,8 @@ NPY_NO_EXPORT PyArray_DTypeMeta PyArrayDescr_TypeFull = {
         .tp_getset = arraydescr_getsets,
         .tp_new = arraydescr_new,
     },},
-    .type_num = -1,
-    .flags = NPY_DT_ABSTRACT,
     .singleton = NULL,
+    .type_num = -1,
     .scalar_type = NULL,
+    .flags = NPY_DT_ABSTRACT,
 };
diff --git a/numpy/core/src/multiarray/descriptor.h b/numpy/core/src/multiarray/descriptor.h
index f832958dae90..7e6f212f2879 100644
--- a/numpy/core/src/multiarray/descriptor.h
+++ b/numpy/core/src/multiarray/descriptor.h
@@ -6,6 +6,18 @@ NPY_NO_EXPORT PyObject *arraydescr_protocol_typestr_get(
 NPY_NO_EXPORT PyObject *arraydescr_protocol_descr_get(
         PyArray_Descr *self, void *);
 
+/*
+ * offset:    A starting offset.
+ * alignment: A power-of-two alignment.
+ *
+ * This macro returns the smallest value >= 'offset'
+ * that is divisible by 'alignment'. Because 'alignment'
+ * is a power of two and integers are twos-complement,
+ * it is possible to use some simple bit-fiddling to do this.
+ */
+#define NPY_NEXT_ALIGNED_OFFSET(offset, alignment) \
+                (((offset) + (alignment) - 1) & (-(alignment)))
+
 NPY_NO_EXPORT PyObject *
 array_set_typeDict(PyObject *NPY_UNUSED(ignored), PyObject *args);
 
diff --git a/numpy/core/src/multiarray/dlpack.c b/numpy/core/src/multiarray/dlpack.c
index 291e60a226a7..1c6eb58f2586 100644
--- a/numpy/core/src/multiarray/dlpack.c
+++ b/numpy/core/src/multiarray/dlpack.c
@@ -3,22 +3,33 @@
 
 #define PY_SSIZE_T_CLEAN
 #include 
-#include 
 
+#include "dlpack/dlpack.h"
 #include "numpy/arrayobject.h"
-#include "common/npy_argparse.h"
-
-#include "common/dlpack/dlpack.h"
-#include "common/npy_dlpack.h"
+#include "npy_argparse.h"
+#include "npy_dlpack.h"
 
 static void
 array_dlpack_deleter(DLManagedTensor *self)
 {
+    /*
+     * Leak the pyobj if not initialized.  This can happen if we are running
+     * exit handlers that are destructing c++ objects with residual (owned)
+     * PyObjects stored in them after the Python runtime has already been
+     * terminated.
+     */
+    if (!Py_IsInitialized()) {
+        return;
+    }
+
+    PyGILState_STATE state = PyGILState_Ensure();
+
     PyArrayObject *array = (PyArrayObject *)self->manager_ctx;
-    // This will also free the strides as it's one allocation.
-    PyMem_Free(self->dl_tensor.shape);
+    // This will also free the shape and strides as it's one allocation.
     PyMem_Free(self);
     Py_XDECREF(array);
+
+    PyGILState_Release(state);
 }
 
 /* This is exactly as mandated by dlpack */
@@ -88,6 +99,12 @@ array_get_dl_device(PyArrayObject *self) {
     ret.device_type = kDLCPU;
     ret.device_id = 0;
     PyObject *base = PyArray_BASE(self);
+
+    // walk the bases (see gh-20340)
+    while (base != NULL && PyArray_Check(base)) {
+        base = PyArray_BASE((PyArrayObject *)base);
+    }
+
     // The outer if is due to the fact that NumPy arrays are on the CPU
     // by default (if not created from DLPack).
     if (PyCapsule_IsValid(base, NPY_DLPACK_INTERNAL_CAPSULE_NAME)) {
@@ -114,14 +131,15 @@ array_dlpack(PyArrayObject *self,
     }
 
     if (stream != Py_None) {
-        PyErr_SetString(PyExc_RuntimeError, "NumPy only supports "
-                "stream=None.");
+        PyErr_SetString(PyExc_RuntimeError,
+                "NumPy only supports stream=None.");
         return NULL;
     }
 
     if ( !(PyArray_FLAGS(self) & NPY_ARRAY_WRITEABLE)) {
-        PyErr_SetString(PyExc_TypeError, "NumPy currently only supports "
-                "dlpack for writeable arrays");
+        PyErr_SetString(PyExc_BufferError,
+            "Cannot export readonly array since signalling readonly "
+            "is unsupported by DLPack.");
         return NULL;
     }
 
@@ -132,8 +150,8 @@ array_dlpack(PyArrayObject *self,
 
     if (!PyArray_IS_C_CONTIGUOUS(self) && PyArray_SIZE(self) != 1) {
         for (int i = 0; i < ndim; ++i) {
-            if (strides[i] % itemsize != 0) {
-                PyErr_SetString(PyExc_RuntimeError,
+            if (shape[i] != 1 && strides[i] % itemsize != 0) {
+                PyErr_SetString(PyExc_BufferError,
                         "DLPack only supports strides which are a multiple of "
                         "itemsize.");
                 return NULL;
@@ -145,8 +163,8 @@ array_dlpack(PyArrayObject *self,
     PyArray_Descr *dtype = PyArray_DESCR(self);
 
     if (PyDataType_ISBYTESWAPPED(dtype)) {
-        PyErr_SetString(PyExc_TypeError, "DLPack only supports native "
-                    "byte swapping.");
+        PyErr_SetString(PyExc_BufferError,
+                "DLPack only supports native byte order.");
             return NULL;
     }
 
@@ -163,8 +181,9 @@ array_dlpack(PyArrayObject *self,
         // We can't be sure that the dtype is
         // IEEE or padded.
         if (itemsize > 8) {
-            PyErr_SetString(PyExc_TypeError, "DLPack only supports IEEE "
-                    "floating point types without padding.");
+            PyErr_SetString(PyExc_BufferError,
+                    "DLPack only supports IEEE floating point types "
+                    "without padding (longdouble typically is not IEEE).");
             return NULL;
         }
         managed_dtype.code = kDLFloat;
@@ -173,16 +192,17 @@ array_dlpack(PyArrayObject *self,
         // We can't be sure that the dtype is
         // IEEE or padded.
         if (itemsize > 16) {
-            PyErr_SetString(PyExc_TypeError, "DLPack only supports IEEE "
-                    "complex point types without padding.");
+            PyErr_SetString(PyExc_BufferError,
+                    "DLPack only supports IEEE floating point types "
+                    "without padding (longdouble typically is not IEEE).");
             return NULL;
         }
         managed_dtype.code = kDLComplex;
     }
     else {
-        PyErr_SetString(PyExc_TypeError,
-                        "DLPack only supports signed/unsigned integers, float "
-                        "and complex dtypes.");
+        PyErr_SetString(PyExc_BufferError,
+                "DLPack only supports signed/unsigned integers, float "
+                "and complex dtypes.");
         return NULL;
     }
 
@@ -191,12 +211,17 @@ array_dlpack(PyArrayObject *self,
         return NULL;
     }
 
-    DLManagedTensor *managed = PyMem_Malloc(sizeof(DLManagedTensor));
-    if (managed == NULL) {
+    // ensure alignment
+    int offset = sizeof(DLManagedTensor) % sizeof(void *);
+    void *ptr = PyMem_Malloc(sizeof(DLManagedTensor) + offset +
+        (sizeof(int64_t) * ndim * 2));
+    if (ptr == NULL) {
         PyErr_NoMemory();
         return NULL;
     }
 
+    DLManagedTensor *managed = ptr;
+
     /*
      * Note: the `dlpack.h` header suggests/standardizes that `data` must be
      * 256-byte aligned.  We ignore this intentionally, because `__dlpack__`
@@ -215,12 +240,8 @@ array_dlpack(PyArrayObject *self,
     managed->dl_tensor.device = device;
     managed->dl_tensor.dtype = managed_dtype;
 
-    int64_t *managed_shape_strides = PyMem_Malloc(sizeof(int64_t) * ndim * 2);
-    if (managed_shape_strides == NULL) {
-        PyErr_NoMemory();
-        PyMem_Free(managed);
-        return NULL;
-    }
+    int64_t *managed_shape_strides = (int64_t *)((char *)ptr +
+        sizeof(DLManagedTensor) + offset);
 
     int64_t *managed_shape = managed_shape_strides;
     int64_t *managed_strides = managed_shape_strides + ndim;
@@ -243,8 +264,7 @@ array_dlpack(PyArrayObject *self,
     PyObject *capsule = PyCapsule_New(managed, NPY_DLPACK_CAPSULE_NAME,
             dlpack_capsule_deleter);
     if (capsule == NULL) {
-        PyMem_Free(managed);
-        PyMem_Free(managed_shape_strides);
+        PyMem_Free(ptr);
         return NULL;
     }
 
@@ -264,7 +284,7 @@ array_dlpack_device(PyArrayObject *self, PyObject *NPY_UNUSED(args))
 }
 
 NPY_NO_EXPORT PyObject *
-_from_dlpack(PyObject *NPY_UNUSED(self), PyObject *obj) {
+from_dlpack(PyObject *NPY_UNUSED(self), PyObject *obj) {
     PyObject *capsule = PyObject_CallMethod((PyObject *)obj->ob_type,
             "__dlpack__", "O", obj);
     if (capsule == NULL) {
diff --git a/numpy/core/src/multiarray/dragon4.c b/numpy/core/src/multiarray/dragon4.c
index ce0293615228..5d245b106f91 100644
--- a/numpy/core/src/multiarray/dragon4.c
+++ b/numpy/core/src/multiarray/dragon4.c
@@ -1809,9 +1809,16 @@ FormatPositional(char *buffer, npy_uint32 bufferSize, BigInt *mantissa,
             pos--;
             numFractionDigits--;
         }
-        if (trim_mode == TrimMode_LeaveOneZero && buffer[pos-1] == '.') {
-            buffer[pos++] = '0';
-            numFractionDigits++;
+        if (buffer[pos-1] == '.') {
+            /* in TrimMode_LeaveOneZero, add trailing 0 back */
+            if (trim_mode == TrimMode_LeaveOneZero){
+                buffer[pos++] = '0';
+                numFractionDigits++;
+            }
+            /* in TrimMode_DptZeros, remove trailing decimal point */
+            else if (trim_mode == TrimMode_DptZeros) {
+                    pos--;
+            }
         }
     }
 
diff --git a/numpy/core/src/multiarray/dtype_transfer.c b/numpy/core/src/multiarray/dtype_transfer.c
index 8fb44c4f6c5b..c07670488a3d 100644
--- a/numpy/core/src/multiarray/dtype_transfer.c
+++ b/numpy/core/src/multiarray/dtype_transfer.c
@@ -11,12 +11,14 @@
  */
 #define NPY_NO_DEPRECATED_API NPY_API_VERSION
 #define _MULTIARRAYMODULE
+#define _UMATHMODULE
 
 #define PY_SSIZE_T_CLEAN
 #include 
 #include 
 
 #include "numpy/arrayobject.h"
+#include "numpy/npy_math.h"
 
 #include "lowlevel_strided_loops.h"
 #include "npy_pycompat.h"
@@ -35,6 +37,8 @@
 #include "array_method.h"
 #include "array_coercion.h"
 
+#include "umathmodule.h"
+
 #define NPY_LOWLEVEL_BUFFER_BLOCKSIZE  128
 
 /********** PRINTF DEBUG TRACING **************/
@@ -237,7 +241,7 @@ NPY_NO_EXPORT int
 any_to_object_get_loop(
         PyArrayMethod_Context *context,
         int aligned, int move_references,
-        npy_intp *strides,
+        const npy_intp *strides,
         PyArrayMethod_StridedLoop **out_loop,
         NpyAuxData **out_transferdata,
         NPY_ARRAYMETHOD_FLAGS *flags)
@@ -254,6 +258,7 @@ any_to_object_get_loop(
     data->base.free = &_any_to_object_auxdata_free;
     data->base.clone = &_any_to_object_auxdata_clone;
     data->arr_fields.base = NULL;
+    Py_SET_TYPE(&data->arr_fields, NULL);
     data->arr_fields.descr = context->descriptors[0];
     Py_INCREF(data->arr_fields.descr);
     data->arr_fields.flags = aligned ? NPY_ARRAY_ALIGNED : 0;
@@ -343,7 +348,7 @@ NPY_NO_EXPORT int
 object_to_any_get_loop(
         PyArrayMethod_Context *context,
         int NPY_UNUSED(aligned), int move_references,
-        npy_intp *NPY_UNUSED(strides),
+        const npy_intp *NPY_UNUSED(strides),
         PyArrayMethod_StridedLoop **out_loop,
         NpyAuxData **out_transferdata,
         NPY_ARRAYMETHOD_FLAGS *flags)
@@ -1506,7 +1511,7 @@ get_one_to_n_transfer_function(int aligned,
                             npy_intp N,
                             PyArrayMethod_StridedLoop **out_stransfer,
                             NpyAuxData **out_transferdata,
-                            int *out_needs_api)
+                            NPY_ARRAYMETHOD_FLAGS *out_flags)
 {
     _one_to_n_data *data = PyMem_Malloc(sizeof(_one_to_n_data));
     if (data == NULL) {
@@ -1530,18 +1535,19 @@ get_one_to_n_transfer_function(int aligned,
                     src_dtype, dst_dtype,
                     0,
                     &data->wrapped,
-                    out_needs_api) != NPY_SUCCEED) {
+                    out_flags) != NPY_SUCCEED) {
         NPY_AUXDATA_FREE((NpyAuxData *)data);
         return NPY_FAIL;
     }
 
     /* If the src object will need a DECREF, set src_dtype */
     if (move_references && PyDataType_REFCHK(src_dtype)) {
+        *out_flags |= NPY_METH_REQUIRES_PYAPI;
         if (get_decref_transfer_function(aligned,
                             src_stride,
                             src_dtype,
                             &data->decref_src,
-                            out_needs_api) != NPY_SUCCEED) {
+                            NULL) != NPY_SUCCEED) {
             NPY_AUXDATA_FREE((NpyAuxData *)data);
             return NPY_FAIL;
         }
@@ -1667,7 +1673,7 @@ get_n_to_n_transfer_function(int aligned,
                             npy_intp N,
                             PyArrayMethod_StridedLoop **out_stransfer,
                             NpyAuxData **out_transferdata,
-                            int *out_needs_api)
+                            NPY_ARRAYMETHOD_FLAGS *out_flags)
 {
     _n_to_n_data *data = PyMem_Malloc(sizeof(_n_to_n_data));
     if (data == NULL) {
@@ -1699,7 +1705,7 @@ get_n_to_n_transfer_function(int aligned,
                     src_dtype, dst_dtype,
                     move_references,
                     &data->wrapped,
-                    out_needs_api) != NPY_SUCCEED) {
+                    out_flags) != NPY_SUCCEED) {
         NPY_AUXDATA_FREE((NpyAuxData *)data);
         return NPY_FAIL;
     }
@@ -1913,7 +1919,7 @@ get_subarray_broadcast_transfer_function(int aligned,
                             int move_references,
                             PyArrayMethod_StridedLoop **out_stransfer,
                             NpyAuxData **out_transferdata,
-                            int *out_needs_api)
+                            NPY_ARRAYMETHOD_FLAGS *out_flags)
 {
     _subarray_broadcast_data *data;
     npy_intp structsize, loop_index, run, run_size,
@@ -1946,7 +1952,7 @@ get_subarray_broadcast_transfer_function(int aligned,
                     src_dtype, dst_dtype,
                     0,
                     &data->wrapped,
-                    out_needs_api) != NPY_SUCCEED) {
+                    out_flags) != NPY_SUCCEED) {
         NPY_AUXDATA_FREE((NpyAuxData *)data);
         return NPY_FAIL;
     }
@@ -1958,7 +1964,7 @@ get_subarray_broadcast_transfer_function(int aligned,
                         src_dtype, NULL,
                         1,
                         &data->decref_src,
-                        out_needs_api) != NPY_SUCCEED) {
+                        out_flags) != NPY_SUCCEED) {
             NPY_AUXDATA_FREE((NpyAuxData *)data);
             return NPY_FAIL;
         }
@@ -1971,7 +1977,7 @@ get_subarray_broadcast_transfer_function(int aligned,
                         dst_dtype, NULL,
                         1,
                         &data->decref_dst,
-                        out_needs_api) != NPY_SUCCEED) {
+                        out_flags) != NPY_SUCCEED) {
             NPY_AUXDATA_FREE((NpyAuxData *)data);
             return NPY_FAIL;
         }
@@ -2087,7 +2093,7 @@ get_subarray_transfer_function(int aligned,
                             int move_references,
                             PyArrayMethod_StridedLoop **out_stransfer,
                             NpyAuxData **out_transferdata,
-                            int *out_needs_api)
+                            NPY_ARRAYMETHOD_FLAGS *out_flags)
 {
     PyArray_Dims src_shape = {NULL, -1}, dst_shape = {NULL, -1};
     npy_intp src_size = 1, dst_size = 1;
@@ -2132,7 +2138,7 @@ get_subarray_transfer_function(int aligned,
                         move_references,
                         src_size,
                         out_stransfer, out_transferdata,
-                        out_needs_api);
+                        out_flags);
     }
     /* Copy the src value to all the dst values */
     else if (src_size == 1) {
@@ -2145,7 +2151,7 @@ get_subarray_transfer_function(int aligned,
                 move_references,
                 dst_size,
                 out_stransfer, out_transferdata,
-                out_needs_api);
+                out_flags);
     }
     /*
      * Copy the subarray with broadcasting, truncating, and zero-padding
@@ -2159,7 +2165,7 @@ get_subarray_transfer_function(int aligned,
                         src_shape, dst_shape,
                         move_references,
                         out_stransfer, out_transferdata,
-                        out_needs_api);
+                        out_flags);
 
         npy_free_cache_dim_obj(src_shape);
         npy_free_cache_dim_obj(dst_shape);
@@ -2277,7 +2283,7 @@ get_fields_transfer_function(int NPY_UNUSED(aligned),
                             int move_references,
                             PyArrayMethod_StridedLoop **out_stransfer,
                             NpyAuxData **out_transferdata,
-                            int *out_needs_api)
+                            NPY_ARRAYMETHOD_FLAGS *out_flags)
 {
     PyObject *key, *tup, *title;
     PyArray_Descr *src_fld_dtype, *dst_fld_dtype;
@@ -2308,6 +2314,7 @@ get_fields_transfer_function(int NPY_UNUSED(aligned),
         data->base.clone = &_field_transfer_data_clone;
         data->field_count = 0;
 
+        *out_flags = PyArrayMethod_MINIMAL_FLAGS;
         for (i = 0; i < field_count; ++i) {
             key = PyTuple_GET_ITEM(dst_dtype->names, i);
             tup = PyDict_GetItem(dst_dtype->fields, key);
@@ -2316,15 +2323,17 @@ get_fields_transfer_function(int NPY_UNUSED(aligned),
                 PyMem_Free(data);
                 return NPY_FAIL;
             }
+            NPY_ARRAYMETHOD_FLAGS field_flags;
             if (PyArray_GetDTypeTransferFunction(0,
                                     src_stride, dst_stride,
                                     src_dtype, dst_fld_dtype,
                                     0,
                                     &data->fields[i].info,
-                                    out_needs_api) != NPY_SUCCEED) {
+                                    &field_flags) != NPY_SUCCEED) {
                 NPY_AUXDATA_FREE((NpyAuxData *)data);
                 return NPY_FAIL;
             }
+            *out_flags = PyArrayMethod_COMBINED_FLAGS(*out_flags, field_flags);
             data->fields[i].src_offset = 0;
             data->fields[i].dst_offset = dst_offset;
             data->field_count++;
@@ -2336,11 +2345,12 @@ get_fields_transfer_function(int NPY_UNUSED(aligned),
          * input, the second one (normally output) just does not matter here.
          */
         if (move_references && PyDataType_REFCHK(src_dtype)) {
+            *out_flags |= NPY_METH_REQUIRES_PYAPI;
             if (get_decref_transfer_function(0,
                                     src_stride,
                                     src_dtype,
                                     &data->fields[field_count].info,
-                                    out_needs_api) != NPY_SUCCEED) {
+                                    NULL) != NPY_SUCCEED) {
                 NPY_AUXDATA_FREE((NpyAuxData *)data);
                 return NPY_FAIL;
             }
@@ -2388,7 +2398,7 @@ get_fields_transfer_function(int NPY_UNUSED(aligned),
                                              src_fld_dtype, dst_dtype,
                                              move_references,
                                              &data->fields[0].info,
-                                             out_needs_api) != NPY_SUCCEED) {
+                                             out_flags) != NPY_SUCCEED) {
             PyMem_Free(data);
             return NPY_FAIL;
         }
@@ -2423,6 +2433,7 @@ get_fields_transfer_function(int NPY_UNUSED(aligned),
     data->base.clone = &_field_transfer_data_clone;
     data->field_count = 0;
 
+    *out_flags = PyArrayMethod_MINIMAL_FLAGS;
     /* set up the transfer function for each field */
     for (i = 0; i < field_count; ++i) {
         key = PyTuple_GET_ITEM(dst_dtype->names, i);
@@ -2440,15 +2451,17 @@ get_fields_transfer_function(int NPY_UNUSED(aligned),
             return NPY_FAIL;
         }
 
+        NPY_ARRAYMETHOD_FLAGS field_flags;
         if (PyArray_GetDTypeTransferFunction(0,
                                              src_stride, dst_stride,
                                              src_fld_dtype, dst_fld_dtype,
                                              move_references,
                                              &data->fields[i].info,
-                                             out_needs_api) != NPY_SUCCEED) {
+                                             &field_flags) != NPY_SUCCEED) {
             NPY_AUXDATA_FREE((NpyAuxData *)data);
             return NPY_FAIL;
         }
+        *out_flags = PyArrayMethod_COMBINED_FLAGS(*out_flags, field_flags);
         data->fields[i].src_offset = src_offset;
         data->fields[i].dst_offset = dst_offset;
         data->field_count++;
@@ -2748,11 +2761,12 @@ get_decref_transfer_function(int aligned,
         src_size = PyArray_MultiplyList(src_shape.ptr, src_shape.len);
         npy_free_cache_dim_obj(src_shape);
 
+        NPY_ARRAYMETHOD_FLAGS ignored_flags;
         if (get_n_to_n_transfer_function(aligned,
                 src_stride, 0,
                 src_dtype->subarray->base, NULL, 1, src_size,
                 &cast_info->func, &cast_info->auxdata,
-                out_needs_api) != NPY_SUCCEED) {
+                &ignored_flags) != NPY_SUCCEED) {
             return NPY_FAIL;
         }
 
@@ -2937,9 +2951,11 @@ _strided_to_strided_multistep_cast(
 
         if (castdata->from.func != NULL) {
             npy_intp out_stride = castdata->from.descriptors[1]->elsize;
+            char *const data[2] = {src, castdata->from_buffer};
+            npy_intp strides[2] = {src_stride, out_stride};
             if (castdata->from.func(&castdata->from.context,
-                    (char *[2]){src, castdata->from_buffer}, &block_size,
-                    (npy_intp [2]){src_stride, out_stride},
+                    data, &block_size,
+                    strides,
                     castdata->from.auxdata) != 0) {
                 /* TODO: Internal buffer may require cleanup on error. */
                 return -1;
@@ -2961,18 +2977,22 @@ _strided_to_strided_multistep_cast(
             main_dst_stride = dst_stride;
         }
 
+        char *const data[2] = {main_src, main_dst};
+        npy_intp strides[2] = {main_src_stride, main_dst_stride};
         if (castdata->main.func(&castdata->main.context,
-                (char *[2]){main_src, main_dst}, &block_size,
-                (npy_intp [2]){main_src_stride, main_dst_stride},
+                data, &block_size,
+                strides,
                 castdata->main.auxdata) != 0) {
             /* TODO: Internal buffer may require cleanup on error. */
             return -1;
         }
 
         if (castdata->to.func != NULL) {
+            char *const data[2] = {main_dst, dst};
+            npy_intp strides[2] = {main_dst_stride, dst_stride};
             if (castdata->to.func(&castdata->to.context,
-                    (char *[2]){main_dst, dst}, &block_size,
-                    (npy_intp [2]){main_dst_stride, dst_stride},
+                    data, &block_size,
+                    strides,
                     castdata->to.auxdata) != 0) {
                 return -1;
             }
@@ -2991,7 +3011,8 @@ _strided_to_strided_multistep_cast(
  * transferfunction and transferdata.
  */
 static NPY_INLINE int
-init_cast_info(NPY_cast_info *cast_info, NPY_CASTING *casting,
+init_cast_info(
+        NPY_cast_info *cast_info, NPY_CASTING *casting, npy_intp *view_offset,
         PyArray_Descr *src_dtype, PyArray_Descr *dst_dtype, int main_step)
 {
     PyObject *meth = PyArray_GetCastingImpl(
@@ -3016,14 +3037,15 @@ init_cast_info(NPY_cast_info *cast_info, NPY_CASTING *casting,
     PyArray_Descr *in_descr[2] = {src_dtype, dst_dtype};
 
     *casting = cast_info->context.method->resolve_descriptors(
-            cast_info->context.method, dtypes, in_descr, cast_info->descriptors);
+            cast_info->context.method, dtypes,
+            in_descr, cast_info->descriptors, view_offset);
     if (NPY_UNLIKELY(*casting < 0)) {
         if (!PyErr_Occurred()) {
             PyErr_Format(PyExc_TypeError,
                     "Cannot cast array data from %R to %R.", src_dtype, dst_dtype);
-            Py_DECREF(meth);
-            return -1;
         }
+        Py_DECREF(meth);
+        return -1;
     }
     assert(PyArray_DescrCheck(cast_info->descriptors[0]));
     assert(PyArray_DescrCheck(cast_info->descriptors[1]));
@@ -3071,6 +3093,9 @@ _clear_cast_info_after_get_loop_failure(NPY_cast_info *cast_info)
  * transfer function from the each casting implementation (ArrayMethod).
  * May set the transfer function to NULL when the cast can be achieved using
  * a view.
+ * TODO: Expand the view functionality for general offsets, not just 0:
+ *       Partial casts could be skipped also for `view_offset != 0`.
+ *
  * The `out_needs_api` flag must be initialized.
  *
  * NOTE: In theory casting errors here could be slightly misleading in case
@@ -3093,7 +3118,7 @@ define_cast_for_descrs(
         npy_intp src_stride, npy_intp dst_stride,
         PyArray_Descr *src_dtype, PyArray_Descr *dst_dtype,
         int move_references,
-        NPY_cast_info *cast_info, int *out_needs_api)
+        NPY_cast_info *cast_info, NPY_ARRAYMETHOD_FLAGS *out_flags)
 {
     /* Storage for all cast info in case multi-step casting is necessary */
     _multistep_castdata castdata;
@@ -3101,9 +3126,13 @@ define_cast_for_descrs(
     castdata.main.func = NULL;
     castdata.to.func = NULL;
     castdata.from.func = NULL;
+    /* `view_offset` passed to `init_cast_info` but unused for the main cast */
+    npy_intp view_offset = NPY_MIN_INTP;
     NPY_CASTING casting = -1;
+    *out_flags = PyArrayMethod_MINIMAL_FLAGS;
 
-    if (init_cast_info(cast_info, &casting, src_dtype, dst_dtype, 1) < 0) {
+    if (init_cast_info(
+            cast_info, &casting, &view_offset, src_dtype, dst_dtype, 1) < 0) {
         return -1;
     }
 
@@ -3123,17 +3152,18 @@ define_cast_for_descrs(
      */
     if (NPY_UNLIKELY(src_dtype != cast_info->descriptors[0] || must_wrap)) {
         NPY_CASTING from_casting = -1;
+        npy_intp from_view_offset = NPY_MIN_INTP;
         /* Cast function may not support the input, wrap if necessary */
         if (init_cast_info(
-                &castdata.from, &from_casting,
+                &castdata.from, &from_casting, &from_view_offset,
                 src_dtype, cast_info->descriptors[0], 0) < 0) {
             goto fail;
         }
         casting = PyArray_MinCastSafety(casting, from_casting);
 
         /* Prepare the actual cast (if necessary): */
-        if (from_casting & _NPY_CAST_IS_VIEW && !must_wrap) {
-            /* This step is not necessary and can be skipped. */
+        if (from_view_offset == 0 && !must_wrap) {
+            /* This step is not necessary and can be skipped */
             castdata.from.func = &_dec_src_ref_nop;  /* avoid NULL */
             NPY_cast_info_xfree(&castdata.from);
         }
@@ -3150,7 +3180,7 @@ define_cast_for_descrs(
             }
             assert(castdata.from.func != NULL);
 
-            *out_needs_api |= (flags & NPY_METH_REQUIRES_PYAPI) != 0;
+            *out_flags = PyArrayMethod_COMBINED_FLAGS(*out_flags, flags);
             /* The main cast now uses a buffered input: */
             src_stride = strides[1];
             move_references = 1;  /* main cast has to clear the buffer */
@@ -3161,16 +3191,17 @@ define_cast_for_descrs(
      */
     if (NPY_UNLIKELY(dst_dtype != cast_info->descriptors[1] || must_wrap)) {
         NPY_CASTING to_casting = -1;
+        npy_intp to_view_offset = NPY_MIN_INTP;
         /* Cast function may not support the output, wrap if necessary */
         if (init_cast_info(
-                &castdata.to, &to_casting,
+                &castdata.to, &to_casting, &to_view_offset,
                 cast_info->descriptors[1], dst_dtype,  0) < 0) {
             goto fail;
         }
         casting = PyArray_MinCastSafety(casting, to_casting);
 
         /* Prepare the actual cast (if necessary): */
-        if (to_casting & _NPY_CAST_IS_VIEW && !must_wrap) {
+        if (to_view_offset == 0 && !must_wrap) {
             /* This step is not necessary and can be skipped. */
             castdata.to.func = &_dec_src_ref_nop;  /* avoid NULL */
             NPY_cast_info_xfree(&castdata.to);
@@ -3188,7 +3219,7 @@ define_cast_for_descrs(
             }
             assert(castdata.to.func != NULL);
 
-            *out_needs_api |= (flags & NPY_METH_REQUIRES_PYAPI) != 0;
+            *out_flags = PyArrayMethod_COMBINED_FLAGS(*out_flags, flags);
             /* The main cast now uses a buffered input: */
             dst_stride = strides[0];
             if (castdata.from.func != NULL) {
@@ -3209,7 +3240,7 @@ define_cast_for_descrs(
         goto fail;
     }
 
-    *out_needs_api |= (flags & NPY_METH_REQUIRES_PYAPI) != 0;
+    *out_flags = PyArrayMethod_COMBINED_FLAGS(*out_flags, flags);
 
     if (castdata.from.func == NULL && castdata.to.func == NULL) {
         /* Most of the time, there will be only one step required. */
@@ -3246,7 +3277,7 @@ PyArray_GetDTypeTransferFunction(int aligned,
                             PyArray_Descr *src_dtype, PyArray_Descr *dst_dtype,
                             int move_references,
                             NPY_cast_info *cast_info,
-                            int *out_needs_api)
+                            NPY_ARRAYMETHOD_FLAGS *out_flags)
 {
     assert(src_dtype != NULL);
 
@@ -3261,17 +3292,24 @@ PyArray_GetDTypeTransferFunction(int aligned,
      */
     if (dst_dtype == NULL) {
         assert(move_references);
-        return get_decref_transfer_function(aligned,
+        int needs_api = 0;
+        int res = get_decref_transfer_function(aligned,
                                 src_dtype->elsize,
                                 src_dtype,
                                 cast_info,
-                                out_needs_api);
+                                &needs_api);
+        /* decref'ing never creates floating point errors, so just ignore it */
+        *out_flags = PyArrayMethod_MINIMAL_FLAGS;
+        if (needs_api) {
+            *out_flags |= NPY_METH_REQUIRES_PYAPI;
+        }
+        return res;
     }
 
     if (define_cast_for_descrs(aligned,
             src_stride, dst_stride,
             src_dtype, dst_dtype, move_references,
-            cast_info, out_needs_api) < 0) {
+            cast_info, out_flags) < 0) {
         return NPY_FAIL;
     }
 
@@ -3343,21 +3381,29 @@ wrap_aligned_transferfunction(
      *       have an explicit implementation instead if we want performance.
      */
     if (must_wrap || src_wrapped_dtype != src_dtype) {
+        NPY_ARRAYMETHOD_FLAGS flags;
         if (PyArray_GetDTypeTransferFunction(aligned,
                 src_stride, castdata.main.descriptors[0]->elsize,
                 src_dtype, castdata.main.descriptors[0], 0,
-                &castdata.from, out_needs_api) != NPY_SUCCEED) {
+                &castdata.from, &flags) != NPY_SUCCEED) {
             goto fail;
         }
+        if (flags & NPY_METH_REQUIRES_PYAPI) {
+            *out_needs_api = 1;
+        }
     }
     if (must_wrap || dst_wrapped_dtype != dst_dtype) {
+        NPY_ARRAYMETHOD_FLAGS flags;
         if (PyArray_GetDTypeTransferFunction(aligned,
                 castdata.main.descriptors[1]->elsize, dst_stride,
                 castdata.main.descriptors[1], dst_dtype,
                 1,  /* clear buffer if it includes references */
-                &castdata.to, out_needs_api) != NPY_SUCCEED) {
+                &castdata.to, &flags) != NPY_SUCCEED) {
             goto fail;
         }
+        if (flags & NPY_METH_REQUIRES_PYAPI) {
+            *out_needs_api = 1;
+        }
     }
 
     *out_transferdata = _multistep_cast_auxdata_clone_int(&castdata, 1);
@@ -3383,8 +3429,8 @@ wrap_aligned_transferfunction(
  * For casts between two dtypes with the same type (within DType casts)
  * it also wraps the `copyswapn` function.
  *
- * This function is called called from `ArrayMethod.get_loop()` when a
- * specialized cast function is missing.
+ * This function is called from `ArrayMethod.get_loop()` when a specialized
+ * cast function is missing.
  *
  * In general, the legacy cast functions do not support unaligned access,
  * so an ArrayMethod using this must signal that.  In a few places we do
@@ -3447,11 +3493,11 @@ get_wrapped_legacy_cast_function(int aligned,
      * If we are here, use the legacy code to wrap the above cast (which
      * does not support unaligned data) into copyswapn.
      */
-    PyArray_Descr *src_wrapped_dtype = ensure_dtype_nbo(src_dtype);
+    PyArray_Descr *src_wrapped_dtype = NPY_DT_CALL_ensure_canonical(src_dtype);
     if (src_wrapped_dtype == NULL) {
         goto fail;
     }
-    PyArray_Descr *dst_wrapped_dtype = ensure_dtype_nbo(dst_dtype);
+    PyArray_Descr *dst_wrapped_dtype = NPY_DT_CALL_ensure_canonical(dst_dtype);
     if (dst_wrapped_dtype == NULL) {
         goto fail;
     }
@@ -3482,7 +3528,7 @@ PyArray_GetMaskedDTypeTransferFunction(int aligned,
                             PyArray_Descr *mask_dtype,
                             int move_references,
                             NPY_cast_info *cast_info,
-                            int *out_needs_api)
+                            NPY_ARRAYMETHOD_FLAGS *out_flags)
 {
     NPY_cast_info_init(cast_info);
 
@@ -3510,18 +3556,19 @@ PyArray_GetMaskedDTypeTransferFunction(int aligned,
                                 src_dtype, dst_dtype,
                                 move_references,
                                 &data->wrapped,
-                                out_needs_api) != NPY_SUCCEED) {
+                                out_flags) != NPY_SUCCEED) {
         PyMem_Free(data);
         return NPY_FAIL;
     }
 
     /* If the src object will need a DECREF, get a function to handle that */
     if (move_references && PyDataType_REFCHK(src_dtype)) {
+        *out_flags |= NPY_METH_REQUIRES_PYAPI;
         if (get_decref_transfer_function(aligned,
                             src_stride,
                             src_dtype,
                             &data->decref_src,
-                            out_needs_api) != NPY_SUCCEED) {
+                            NULL) != NPY_SUCCEED) {
             NPY_AUXDATA_FREE((NpyAuxData *)data);
             return NPY_FAIL;
         }
@@ -3552,7 +3599,7 @@ PyArray_CastRawArrays(npy_intp count,
                       PyArray_Descr *src_dtype, PyArray_Descr *dst_dtype,
                       int move_references)
 {
-    int aligned = 1, needs_api = 0;
+    int aligned;
 
     /* Make sure the copy is reasonable */
     if (dst_stride == 0 && count > 1) {
@@ -3576,15 +3623,20 @@ PyArray_CastRawArrays(npy_intp count,
 
     /* Get the function to do the casting */
     NPY_cast_info cast_info;
+    NPY_ARRAYMETHOD_FLAGS flags;
     if (PyArray_GetDTypeTransferFunction(aligned,
                         src_stride, dst_stride,
                         src_dtype, dst_dtype,
                         move_references,
                         &cast_info,
-                        &needs_api) != NPY_SUCCEED) {
+                        &flags) != NPY_SUCCEED) {
         return NPY_FAIL;
     }
 
+    if (!(flags & NPY_METH_NO_FLOATINGPOINT_ERRORS)) {
+        npy_clear_floatstatus_barrier((char*)&cast_info);
+    }
+
     /* Cast */
     char *args[2] = {src, dst};
     npy_intp strides[2] = {src_stride, dst_stride};
@@ -3593,8 +3645,16 @@ PyArray_CastRawArrays(npy_intp count,
     /* Cleanup */
     NPY_cast_info_xfree(&cast_info);
 
-    /* If needs_api was set to 1, it may have raised a Python exception */
-    return (needs_api && PyErr_Occurred()) ? NPY_FAIL : NPY_SUCCEED;
+    if (flags & NPY_METH_REQUIRES_PYAPI && PyErr_Occurred()) {
+        return NPY_FAIL;
+    }
+    if (!(flags & NPY_METH_NO_FLOATINGPOINT_ERRORS)) {
+        int fpes = npy_get_floatstatus_barrier(*args);
+        if (fpes && PyUFunc_GiveFloatingpointErrors("cast", fpes) < 0) {
+            return NPY_FAIL;
+        }
+    }
+    return NPY_SUCCEED;
 }
 
 /*
diff --git a/numpy/core/src/multiarray/dtype_transfer.h b/numpy/core/src/multiarray/dtype_transfer.h
index c7e0a029f990..9ae332e385b1 100644
--- a/numpy/core/src/multiarray/dtype_transfer.h
+++ b/numpy/core/src/multiarray/dtype_transfer.h
@@ -132,7 +132,7 @@ NPY_NO_EXPORT int
 any_to_object_get_loop(
         PyArrayMethod_Context *context,
         int aligned, int move_references,
-        npy_intp *strides,
+        const npy_intp *strides,
         PyArrayMethod_StridedLoop **out_loop,
         NpyAuxData **out_transferdata,
         NPY_ARRAYMETHOD_FLAGS *flags);
@@ -141,7 +141,7 @@ NPY_NO_EXPORT int
 object_to_any_get_loop(
         PyArrayMethod_Context *context,
         int NPY_UNUSED(aligned), int move_references,
-        npy_intp *NPY_UNUSED(strides),
+        const npy_intp *NPY_UNUSED(strides),
         PyArrayMethod_StridedLoop **out_loop,
         NpyAuxData **out_transferdata,
         NPY_ARRAYMETHOD_FLAGS *flags);
diff --git a/numpy/core/src/multiarray/dtypemeta.c b/numpy/core/src/multiarray/dtypemeta.c
index cd489d5e7c9d..b5226729150d 100644
--- a/numpy/core/src/multiarray/dtypemeta.c
+++ b/numpy/core/src/multiarray/dtypemeta.c
@@ -12,6 +12,7 @@
 
 #include "common.h"
 #include "dtypemeta.h"
+#include "descriptor.h"
 #include "_datetime.h"
 #include "array_coercion.h"
 #include "scalartypes.h"
@@ -153,6 +154,9 @@ string_discover_descr_from_pyobject(
                     "string to large to store inside array.");
         }
         PyArray_Descr *res = PyArray_DescrNewFromType(cls->type_num);
+        if (res == NULL) {
+            return NULL;
+        }
         res->elsize = (int)itemsize;
         return res;
     }
@@ -171,10 +175,15 @@ void_discover_descr_from_pyobject(
     }
     if (PyBytes_Check(obj)) {
         PyArray_Descr *descr = PyArray_DescrNewFromType(NPY_VOID);
+        if (descr == NULL) {
+            return NULL;
+        }
         Py_ssize_t itemsize = PyBytes_Size(obj);
         if (itemsize > NPY_MAX_INT) {
             PyErr_SetString(PyExc_TypeError,
                     "byte-like to large to store inside array.");
+            Py_DECREF(descr);
+            return NULL;
         }
         descr->elsize = (int)itemsize;
         return descr;
@@ -214,6 +223,23 @@ nonparametric_default_descr(PyArray_DTypeMeta *cls)
 }
 
 
+/*
+ * For most builtin (and legacy) dtypes, the canonical property means to
+ * ensure native byte-order.  (We do not care about metadata here.)
+ */
+static PyArray_Descr *
+ensure_native_byteorder(PyArray_Descr *descr)
+{
+    if (PyArray_ISNBO(descr->byteorder)) {
+        Py_INCREF(descr);
+        return descr;
+    }
+    else {
+        return PyArray_DescrNewByteorder(descr, NPY_NATIVE);
+    }
+}
+
+
 /* Ensure a copy of the singleton (just in case we do adapt it somewhere) */
 static PyArray_Descr *
 datetime_and_timedelta_default_descr(PyArray_DTypeMeta *cls)
@@ -257,10 +283,117 @@ static PyArray_Descr *
 string_unicode_common_instance(PyArray_Descr *descr1, PyArray_Descr *descr2)
 {
     if (descr1->elsize >= descr2->elsize) {
-        return ensure_dtype_nbo(descr1);
+        return NPY_DT_CALL_ensure_canonical(descr1);
     }
     else {
-        return ensure_dtype_nbo(descr2);
+        return NPY_DT_CALL_ensure_canonical(descr2);
+    }
+}
+
+
+static PyArray_Descr *
+void_ensure_canonical(PyArray_Descr *self)
+{
+    if (self->subarray != NULL) {
+        PyArray_Descr *new_base = NPY_DT_CALL_ensure_canonical(
+                self->subarray->base);
+        if (new_base == NULL) {
+            return NULL;
+        }
+        if (new_base == self->subarray->base) {
+            /* just return self, no need to modify */
+            Py_DECREF(new_base);
+            Py_INCREF(self);
+            return self;
+        }
+        PyArray_Descr *new = PyArray_DescrNew(self);
+        if (new == NULL) {
+            return NULL;
+        }
+        Py_SETREF(new->subarray->base, new_base);
+        return new;
+    }
+    else if (self->names != NULL) {
+        /*
+         * This branch is fairly complex, since it needs to build a new
+         * descriptor that is in canonical form.  This means that the new
+         * descriptor should be an aligned struct if the old one was, and
+         * otherwise it should be an unaligned struct.
+         * Any unnecessary empty space is stripped from the struct.
+         *
+         * TODO: In principle we could/should try to provide the identity when
+         *       no change is necessary. (Simple if we add a flag.)
+         */
+        Py_ssize_t field_num = PyTuple_GET_SIZE(self->names);
+
+        PyArray_Descr *new = PyArray_DescrNew(self);
+        if (new == NULL) {
+            return NULL;
+        }
+        Py_SETREF(new->fields, PyDict_New());
+        if (new->fields == NULL) {
+            Py_DECREF(new);
+            return NULL;
+        }
+        int aligned = PyDataType_FLAGCHK(new, NPY_ALIGNED_STRUCT);
+        new->flags = new->flags & ~NPY_FROM_FIELDS;
+        new->flags |= NPY_NEEDS_PYAPI;  /* always needed for field access */
+        int totalsize = 0;
+        int maxalign = 1;
+        for (Py_ssize_t i = 0; i < field_num; i++) {
+            PyObject *name = PyTuple_GET_ITEM(self->names, i);
+            PyObject *tuple = PyDict_GetItem(self->fields, name);
+            PyObject *new_tuple = PyTuple_New(PyTuple_GET_SIZE(tuple));
+            PyArray_Descr *field_descr = NPY_DT_CALL_ensure_canonical(
+                    (PyArray_Descr *)PyTuple_GET_ITEM(tuple, 0));
+            if (field_descr == NULL) {
+                Py_DECREF(new_tuple);
+                Py_DECREF(new);
+                return NULL;
+            }
+            new->flags |= field_descr->flags & NPY_FROM_FIELDS;
+            PyTuple_SET_ITEM(new_tuple, 0, (PyObject *)field_descr);
+
+            if (aligned) {
+                totalsize = NPY_NEXT_ALIGNED_OFFSET(
+                        totalsize, field_descr->alignment);
+                maxalign = PyArray_MAX(maxalign, field_descr->alignment);
+            }
+            PyObject *offset_obj = PyLong_FromLong(totalsize);
+            if (offset_obj == NULL) {
+                Py_DECREF(new_tuple);
+                Py_DECREF(new);
+                return NULL;
+            }
+            PyTuple_SET_ITEM(new_tuple, 1, (PyObject *)offset_obj);
+            if (PyTuple_GET_SIZE(tuple) == 3) {
+                /* Be sure to set all items in the tuple before using it */
+                PyObject *title = PyTuple_GET_ITEM(tuple, 2);
+                Py_INCREF(title);
+                PyTuple_SET_ITEM(new_tuple, 2, title);
+                if (PyDict_SetItem(new->fields, title, new_tuple) < 0) {
+                    Py_DECREF(new_tuple);
+                    Py_DECREF(new);
+                    return NULL;
+                }
+            }
+            if (PyDict_SetItem(new->fields, name, new_tuple) < 0) {
+                Py_DECREF(new_tuple);
+                Py_DECREF(new);
+                return NULL;
+            }
+            Py_DECREF(new_tuple);  /* Reference now owned by new->fields */
+            totalsize += field_descr->elsize;
+        }
+        totalsize = NPY_NEXT_ALIGNED_OFFSET(totalsize, maxalign);
+        new->elsize = totalsize;
+        new->alignment = maxalign;
+        return new;
+    }
+    else {
+        /* unstructured voids are always canonical. */
+        Py_INCREF(self);
+        return self;
     }
 }
 
@@ -268,26 +401,81 @@ string_unicode_common_instance(PyArray_Descr *descr1, PyArray_Descr *descr2)
 static PyArray_Descr *
 void_common_instance(PyArray_Descr *descr1, PyArray_Descr *descr2)
 {
-    /*
-     * We currently do not support promotion of void types unless they
-     * are equivalent.
-     */
-    if (!PyArray_CanCastTypeTo(descr1, descr2, NPY_EQUIV_CASTING)) {
-        if (descr1->subarray == NULL && descr1->names == NULL &&
-                descr2->subarray == NULL && descr2->names == NULL) {
+    if (descr1->subarray == NULL && descr1->names == NULL &&
+            descr2->subarray == NULL && descr2->names == NULL) {
+        if (descr1->elsize != descr2->elsize) {
             PyErr_SetString(PyExc_TypeError,
                     "Invalid type promotion with void datatypes of different "
                     "lengths. Use the `np.bytes_` datatype instead to pad the "
                     "shorter value with trailing zero bytes.");
+            return NULL;
         }
-        else {
+        Py_INCREF(descr1);
+        return descr1;
+    }
+
+    if (descr1->names != NULL && descr2->names != NULL) {
+        /* If both have fields promoting individual fields may be possible */
+        static PyObject *promote_fields_func = NULL;
+        npy_cache_import("numpy.core._internal", "_promote_fields",
+                &promote_fields_func);
+        if (promote_fields_func == NULL) {
+            return NULL;
+        }
+        PyObject *result = PyObject_CallFunctionObjArgs(promote_fields_func,
+                descr1, descr2, NULL);
+        if (result == NULL) {
+            return NULL;
+        }
+        if (!PyObject_TypeCheck(result, Py_TYPE(descr1))) {
+            PyErr_SetString(PyExc_RuntimeError,
+                    "Internal NumPy error: `_promote_fields` did not return "
+                    "a valid descriptor object.");
+            Py_DECREF(result);
+            return NULL;
+        }
+        return (PyArray_Descr *)result;
+    }
+    else if (descr1->subarray != NULL && descr2->subarray != NULL) {
+        int cmp = PyObject_RichCompareBool(
+                descr1->subarray->shape, descr2->subarray->shape, Py_EQ);
+        if (error_converting(cmp)) {
+            return NULL;
+        }
+        if (!cmp) {
             PyErr_SetString(PyExc_TypeError,
-                    "invalid type promotion with structured datatype(s).");
+                    "invalid type promotion with subarray datatypes "
+                    "(shape mismatch).");
+            return NULL;
         }
-        return NULL;
+        PyArray_Descr *new_base = PyArray_PromoteTypes(
+                descr1->subarray->base, descr2->subarray->base);
+        if (new_base == NULL) {
+            return NULL;
+        }
+        /*
+         * If it is the same dtype and the container did not change, we might
+         * as well preserve identity and metadata.  This could probably be
+         * changed.
+         */
+        if (descr1 == descr2 && new_base == descr1->subarray->base) {
+            Py_DECREF(new_base);
+            Py_INCREF(descr1);
+            return descr1;
+        }
+
+        PyArray_Descr *new_descr = PyArray_DescrNew(descr1);
+        if (new_descr == NULL) {
+            Py_DECREF(new_base);
+            return NULL;
+        }
+        Py_SETREF(new_descr->subarray->base, new_base);
+        return new_descr;
     }
-    Py_INCREF(descr1);
-    return descr1;
+
+    PyErr_SetString(PyExc_TypeError,
+            "invalid type promotion with structured datatype(s).");
+    return NULL;
 }
 
 NPY_NO_EXPORT int
@@ -425,6 +613,7 @@ string_unicode_common_dtype(PyArray_DTypeMeta *cls, PyArray_DTypeMeta *other)
     return cls;
 }
 
+
 static PyArray_DTypeMeta *
 datetime_common_dtype(PyArray_DTypeMeta *cls, PyArray_DTypeMeta *other)
 {
@@ -613,6 +802,7 @@ dtypemeta_wrap_legacy_descriptor(PyArray_Descr *descr)
     dt_slots->is_known_scalar_type = python_builtins_are_known_scalar_types;
     dt_slots->common_dtype = default_builtin_common_dtype;
     dt_slots->common_instance = NULL;
+    dt_slots->ensure_canonical = ensure_native_byteorder;
 
     if (PyTypeNum_ISSIGNED(dtype_class->type_num)) {
         /* Convert our scalars (raise on too large unsigned and NaN, etc.) */
@@ -644,6 +834,7 @@ dtypemeta_wrap_legacy_descriptor(PyArray_Descr *descr)
             dt_slots->discover_descr_from_pyobject = (
                     void_discover_descr_from_pyobject);
             dt_slots->common_instance = void_common_instance;
+            dt_slots->ensure_canonical = void_ensure_canonical;
         }
         else {
             dt_slots->default_descr = string_and_unicode_default_descr;
@@ -702,12 +893,12 @@ NPY_NO_EXPORT PyTypeObject PyArrayDTypeMeta_Type = {
     /* Types are garbage collected (see dtypemeta_is_gc documentation) */
     .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,
     .tp_doc = "Preliminary NumPy API: The Type of NumPy DTypes (metaclass)",
-    .tp_getset = dtypemeta_getset,
+    .tp_traverse = (traverseproc)dtypemeta_traverse,
     .tp_members = dtypemeta_members,
+    .tp_getset = dtypemeta_getset,
     .tp_base = NULL,  /* set to PyType_Type at import time */
-    .tp_alloc = dtypemeta_alloc,
     .tp_init = (initproc)dtypemeta_init,
+    .tp_alloc = dtypemeta_alloc,
     .tp_new = dtypemeta_new,
     .tp_is_gc = dtypemeta_is_gc,
-    .tp_traverse = (traverseproc)dtypemeta_traverse,
 };
diff --git a/numpy/core/src/multiarray/dtypemeta.h b/numpy/core/src/multiarray/dtypemeta.h
index 2a61fe39de37..15318f040042 100644
--- a/numpy/core/src/multiarray/dtypemeta.h
+++ b/numpy/core/src/multiarray/dtypemeta.h
@@ -1,6 +1,9 @@
 #ifndef NUMPY_CORE_SRC_MULTIARRAY_DTYPEMETA_H_
 #define NUMPY_CORE_SRC_MULTIARRAY_DTYPEMETA_H_
 
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 /* DType flags, currently private, since we may just expose functions */
 #define NPY_DT_LEGACY 1 << 0
@@ -25,6 +28,7 @@ typedef PyArray_DTypeMeta *(common_dtype_function)(
         PyArray_DTypeMeta *dtype1, PyArray_DTypeMeta *dtype2);
 typedef PyArray_Descr *(common_instance_function)(
         PyArray_Descr *dtype1, PyArray_Descr *dtype2);
+typedef PyArray_Descr *(ensure_canonical_function)(PyArray_Descr *dtype);
 
 /*
  * TODO: These two functions are currently only used for experimental DType
@@ -44,9 +48,9 @@ typedef struct {
     default_descr_function *default_descr;
     common_dtype_function *common_dtype;
     common_instance_function *common_instance;
+    ensure_canonical_function *ensure_canonical;
     /*
      * Currently only used for experimental user DTypes.
-     * Typing as `void *` until NumPy itself uses these (directly).
      */
     setitemfunction *setitem;
     getitemfunction *getitem;
@@ -93,11 +97,14 @@ typedef struct {
     NPY_DT_SLOTS(dtype)->default_descr(dtype)
 #define NPY_DT_CALL_common_dtype(dtype, other)  \
     NPY_DT_SLOTS(dtype)->common_dtype(dtype, other)
+#define NPY_DT_CALL_ensure_canonical(descr)  \
+    NPY_DT_SLOTS(NPY_DTYPE(descr))->ensure_canonical(descr)
 #define NPY_DT_CALL_getitem(descr, data_ptr)  \
     NPY_DT_SLOTS(NPY_DTYPE(descr))->getitem(descr, data_ptr)
 #define NPY_DT_CALL_setitem(descr, value, data_ptr)  \
     NPY_DT_SLOTS(NPY_DTYPE(descr))->setitem(descr, value, data_ptr)
 
+
 /*
  * This function will hopefully be phased out or replaced, but was convenient
  * for incremental implementation of new DTypes based on DTypeMeta.
@@ -122,4 +129,8 @@ python_builtins_are_known_scalar_types(
 NPY_NO_EXPORT int
 dtypemeta_wrap_legacy_descriptor(PyArray_Descr *dtypem);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif  /* NUMPY_CORE_SRC_MULTIARRAY_DTYPEMETA_H_ */
diff --git a/numpy/core/src/multiarray/einsum_sumprod.c.src b/numpy/core/src/multiarray/einsum_sumprod.c.src
index 3114a58960ef..e7b2f2c2c0cd 100644
--- a/numpy/core/src/multiarray/einsum_sumprod.c.src
+++ b/numpy/core/src/multiarray/einsum_sumprod.c.src
@@ -68,7 +68,7 @@
  *            0*3#
  * #NPYV_CHK = 0*5,
  *             0*5,
- *             0, NPY_SIMD, NPY_SIMD_F64, 0,
+ *             0, NPY_SIMD_F32, NPY_SIMD_F64, 0,
  *             0*3#
  */
 
diff --git a/numpy/core/src/multiarray/experimental_public_dtype_api.c b/numpy/core/src/multiarray/experimental_public_dtype_api.c
index 4b9c7199b167..84507b4812ba 100644
--- a/numpy/core/src/multiarray/experimental_public_dtype_api.c
+++ b/numpy/core/src/multiarray/experimental_public_dtype_api.c
@@ -16,7 +16,7 @@
 #include "common_dtype.h"
 
 
-#define EXPERIMENTAL_DTYPE_API_VERSION 2
+#define EXPERIMENTAL_DTYPE_API_VERSION 5
 
 
 typedef struct{
@@ -111,13 +111,13 @@ legacy_getitem_using_DType(void *data, void *arr)
  * from the user in the future and more could get defaults for compatibility.
  */
 PyArray_ArrFuncs default_funcs = {
+        .getitem = &legacy_getitem_using_DType,
         .setitem = &legacy_setitem_using_DType,
-        .getitem = &legacy_getitem_using_DType
 };
 
 
 /* other slots are in order, so keep only last around: */
-#define NUM_DTYPE_SLOTS 7
+#define NUM_DTYPE_SLOTS 8
 
 
 int
@@ -209,6 +209,12 @@ PyArrayInitDTypeMeta_FromSpec(
         return -1;
     }
 
+    if (NPY_DT_SLOTS(DType)->ensure_canonical == NULL) {
+        PyErr_SetString(PyExc_RuntimeError,
+                        "A DType must provide an ensure_canonical implementation.");
+        return -1;
+    }
+
     /*
      * Now that the spec is read we can check that all required functions were
      * defined by the user.
@@ -252,6 +258,14 @@ PyArrayInitDTypeMeta_FromSpec(
     /*
      * And now, register all the casts that are currently defined!
      */
+    if (spec->casts == NULL) {
+        PyErr_SetString(
+            PyExc_RuntimeError,
+            "DType must at least provide a function to cast (or just copy) "
+            "between its own instances!");
+        return -1;
+    }
+
     PyArrayMethod_Spec **next_meth_spec = spec->casts;
     while (1) {
         PyArrayMethod_Spec *meth_spec = *next_meth_spec;
@@ -300,37 +314,23 @@ PyArrayInitDTypeMeta_FromSpec(
 }
 
 
-/* Function is defined in umath/dispatching.c (same/one compilation unit) */
+/* Functions defined in umath/dispatching.c (same/one compilation unit) */
 NPY_NO_EXPORT int
 PyUFunc_AddLoop(PyUFuncObject *ufunc, PyObject *info, int ignore_duplicate);
 
-static int
-PyUFunc_AddLoopFromSpec(PyObject *ufunc, PyArrayMethod_Spec *spec)
-{
-    if (!PyObject_TypeCheck(ufunc, &PyUFunc_Type)) {
-        PyErr_SetString(PyExc_TypeError,
-                "ufunc object passed is not a ufunc!");
-        return -1;
-    }
-    PyBoundArrayMethodObject *bmeth =
-            (PyBoundArrayMethodObject *)PyArrayMethod_FromSpec(spec);
-    if (bmeth == NULL) {
-        return -1;
-    }
-    int nargs = bmeth->method->nin + bmeth->method->nout;
-    PyObject *dtypes = PyArray_TupleFromItems(
-            nargs, (PyObject **)bmeth->dtypes, 1);
-    if (dtypes == NULL) {
-        return -1;
-    }
-    PyObject *info = PyTuple_Pack(2, dtypes, bmeth->method);
-    Py_DECREF(bmeth);
-    Py_DECREF(dtypes);
-    if (info == NULL) {
-        return -1;
-    }
-    return PyUFunc_AddLoop((PyUFuncObject *)ufunc, info, 0);
-}
+NPY_NO_EXPORT int
+PyUFunc_AddLoopFromSpec(PyUFuncObject *ufunc, PyObject *info, int ignore_duplicate);
+
+
+/*
+ * Function is defined in umath/wrapping_array_method.c
+ * (same/one compilation unit)
+ */
+NPY_NO_EXPORT int
+PyUFunc_AddWrappingLoop(PyObject *ufunc_obj,
+        PyArray_DTypeMeta *new_dtypes[], PyArray_DTypeMeta *wrapped_dtypes[],
+        translate_given_descrs_func *translate_given_descrs,
+        translate_loop_descrs_func *translate_loop_descrs);
 
 
 static int
@@ -358,18 +358,75 @@ PyUFunc_AddPromoter(
 }
 
 
+/*
+ * Lightweight function fetch a default instance of a DType class.
+ * Note that this version is named `_PyArray_GetDefaultDescr` with an
+ * underscore.  The `singleton` slot is public, so an inline version is
+ * provided that checks `singleton != NULL` first.
+ */
+static PyArray_Descr *
+_PyArray_GetDefaultDescr(PyArray_DTypeMeta *DType)
+{
+    return NPY_DT_CALL_default_descr(DType);
+}
+
+
 NPY_NO_EXPORT PyObject *
 _get_experimental_dtype_api(PyObject *NPY_UNUSED(mod), PyObject *arg)
 {
-    static void *experimental_api_table[] = {
+    static void *experimental_api_table[42] = {
             &PyUFunc_AddLoopFromSpec,
             &PyUFunc_AddPromoter,
             &PyArrayDTypeMeta_Type,
             &PyArrayInitDTypeMeta_FromSpec,
             &PyArray_CommonDType,
             &PyArray_PromoteDTypeSequence,
+            &_PyArray_GetDefaultDescr,
+            &PyUFunc_AddWrappingLoop,
             NULL,
+            NULL,
+            /* NumPy's builtin DTypes (starting at offset 10 going to 41) */
     };
+    if (experimental_api_table[10] == NULL) {
+        experimental_api_table[10] = PyArray_DTypeFromTypeNum(NPY_BOOL);
+        /* Integers */
+        experimental_api_table[11] = PyArray_DTypeFromTypeNum(NPY_BYTE);
+        experimental_api_table[12] = PyArray_DTypeFromTypeNum(NPY_UBYTE);
+        experimental_api_table[13] = PyArray_DTypeFromTypeNum(NPY_SHORT);
+        experimental_api_table[14] = PyArray_DTypeFromTypeNum(NPY_USHORT);
+        experimental_api_table[15] = PyArray_DTypeFromTypeNum(NPY_INT);
+        experimental_api_table[16] = PyArray_DTypeFromTypeNum(NPY_UINT);
+        experimental_api_table[17] = PyArray_DTypeFromTypeNum(NPY_LONG);
+        experimental_api_table[18] = PyArray_DTypeFromTypeNum(NPY_ULONG);
+        experimental_api_table[19] = PyArray_DTypeFromTypeNum(NPY_LONGLONG);
+        experimental_api_table[20] = PyArray_DTypeFromTypeNum(NPY_ULONGLONG);
+        /* Integer aliases */
+        experimental_api_table[21] = PyArray_DTypeFromTypeNum(NPY_INT8);
+        experimental_api_table[22] = PyArray_DTypeFromTypeNum(NPY_UINT8);
+        experimental_api_table[23] = PyArray_DTypeFromTypeNum(NPY_INT16);
+        experimental_api_table[24] = PyArray_DTypeFromTypeNum(NPY_UINT16);
+        experimental_api_table[25] = PyArray_DTypeFromTypeNum(NPY_INT32);
+        experimental_api_table[26] = PyArray_DTypeFromTypeNum(NPY_UINT32);
+        experimental_api_table[27] = PyArray_DTypeFromTypeNum(NPY_INT64);
+        experimental_api_table[28] = PyArray_DTypeFromTypeNum(NPY_UINT64);
+        experimental_api_table[29] = PyArray_DTypeFromTypeNum(NPY_INTP);
+        experimental_api_table[30] = PyArray_DTypeFromTypeNum(NPY_UINTP);
+        /* Floats */
+        experimental_api_table[31] = PyArray_DTypeFromTypeNum(NPY_HALF);
+        experimental_api_table[32] = PyArray_DTypeFromTypeNum(NPY_FLOAT);
+        experimental_api_table[33] = PyArray_DTypeFromTypeNum(NPY_DOUBLE);
+        experimental_api_table[34] = PyArray_DTypeFromTypeNum(NPY_LONGDOUBLE);
+        /* Complex */
+        experimental_api_table[35] = PyArray_DTypeFromTypeNum(NPY_CFLOAT);
+        experimental_api_table[36] = PyArray_DTypeFromTypeNum(NPY_CDOUBLE);
+        experimental_api_table[37] = PyArray_DTypeFromTypeNum(NPY_CLONGDOUBLE);
+        /* String/Bytes */
+        experimental_api_table[38] = PyArray_DTypeFromTypeNum(NPY_STRING);
+        experimental_api_table[39] = PyArray_DTypeFromTypeNum(NPY_UNICODE);
+        /* Datetime/Timedelta */
+        experimental_api_table[40] = PyArray_DTypeFromTypeNum(NPY_DATETIME);
+        experimental_api_table[41] = PyArray_DTypeFromTypeNum(NPY_TIMEDELTA);
+    }
 
     char *env = getenv("NUMPY_EXPERIMENTAL_DTYPE_API");
     if (env == NULL || strcmp(env, "1") != 0) {
diff --git a/numpy/core/src/multiarray/flagsobject.c b/numpy/core/src/multiarray/flagsobject.c
index 3b1b4f406194..bcc9f4e941da 100644
--- a/numpy/core/src/multiarray/flagsobject.c
+++ b/numpy/core/src/multiarray/flagsobject.c
@@ -105,20 +105,11 @@ PyArray_UpdateFlags(PyArrayObject *ret, int flagmask)
  *
  * According to these rules, a 0- or 1-dimensional array is either both
  * C- and F-contiguous, or neither; and an array with 2+ dimensions
- * can be C- or F- contiguous, or neither, but not both. Though there
- * there are exceptions for arrays with zero or one item, in the first
- * case the check is relaxed up to and including the first dimension
- * with shape[i] == 0. In the second case `strides == itemsize` will
- * can be true for all dimensions and both flags are set.
- *
- * When NPY_RELAXED_STRIDES_CHECKING is set, we use a more accurate
- * definition of C- and F-contiguity, in which all 0-sized arrays are
- * contiguous (regardless of dimensionality), and if shape[i] == 1
- * then we ignore strides[i] (since it has no affect on memory layout).
- * With these new rules, it is possible for e.g. a 10x1 array to be both
- * C- and F-contiguous -- but, they break downstream code which assumes
- * that for contiguous arrays strides[-1] (resp. strides[0]) always
- * contains the itemsize.
+ * can be C- or F- contiguous, or neither, but not both (unless it has only
+ * a single element).
+ * We correct this, however.  When a dimension has length 1, its stride is
+ * never used and thus has no effect on the  memory layout.
+ * The above rules thus only apply when ignoring all size 1 dimensions.
  */
 static void
 _UpdateContiguousFlags(PyArrayObject *ap)
@@ -131,7 +122,6 @@ _UpdateContiguousFlags(PyArrayObject *ap)
     sd = PyArray_ITEMSIZE(ap);
     for (i = PyArray_NDIM(ap) - 1; i >= 0; --i) {
         dim = PyArray_DIMS(ap)[i];
-#if NPY_RELAXED_STRIDES_CHECKING
         /* contiguous by definition */
         if (dim == 0) {
             PyArray_ENABLEFLAGS(ap, NPY_ARRAY_C_CONTIGUOUS);
@@ -144,17 +134,6 @@ _UpdateContiguousFlags(PyArrayObject *ap)
             }
             sd *= dim;
         }
-#else /* not NPY_RELAXED_STRIDES_CHECKING */
-        if (PyArray_STRIDES(ap)[i] != sd) {
-            is_c_contig = 0;
-            break;
-        }
-        /* contiguous, if it got this far */
-        if (dim == 0) {
-            break;
-        }
-        sd *= dim;
-#endif /* not NPY_RELAXED_STRIDES_CHECKING */
     }
     if (is_c_contig) {
         PyArray_ENABLEFLAGS(ap, NPY_ARRAY_C_CONTIGUOUS);
@@ -167,7 +146,6 @@ _UpdateContiguousFlags(PyArrayObject *ap)
     sd = PyArray_ITEMSIZE(ap);
     for (i = 0; i < PyArray_NDIM(ap); ++i) {
         dim = PyArray_DIMS(ap)[i];
-#if NPY_RELAXED_STRIDES_CHECKING
         if (dim != 1) {
             if (PyArray_STRIDES(ap)[i] != sd) {
                 PyArray_CLEARFLAGS(ap, NPY_ARRAY_F_CONTIGUOUS);
@@ -175,16 +153,6 @@ _UpdateContiguousFlags(PyArrayObject *ap)
             }
             sd *= dim;
         }
-#else /* not NPY_RELAXED_STRIDES_CHECKING */
-        if (PyArray_STRIDES(ap)[i] != sd) {
-            PyArray_CLEARFLAGS(ap, NPY_ARRAY_F_CONTIGUOUS);
-            return;
-        }
-        if (dim == 0) {
-            break;
-        }
-        sd *= dim;
-#endif /* not NPY_RELAXED_STRIDES_CHECKING */
     }
     PyArray_ENABLEFLAGS(ap, NPY_ARRAY_F_CONTIGUOUS);
     return;
@@ -237,25 +205,6 @@ _define_get_warn(NPY_ARRAY_ALIGNED|
             NPY_ARRAY_WRITEABLE|
             NPY_ARRAY_C_CONTIGUOUS, carray)
 
-static PyObject *
-arrayflags_updateifcopy_get(PyArrayFlagsObject *self, void *NPY_UNUSED(ignored))
-{
-    PyObject *item;
-    /* 2017-Nov-10 1.14 */
-    if(DEPRECATE("UPDATEIFCOPY deprecated, use WRITEBACKIFCOPY instead") < 0) {
-        return NULL;
-    }
-    if ((self->flags & (NPY_ARRAY_UPDATEIFCOPY)) == (NPY_ARRAY_UPDATEIFCOPY)) {
-        item = Py_True;
-    }
-    else {
-        item = Py_False;
-    }
-    Py_INCREF(item);
-    return item;
-}
-
-
 static PyObject *
 arrayflags_forc_get(PyArrayFlagsObject *self, void *NPY_UNUSED(ignored))
 {
@@ -312,36 +261,6 @@ arrayflags_num_get(PyArrayFlagsObject *self, void *NPY_UNUSED(ignored))
     return PyLong_FromLong(self->flags);
 }
 
-/* relies on setflags order being write, align, uic */
-static int
-arrayflags_updateifcopy_set(
-        PyArrayFlagsObject *self, PyObject *obj, void *NPY_UNUSED(ignored))
-{
-    PyObject *res;
-
-    if (obj == NULL) {
-        PyErr_SetString(PyExc_AttributeError,
-                "Cannot delete flags updateifcopy attribute");
-        return -1;
-    }
-    if (self->arr == NULL) {
-        PyErr_SetString(PyExc_ValueError,
-                "Cannot set flags on array scalars.");
-        return -1;
-    }
-    /* 2017-Nov-10 1.14 */
-    if(DEPRECATE("UPDATEIFCOPY deprecated, use WRITEBACKIFCOPY instead") < 0) {
-        return -1;
-    }
-    res = PyObject_CallMethod(self->arr, "setflags", "OOO", Py_None, Py_None,
-                              (PyObject_IsTrue(obj) ? Py_True : Py_False));
-    if (res == NULL) {
-        return -1;
-    }
-    Py_DECREF(res);
-    return 0;
-}
-
 /* relies on setflags order being write, align, uic */
 static int
 arrayflags_writebackifcopy_set(
@@ -473,10 +392,6 @@ static PyGetSetDef arrayflags_getsets[] = {
         (getter)arrayflags_fortran_get,
         NULL,
         NULL, NULL},
-    {"updateifcopy",
-        (getter)arrayflags_updateifcopy_get,
-        (setter)arrayflags_updateifcopy_set,
-        NULL, NULL},
     {"writebackifcopy",
         (getter)arrayflags_writebackifcopy_get,
         (setter)arrayflags_writebackifcopy_set,
@@ -574,8 +489,6 @@ arrayflags_getitem(PyArrayFlagsObject *self, PyObject *ind)
             return arrayflags_aligned_get(self, NULL);
         case 'X':
             return arrayflags_writebackifcopy_get(self, NULL);
-        case 'U':
-            return arrayflags_updateifcopy_get(self, NULL);
         default:
             goto fail;
         }
@@ -631,9 +544,6 @@ arrayflags_getitem(PyArrayFlagsObject *self, PyObject *ind)
         }
         break;
     case 12:
-        if (strncmp(key, "UPDATEIFCOPY", n) == 0) {
-            return arrayflags_updateifcopy_get(self, NULL);
-        }
         if (strncmp(key, "C_CONTIGUOUS", n) == 0) {
             return arrayflags_contiguous_get(self, NULL);
         }
@@ -684,10 +594,6 @@ arrayflags_setitem(PyArrayFlagsObject *self, PyObject *ind, PyObject *item)
              ((n==1) && (strncmp(key, "A", n) == 0))) {
         return arrayflags_aligned_set(self, item, NULL);
     }
-    else if (((n==12) && (strncmp(key, "UPDATEIFCOPY", n) == 0)) ||
-             ((n==1) && (strncmp(key, "U", n) == 0))) {
-        return arrayflags_updateifcopy_set(self, item, NULL);
-    }
     else if (((n==15) && (strncmp(key, "WRITEBACKIFCOPY", n) == 0)) ||
              ((n==1) && (strncmp(key, "X", n) == 0))) {
         return arrayflags_writebackifcopy_set(self, item, NULL);
@@ -721,16 +627,14 @@ arrayflags_print(PyArrayFlagsObject *self)
     return PyUnicode_FromFormat(
                         "  %s : %s\n  %s : %s\n"
                         "  %s : %s\n  %s : %s%s\n"
-                        "  %s : %s\n  %s : %s\n"
-                        "  %s : %s\n",
+                        "  %s : %s\n  %s : %s\n",
                         "C_CONTIGUOUS",    _torf_(fl, NPY_ARRAY_C_CONTIGUOUS),
                         "F_CONTIGUOUS",    _torf_(fl, NPY_ARRAY_F_CONTIGUOUS),
                         "OWNDATA",         _torf_(fl, NPY_ARRAY_OWNDATA),
                         "WRITEABLE",       _torf_(fl, NPY_ARRAY_WRITEABLE),
                         _warn_on_write,
                         "ALIGNED",         _torf_(fl, NPY_ARRAY_ALIGNED),
-                        "WRITEBACKIFCOPY", _torf_(fl, NPY_ARRAY_WRITEBACKIFCOPY),
-                        "UPDATEIFCOPY",    _torf_(fl, NPY_ARRAY_UPDATEIFCOPY)
+                        "WRITEBACKIFCOPY", _torf_(fl, NPY_ARRAY_WRITEBACKIFCOPY)
     );
 }
 
diff --git a/numpy/core/src/multiarray/getset.c b/numpy/core/src/multiarray/getset.c
index e81ca29471bc..ab35548ed728 100644
--- a/numpy/core/src/multiarray/getset.c
+++ b/numpy/core/src/multiarray/getset.c
@@ -385,13 +385,8 @@ array_data_set(PyArrayObject *self, PyObject *op, void *NPY_UNUSED(ignored))
     if (PyArray_FLAGS(self) & NPY_ARRAY_OWNDATA) {
         PyArray_XDECREF(self);
         size_t nbytes = PyArray_NBYTES(self);
-        /*
-         * Allocation will never be 0, see comment in ctors.c
-         * line 820
-         */
         if (nbytes == 0) {
-            PyArray_Descr *dtype = PyArray_DESCR(self);
-            nbytes = dtype->elsize ? dtype->elsize : 1;
+            nbytes = 1;
         }
         PyObject *handler = PyArray_HANDLER(self);
         if (handler == NULL) {
@@ -401,14 +396,13 @@ array_data_set(PyArrayObject *self, PyObject *op, void *NPY_UNUSED(ignored))
             return -1;
         }
         PyDataMem_UserFREE(PyArray_DATA(self), nbytes, handler);
+        Py_CLEAR(((PyArrayObject_fields *)self)->mem_handler);
     }
     if (PyArray_BASE(self)) {
-        if ((PyArray_FLAGS(self) & NPY_ARRAY_WRITEBACKIFCOPY) ||
-            (PyArray_FLAGS(self) & NPY_ARRAY_UPDATEIFCOPY)) {
+        if (PyArray_FLAGS(self) & NPY_ARRAY_WRITEBACKIFCOPY) {
             PyArray_ENABLEFLAGS((PyArrayObject *)PyArray_BASE(self),
                                                 NPY_ARRAY_WRITEABLE);
             PyArray_CLEARFLAGS(self, NPY_ARRAY_WRITEBACKIFCOPY);
-            PyArray_CLEARFLAGS(self, NPY_ARRAY_UPDATEIFCOPY);
         }
         Py_DECREF(PyArray_BASE(self));
         ((PyArrayObject_fields *)self)->base = NULL;
@@ -505,9 +499,6 @@ array_descr_set(PyArrayObject *self, PyObject *arg, void *NPY_UNUSED(ignored))
 
     /* Changing the size of the dtype results in a shape change */
     if (newtype->elsize != PyArray_DESCR(self)->elsize) {
-        int axis;
-        npy_intp newdim;
-
         /* forbidden cases */
         if (PyArray_NDIM(self) == 0) {
             PyErr_SetString(PyExc_ValueError,
@@ -522,31 +513,21 @@ array_descr_set(PyArrayObject *self, PyObject *arg, void *NPY_UNUSED(ignored))
             goto fail;
         }
 
-        /* determine which axis to resize */
-        if (PyArray_IS_C_CONTIGUOUS(self)) {
-            axis = PyArray_NDIM(self) - 1;
-        }
-        else if (PyArray_IS_F_CONTIGUOUS(self)) {
-            /* 2015-11-27 1.11.0, gh-6747 */
-            if (DEPRECATE(
-                        "Changing the shape of an F-contiguous array by "
-                        "descriptor assignment is deprecated. To maintain the "
-                        "Fortran contiguity of a multidimensional Fortran "
-                        "array, use 'a.T.view(...).T' instead") < 0) {
-                goto fail;
-            }
-            axis = 0;
-        }
-        else {
-            /* Don't mention the deprecated F-contiguous support */
+        /* resize on last axis only */
+        int axis = PyArray_NDIM(self) - 1;
+        if (PyArray_DIMS(self)[axis] != 1 &&
+                PyArray_SIZE(self) != 0 &&
+                PyArray_STRIDES(self)[axis] != PyArray_DESCR(self)->elsize) {
             PyErr_SetString(PyExc_ValueError,
-                    "To change to a dtype of a different size, the array must "
-                    "be C-contiguous");
+                    "To change to a dtype of a different size, the last axis "
+                    "must be contiguous");
             goto fail;
         }
 
+        npy_intp newdim;
+
         if (newtype->elsize < PyArray_DESCR(self)->elsize) {
-            /* if it is compatible, increase the size of the relevant axis */
+            /* if it is compatible, increase the size of the last axis */
             if (newtype->elsize == 0 ||
                     PyArray_DESCR(self)->elsize % newtype->elsize != 0) {
                 PyErr_SetString(PyExc_ValueError,
@@ -558,7 +539,7 @@ array_descr_set(PyArrayObject *self, PyObject *arg, void *NPY_UNUSED(ignored))
             PyArray_DIMS(self)[axis] *= newdim;
             PyArray_STRIDES(self)[axis] = newtype->elsize;
         }
-        else if (newtype->elsize > PyArray_DESCR(self)->elsize) {
+        else /* newtype->elsize > PyArray_DESCR(self)->elsize */ {
             /* if it is compatible, decrease the size of the relevant axis */
             newdim = PyArray_DIMS(self)[axis] * PyArray_DESCR(self)->elsize;
             if ((newdim % newtype->elsize) != 0) {
@@ -633,7 +614,7 @@ array_struct_get(PyArrayObject *self, void *NPY_UNUSED(ignored))
         inter->flags = inter->flags & ~NPY_ARRAY_WRITEABLE;
     }
     /* reset unused flags */
-    inter->flags &= ~(NPY_ARRAY_WRITEBACKIFCOPY | NPY_ARRAY_UPDATEIFCOPY |NPY_ARRAY_OWNDATA);
+    inter->flags &= ~(NPY_ARRAY_WRITEBACKIFCOPY | NPY_ARRAY_OWNDATA);
     if (PyArray_ISNOTSWAPPED(self)) inter->flags |= NPY_ARRAY_NOTSWAPPED;
     /*
      * Copy shape and strides over since these can be reset
@@ -721,15 +702,18 @@ _get_part(PyArrayObject *self, int imag)
 
     }
     type = PyArray_DescrFromType(float_type_num);
+    if (type == NULL) {
+        return NULL;
+    }
 
     offset = (imag ? type->elsize : 0);
 
     if (!PyArray_ISNBO(PyArray_DESCR(self)->byteorder)) {
-        PyArray_Descr *new;
-        new = PyArray_DescrNew(type);
-        new->byteorder = PyArray_DESCR(self)->byteorder;
-        Py_DECREF(type);
-        type = new;
+        Py_SETREF(type, PyArray_DescrNew(type));
+        if (type == NULL) {
+            return NULL;
+        }
+        type->byteorder = PyArray_DESCR(self)->byteorder;
     }
     ret = (PyArrayObject *)PyArray_NewFromDescrAndBase(
             Py_TYPE(self),
@@ -824,6 +808,7 @@ array_imag_get(PyArrayObject *self, void *NPY_UNUSED(ignored))
             return NULL;
         }
         if (_zerofill(ret) < 0) {
+            Py_DECREF(ret);
             return NULL;
         }
         PyArray_CLEARFLAGS(ret, NPY_ARRAY_WRITEABLE);
@@ -949,15 +934,6 @@ array_transpose_get(PyArrayObject *self, void *NPY_UNUSED(ignored))
     return PyArray_Transpose(self, NULL);
 }
 
-/* If this is None, no function call is made
-   --- default sub-class behavior
-*/
-static PyObject *
-array_finalize_get(PyArrayObject *NPY_UNUSED(self), void *NPY_UNUSED(ignored))
-{
-    Py_RETURN_NONE;
-}
-
 NPY_NO_EXPORT PyGetSetDef array_getsetlist[] = {
     {"ndim",
         (getter)array_ndim_get,
@@ -1031,10 +1007,6 @@ NPY_NO_EXPORT PyGetSetDef array_getsetlist[] = {
         (getter)array_priority_get,
         NULL,
         NULL, NULL},
-    {"__array_finalize__",
-        (getter)array_finalize_get,
-        NULL,
-        NULL, NULL},
     {NULL, NULL, NULL, NULL, NULL},  /* Sentinel */
 };
 
diff --git a/numpy/core/src/multiarray/hashdescr.c b/numpy/core/src/multiarray/hashdescr.c
index a3c9e986bf40..76403df25ead 100644
--- a/numpy/core/src/multiarray/hashdescr.c
+++ b/numpy/core/src/multiarray/hashdescr.c
@@ -85,7 +85,7 @@ static int _array_descr_builtin(PyArray_Descr* descr, PyObject *l)
         item = PyTuple_GetItem(t, i);
         if (item == NULL) {
             PyErr_SetString(PyExc_SystemError,
-                    "(Hash) Error while computing builting hash");
+                    "(Hash) Error while computing builtin hash");
             goto clean_t;
         }
         PyList_Append(l, item);
diff --git a/numpy/core/src/multiarray/item_selection.c b/numpy/core/src/multiarray/item_selection.c
index 086b674c809e..9fad153a3d4c 100644
--- a/numpy/core/src/multiarray/item_selection.c
+++ b/numpy/core/src/multiarray/item_selection.c
@@ -2641,13 +2641,33 @@ PyArray_Nonzero(PyArrayObject *self)
                     *multi_index++ = j++;
                 }
             }
+            /*
+             * Fallback to a branchless strategy to avoid branch misprediction 
+             * stalls that are very expensive on most modern processors.
+             */
             else {
-                npy_intp j;
-                for (j = 0; j < count; ++j) {
-                    if (*data != 0) {
-                        *multi_index++ = j;
-                    }
+                npy_intp *multi_index_end = multi_index + nonzero_count;
+                npy_intp j = 0;
+
+                /* Manually unroll for GCC and maybe other compilers */
+                while (multi_index + 4 < multi_index_end) {
+                    *multi_index = j;
+                    multi_index += data[0] != 0;
+                    *multi_index = j + 1;
+                    multi_index += data[stride] != 0;
+                    *multi_index = j + 2;
+                    multi_index += data[stride * 2] != 0;
+                    *multi_index = j + 3;
+                    multi_index += data[stride * 3] != 0;
+                    data += stride * 4;
+                    j += 4;
+                }
+
+                while (multi_index < multi_index_end) {
+                    *multi_index = j;
+                    multi_index += *data != 0;
                     data += stride;
+                    ++j;
                 }
             }
         }
diff --git a/numpy/core/src/multiarray/iterators.c b/numpy/core/src/multiarray/iterators.c
index f959162fd015..95aa11d2ded7 100644
--- a/numpy/core/src/multiarray/iterators.c
+++ b/numpy/core/src/multiarray/iterators.c
@@ -827,7 +827,8 @@ iter_ass_subscript(PyArrayIterObject *self, PyObject *ind, PyObject *val)
     if (PyBool_Check(ind)) {
         retval = 0;
         if (PyObject_IsTrue(ind)) {
-            retval = PyArray_Pack(PyArray_DESCR(self->ao), self->dataptr, val);
+            retval = PyArray_Pack(
+                    PyArray_DESCR(self->ao), self->dataptr, val);
         }
         goto finish;
     }
diff --git a/numpy/core/src/multiarray/legacy_dtype_implementation.c b/numpy/core/src/multiarray/legacy_dtype_implementation.c
index 72a52d7a87c0..73c70c393a0c 100644
--- a/numpy/core/src/multiarray/legacy_dtype_implementation.c
+++ b/numpy/core/src/multiarray/legacy_dtype_implementation.c
@@ -13,6 +13,7 @@
 #include "scalartypes.h"
 #include "_datetime.h"
 #include "datetime_strings.h"
+#include "can_cast_table.h"
 #include "convert_datatype.h"
 
 #include "legacy_dtype_implementation.h"
diff --git a/numpy/core/src/multiarray/lowlevel_strided_loops.c.src b/numpy/core/src/multiarray/lowlevel_strided_loops.c.src
index e313d244768d..8e3afd3cc658 100644
--- a/numpy/core/src/multiarray/lowlevel_strided_loops.c.src
+++ b/numpy/core/src/multiarray/lowlevel_strided_loops.c.src
@@ -13,6 +13,7 @@
 
 #define NPY_NO_DEPRECATED_API NPY_API_VERSION
 #define _MULTIARRAYMODULE
+#define _UMATHMODULE
 #include 
 #include 
 #include 
@@ -22,6 +23,7 @@
 #include "array_method.h"
 #include "usertypes.h"
 
+#include "umathmodule.h"
 
 /*
  * x86 platform works with unaligned access but the compiler is allowed to
@@ -1557,14 +1559,16 @@ mapiter_trivial_@name@(PyArrayObject *self, PyArrayObject *ind,
  * General advanced indexing iteration.
  */
 NPY_NO_EXPORT int
-mapiter_@name@(PyArrayMapIterObject *mit)
+mapiter_@name@(
+        PyArrayMapIterObject *mit, NPY_cast_info *cast_info,
+        NPY_ARRAYMETHOD_FLAGS flags, int is_aligned)
 {
     npy_intp *counter, count;
-    int i, is_aligned;
+    int i;
 
     /* Cached mit info */
     int numiter = mit->numiter;
-    int needs_api = mit->needs_api;
+    int needs_api = (flags & NPY_METH_REQUIRES_PYAPI) != 0;
     /* Constant information */
     npy_intp fancy_dims[NPY_MAXDIMS];
     npy_intp fancy_strides[NPY_MAXDIMS];
@@ -1586,13 +1590,6 @@ mapiter_@name@(PyArrayMapIterObject *mit)
         fancy_strides[i] = mit->fancy_strides[i];
     }
 
-    /*
-     * Alignment information (swapping is never needed, since we buffer),
-     * could also check extra_op is buffered, but it should rarely matter.
-     */
-
-    is_aligned = IsUintAligned(array) && IsUintAligned(mit->extra_op);
-
     if (mit->size == 0) {
        return 0;
     }
@@ -1600,9 +1597,11 @@ mapiter_@name@(PyArrayMapIterObject *mit)
     if (mit->subspace_iter == NULL) {
         /*
          * Item by item copy situation, the operand is buffered
-         * so use copyswap.
+         * so use copyswap.  The iterator may not do any transfers, so may
+         * not have set `needs_api` yet, set it if necessary:
          */
-         PyArray_CopySwapFunc *copyswap = PyArray_DESCR(array)->f->copyswap;
+        needs_api |= PyDataType_REFCHK(PyArray_DESCR(array));
+        PyArray_CopySwapFunc *copyswap = PyArray_DESCR(array)->f->copyswap;
 
         /* We have only one iterator handling everything */
         counter = NpyIter_GetInnerLoopSizePtr(mit->outer);
@@ -1715,28 +1714,9 @@ mapiter_@name@(PyArrayMapIterObject *mit)
         int is_subiter_trivial = 0; /* has three states */
         npy_intp reset_offsets[2] = {0, 0};
 
-        /* Use strided transfer functions for the inner loop */
-        npy_intp fixed_strides[2];
-
-        /*
-         * Get a dtype transfer function, since there are no
-         * buffers, this is safe.
-         */
-        NpyIter_GetInnerFixedStrideArray(mit->subspace_iter, fixed_strides);
-
-        NPY_cast_info cast_info;
-        if (PyArray_GetDTypeTransferFunction(is_aligned,
-#if @isget@
-                        fixed_strides[0], fixed_strides[1],
-                        PyArray_DESCR(array), PyArray_DESCR(mit->extra_op),
-#else
-                        fixed_strides[1], fixed_strides[0],
-                         PyArray_DESCR(mit->extra_op), PyArray_DESCR(array),
-#endif
-                        0,
-                        &cast_info,
-                        &needs_api) != NPY_SUCCEED) {
-            return -1;
+        /* Note: it may make sense to refactor `needs_api` out in this branch */
+        if (flags & NPY_METH_REQUIRES_PYAPI) {
+            needs_api = 1;
         }
 
         counter = NpyIter_GetInnerLoopSizePtr(mit->subspace_iter);
@@ -1771,7 +1751,6 @@ mapiter_@name@(PyArrayMapIterObject *mit)
 #if @isget@ && @one_iter@
                     if (check_and_adjust_index(&indval, fancy_dims[i],
                                                iteraxis, _save) < 0 ) {
-                        NPY_cast_info_xfree(&cast_info);
                         return -1;
                     }
 #else
@@ -1803,7 +1782,6 @@ mapiter_@name@(PyArrayMapIterObject *mit)
                                                    &errmsg)) {
                         NPY_END_THREADS;
                         PyErr_SetString(PyExc_ValueError, errmsg);
-                        NPY_cast_info_xfree(&cast_info);
                         return -1;
                     }
                     if (is_subiter_trivial != 0) {
@@ -1833,7 +1811,6 @@ mapiter_@name@(PyArrayMapIterObject *mit)
                  *       not at all...
                  */
                 if (needs_api && PyErr_Occurred()) {
-                    NPY_cast_info_xfree(&cast_info);
                     return -1;
                 }
 #endif
@@ -1841,21 +1818,19 @@ mapiter_@name@(PyArrayMapIterObject *mit)
                 do {
 
 #if @isget@
-                    if (NPY_UNLIKELY(cast_info.func(&cast_info.context,
+                    if (NPY_UNLIKELY(cast_info->func(&cast_info->context,
                             subspace_ptrs, counter, subspace_strides,
-                            cast_info.auxdata) < 0)) {
+                            cast_info->auxdata) < 0)) {
                         NPY_END_THREADS;
-                        NPY_cast_info_xfree(&cast_info);
                         return -1;
                     }
 #else
                     /* The operand order is reversed here */
                     char *args[2] = {subspace_ptrs[1], subspace_ptrs[0]};
                     npy_intp strides[2] = {subspace_strides[1], subspace_strides[0]};
-                    if (NPY_UNLIKELY(cast_info.func(&cast_info.context,
-                            args, counter, strides, cast_info.auxdata) < 0)) {
+                    if (NPY_UNLIKELY(cast_info->func(&cast_info->context,
+                            args, counter, strides, cast_info->auxdata) < 0)) {
                         NPY_END_THREADS;
-                        NPY_cast_info_xfree(&cast_info);
                         return -1;
                     }
 #endif
@@ -1866,8 +1841,6 @@ mapiter_@name@(PyArrayMapIterObject *mit)
             NPY_END_THREADS;
         }
 /**end repeat1**/
-
-        NPY_cast_info_xfree(&cast_info);
     }
     return 0;
 }
diff --git a/numpy/core/src/multiarray/mapping.c b/numpy/core/src/multiarray/mapping.c
index 014a863d5471..98c2d7edaa27 100644
--- a/numpy/core/src/multiarray/mapping.c
+++ b/numpy/core/src/multiarray/mapping.c
@@ -1,11 +1,14 @@
 #define NPY_NO_DEPRECATED_API NPY_API_VERSION
 #define _MULTIARRAYMODULE
+#define _UMATHMODULE
 
 #define PY_SSIZE_T_CLEAN
 #include 
 #include 
 
 #include "numpy/arrayobject.h"
+#include "numpy/npy_math.h"
+
 #include "arrayobject.h"
 
 #include "npy_config.h"
@@ -23,6 +26,11 @@
 #include "mem_overlap.h"
 #include "array_assign.h"
 #include "array_coercion.h"
+/* TODO: Only for `NpyIter_GetTransferFlags` until it is public */
+#define NPY_ITERATOR_IMPLEMENTATION_CODE
+#include "nditer_impl.h"
+
+#include "umathmodule.h"
 
 
 #define HAS_INTEGER 1
@@ -197,21 +205,8 @@ unpack_scalar(PyObject *index, PyObject **result, npy_intp NPY_UNUSED(result_n))
 /**
  * Turn an index argument into a c-array of `PyObject *`s, one for each index.
  *
- * When a scalar is passed, this is written directly to the buffer. When a
- * tuple is passed, the tuple elements are unpacked into the buffer.
- *
- * When some other sequence is passed, this implements the following section
- * from the advanced indexing docs to decide whether to unpack or just write
- * one element:
- *
- * > In order to remain backward compatible with a common usage in Numeric,
- * > basic slicing is also initiated if the selection object is any non-ndarray
- * > sequence (such as a list) containing slice objects, the Ellipsis object,
- * > or the newaxis object, but not for integer arrays or other embedded
- * > sequences.
- *
- * It might be worth deprecating this behaviour (gh-4434), in which case the
- * entire function should become a simple check of PyTuple_Check.
+ * When a tuple is passed, the tuple elements are unpacked into the buffer.
+ * Anything else is handled by unpack_scalar().
  *
  * @param  index     The index object, which may or may not be a tuple. This is
  *                   a borrowed reference.
@@ -228,129 +223,32 @@ unpack_scalar(PyObject *index, PyObject **result, npy_intp NPY_UNUSED(result_n))
 NPY_NO_EXPORT npy_intp
 unpack_indices(PyObject *index, PyObject **result, npy_intp result_n)
 {
-    npy_intp n, i;
-    npy_bool commit_to_unpack;
+    /* It is likely that the logic here can be simplified. See the discussion
+     * on https://github.com/numpy/numpy/pull/21029
+     */
 
     /* Fast route for passing a tuple */
     if (PyTuple_CheckExact(index)) {
         return unpack_tuple((PyTupleObject *)index, result, result_n);
     }
 
-    /* Obvious single-entry cases */
-    if (0  /* to aid macros below */
-            || PyLong_CheckExact(index)
-            || index == Py_None
-            || PySlice_Check(index)
-            || PyArray_Check(index)
-            || !PySequence_Check(index)
-            || PyUnicode_Check(index)) {
-
-        return unpack_scalar(index, result, result_n);
-    }
-
     /*
      * Passing a tuple subclass - coerce to the base type. This incurs an
-     * allocation, but doesn't need to be a fast path anyway
+     * allocation, but doesn't need to be a fast path anyway. Note that by
+     * calling `PySequence_Tuple`, we ensure that the subclass `__iter__` is
+     * called.
      */
     if (PyTuple_Check(index)) {
         PyTupleObject *tup = (PyTupleObject *) PySequence_Tuple(index);
         if (tup == NULL) {
             return -1;
         }
-        n = unpack_tuple(tup, result, result_n);
+        npy_intp n = unpack_tuple(tup, result, result_n);
         Py_DECREF(tup);
         return n;
     }
 
-    /*
-     * At this point, we're left with a non-tuple, non-array, sequence:
-     * typically, a list. We use some somewhat-arbitrary heuristics from here
-     * onwards to decided whether to treat that list as a single index, or a
-     * list of indices.
-     */
-
-    /* if len fails, treat like a scalar */
-    n = PySequence_Size(index);
-    if (n < 0) {
-        PyErr_Clear();
-        return unpack_scalar(index, result, result_n);
-    }
-
-    /*
-     * Backwards compatibility only takes effect for short sequences - otherwise
-     * we treat it like any other scalar.
-     *
-     * Sequences < NPY_MAXDIMS with any slice objects
-     * or newaxis, Ellipsis or other arrays or sequences
-     * embedded, are considered equivalent to an indexing
-     * tuple. (`a[[[1,2], [3,4]]] == a[[1,2], [3,4]]`)
-     */
-    if (n >= NPY_MAXDIMS) {
-        return unpack_scalar(index, result, result_n);
-    }
-
-    /* In case we change result_n elsewhere */
-    assert(n <= result_n);
-
-    /*
-     * Some other type of short sequence - assume we should unpack it like a
-     * tuple, and then decide whether that was actually necessary.
-     */
-    commit_to_unpack = 0;
-    for (i = 0; i < n; i++) {
-        PyObject *tmp_obj = result[i] = PySequence_GetItem(index, i);
-
-        if (commit_to_unpack) {
-            /* propagate errors */
-            if (tmp_obj == NULL) {
-                goto fail;
-            }
-        }
-        else {
-            /*
-             * if getitem fails (unusual) before we've committed, then stop
-             * unpacking
-             */
-            if (tmp_obj == NULL) {
-                PyErr_Clear();
-                break;
-            }
-
-            /* decide if we should treat this sequence like a tuple */
-            if (PyArray_Check(tmp_obj)
-                    || PySequence_Check(tmp_obj)
-                    || PySlice_Check(tmp_obj)
-                    || tmp_obj == Py_Ellipsis
-                    || tmp_obj == Py_None) {
-                if (DEPRECATE_FUTUREWARNING(
-                        "Using a non-tuple sequence for multidimensional "
-                        "indexing is deprecated; use `arr[tuple(seq)]` "
-                        "instead of `arr[seq]`. In the future this will be "
-                        "interpreted as an array index, `arr[np.array(seq)]`, "
-                        "which will result either in an error or a different "
-                        "result.") < 0) {
-                    i++;  /* since loop update doesn't run */
-                    goto fail;
-                }
-                commit_to_unpack = 1;
-            }
-        }
-    }
-
-    /* unpacking was the right thing to do, and we already did it */
-    if (commit_to_unpack) {
-        return n;
-    }
-    /* got to the end, never found an indication that we should have unpacked */
-    else {
-        /* we partially filled result, so empty it first */
-        multi_DECREF(result, i);
-        return unpack_scalar(index, result, result_n);
-    }
-
-fail:
-    multi_DECREF(result, i);
-    return -1;
+    return unpack_scalar(index, result, result_n);
 }
 
 /**
@@ -1024,7 +922,6 @@ array_boolean_subscript(PyArrayObject *self,
     char *ret_data;
     PyArray_Descr *dtype;
     PyArrayObject *ret;
-    int needs_api = 0;
 
     size = count_boolean_trues(PyArray_NDIM(bmask), PyArray_DATA(bmask),
                                 PyArray_DIMS(bmask), PyArray_STRIDES(bmask));
@@ -1072,13 +969,18 @@ array_boolean_subscript(PyArrayObject *self,
         /* Get a dtype transfer function */
         NpyIter_GetInnerFixedStrideArray(iter, fixed_strides);
         NPY_cast_info cast_info;
+        /*
+         * TODO: Ignoring cast flags, since this is only ever a copy. In
+         *       principle that may not be quite right in some future?
+         */
+        NPY_ARRAYMETHOD_FLAGS cast_flags;
         if (PyArray_GetDTypeTransferFunction(
                         IsUintAligned(self) && IsAligned(self),
                         fixed_strides[0], itemsize,
                         dtype, dtype,
                         0,
                         &cast_info,
-                        &needs_api) != NPY_SUCCEED) {
+                        &cast_flags) != NPY_SUCCEED) {
             Py_DECREF(ret);
             NpyIter_Deallocate(iter);
             return NULL;
@@ -1178,7 +1080,6 @@ array_assign_boolean_subscript(PyArrayObject *self,
 {
     npy_intp size, v_stride;
     char *v_data;
-    int needs_api = 0;
     npy_intp bmask_size;
 
     if (PyArray_DESCR(bmask)->type_num != NPY_BOOL) {
@@ -1274,6 +1175,7 @@ array_assign_boolean_subscript(PyArrayObject *self,
         /* Get a dtype transfer function */
         NpyIter_GetInnerFixedStrideArray(iter, fixed_strides);
         NPY_cast_info cast_info;
+        NPY_ARRAYMETHOD_FLAGS cast_flags;
         if (PyArray_GetDTypeTransferFunction(
                  IsUintAligned(self) && IsAligned(self) &&
                         IsUintAligned(v) && IsAligned(v),
@@ -1281,14 +1183,17 @@ array_assign_boolean_subscript(PyArrayObject *self,
                         PyArray_DESCR(v), PyArray_DESCR(self),
                         0,
                         &cast_info,
-                        &needs_api) != NPY_SUCCEED) {
+                        &cast_flags) != NPY_SUCCEED) {
             NpyIter_Deallocate(iter);
             return -1;
         }
 
-        if (!needs_api) {
+        if (!(cast_flags & NPY_METH_REQUIRES_PYAPI)) {
             NPY_BEGIN_THREADS_NDITER(iter);
         }
+        if (!(flags & NPY_METH_NO_FLOATINGPOINT_ERRORS)) {
+            npy_clear_floatstatus_barrier((char *)self);
+        }
 
         npy_intp strides[2] = {v_stride, self_stride};
 
@@ -1319,7 +1224,7 @@ array_assign_boolean_subscript(PyArrayObject *self,
             }
         } while (iternext(iter));
 
-        if (!needs_api) {
+        if (!(cast_flags & NPY_METH_REQUIRES_PYAPI)) {
             NPY_END_THREADS;
         }
 
@@ -1327,6 +1232,12 @@ array_assign_boolean_subscript(PyArrayObject *self,
         if (!NpyIter_Deallocate(iter)) {
             res = -1;
         }
+        if (res == 0 && !(flags & NPY_METH_NO_FLOATINGPOINT_ERRORS)) {
+            int fpes = npy_get_floatstatus_barrier((char *)self);
+            if (fpes && PyUFunc_GiveFloatingpointErrors("cast", fpes) < 0) {
+                return -1;
+            }
+        }
     }
 
     return res;
@@ -1524,6 +1435,8 @@ array_subscript(PyArrayObject *self, PyObject *op)
     int index_type;
     int index_num;
     int i, ndim, fancy_ndim;
+    NPY_cast_info cast_info = {.func = NULL};
+
     /*
      * Index info array. We can have twice as many indices as dimensions
      * (because of None). The + 1 is to not need to check as much.
@@ -1689,7 +1602,43 @@ array_subscript(PyArrayObject *self, PyObject *op)
         goto finish;
     }
 
-    if (mapiter_get(mit) < 0) {
+    /*
+     * Alignment information (swapping is never needed, since we buffer),
+     * could also check extra_op is buffered, but it should rarely matter.
+     */
+    int is_aligned = IsUintAligned(self) && IsUintAligned(mit->extra_op);
+    /*
+     * NOTE: Getting never actually casts, so we currently do not bother to do
+     *       the full checks (floating point errors) here (unlike assignment).
+     */
+    int meth_flags = NpyIter_GetTransferFlags(mit->outer);
+    if (mit->extra_op_iter) {
+        int extra_op_flags = NpyIter_GetTransferFlags(mit->extra_op_iter);
+        meth_flags = PyArrayMethod_COMBINED_FLAGS(meth_flags, extra_op_flags);
+    }
+
+    if (mit->subspace_iter != NULL) {
+        int extra_op_flags = NpyIter_GetTransferFlags(mit->subspace_iter);
+        meth_flags = PyArrayMethod_COMBINED_FLAGS(meth_flags, extra_op_flags);
+
+        NPY_ARRAYMETHOD_FLAGS transfer_flags;
+        npy_intp fixed_strides[2];
+        /*
+         * Get a dtype transfer function, since there are no
+         * buffers, this is safe.
+         */
+        NpyIter_GetInnerFixedStrideArray(mit->subspace_iter, fixed_strides);
+
+        if (PyArray_GetDTypeTransferFunction(is_aligned,
+                fixed_strides[0], fixed_strides[1],
+                PyArray_DESCR(self), PyArray_DESCR(mit->extra_op),
+                0, &cast_info, &transfer_flags) != NPY_SUCCEED) {
+            goto finish;
+        }
+        meth_flags = PyArrayMethod_COMBINED_FLAGS(meth_flags, transfer_flags);
+    }
+
+    if (mapiter_get(mit, &cast_info, meth_flags, is_aligned) < 0) {
         goto finish;
     }
 
@@ -1724,6 +1673,7 @@ array_subscript(PyArrayObject *self, PyObject *op)
     }
 
   finish:
+    NPY_cast_info_xfree(&cast_info);
     Py_XDECREF(mit);
     Py_XDECREF(view);
     /* Clean up indices */
@@ -1809,6 +1759,9 @@ array_assign_subscript(PyArrayObject *self, PyObject *ind, PyObject *op)
 
     PyArrayMapIterObject *mit = NULL;
 
+    /* When a subspace is used, casting is done manually. */
+    NPY_cast_info cast_info = {.func = NULL};
+
     if (op == NULL) {
         PyErr_SetString(PyExc_ValueError,
                         "cannot delete array elements");
@@ -1981,7 +1934,6 @@ array_assign_subscript(PyArrayObject *self, PyObject *ind, PyObject *op)
             index_num == 1 && tmp_arr) {
         /* The array being indexed has one dimension and it is a fancy index */
         PyArrayObject *ind = (PyArrayObject*)indices[0].object;
-
         /* Check if the type is equivalent */
         if (PyArray_EquivTypes(PyArray_DESCR(self),
                                    PyArray_DESCR(tmp_arr)) &&
@@ -2045,12 +1997,50 @@ array_assign_subscript(PyArrayObject *self, PyObject *ind, PyObject *op)
         }
     }
 
-    /* Can now reset the outer iterator (delayed bufalloc) */
-    if (NpyIter_Reset(mit->outer, NULL) < 0) {
+    if (PyArray_MapIterCheckIndices(mit) < 0) {
         goto fail;
     }
 
-    if (PyArray_MapIterCheckIndices(mit) < 0) {
+    /*
+     * Alignment information (swapping is never needed, since we buffer),
+     * could also check extra_op is buffered, but it should rarely matter.
+     */
+    int is_aligned = IsUintAligned(self) && IsUintAligned(mit->extra_op);
+    int meth_flags = NpyIter_GetTransferFlags(mit->outer);
+
+    if (mit->extra_op_iter) {
+        int extra_op_flags = NpyIter_GetTransferFlags(mit->extra_op_iter);
+        meth_flags = PyArrayMethod_COMBINED_FLAGS(meth_flags, extra_op_flags);
+    }
+
+    if (mit->subspace_iter != NULL) {
+        int extra_op_flags = NpyIter_GetTransferFlags(mit->subspace_iter);
+        meth_flags = PyArrayMethod_COMBINED_FLAGS(meth_flags, extra_op_flags);
+
+        NPY_ARRAYMETHOD_FLAGS transfer_flags;
+        npy_intp fixed_strides[2];
+
+        /*
+         * Get a dtype transfer function, since there are no
+         * buffers, this is safe.
+         */
+        NpyIter_GetInnerFixedStrideArray(mit->subspace_iter, fixed_strides);
+
+        if (PyArray_GetDTypeTransferFunction(is_aligned,
+                fixed_strides[1], fixed_strides[0],
+                PyArray_DESCR(mit->extra_op), PyArray_DESCR(self),
+                0, &cast_info, &transfer_flags) != NPY_SUCCEED) {
+            goto fail;
+        }
+        meth_flags = PyArrayMethod_COMBINED_FLAGS(meth_flags, transfer_flags);
+    }
+
+    if (!(meth_flags & NPY_METH_NO_FLOATINGPOINT_ERRORS)) {
+        npy_clear_floatstatus_barrier((char *)mit);
+    }
+
+    /* Can now reset the outer iterator (delayed bufalloc) */
+    if (NpyIter_Reset(mit->outer, NULL) < 0) {
         goto fail;
     }
 
@@ -2058,11 +2048,17 @@ array_assign_subscript(PyArrayObject *self, PyObject *ind, PyObject *op)
      * Could add a casting check, but apparently most assignments do
      * not care about safe casting.
      */
-
-    if (mapiter_set(mit) < 0) {
+    if (mapiter_set(mit, &cast_info, meth_flags, is_aligned) < 0) {
         goto fail;
     }
 
+    if (!(meth_flags & NPY_METH_NO_FLOATINGPOINT_ERRORS)) {
+        int fpes = npy_get_floatstatus_barrier((char *)mit);
+        if (fpes && PyUFunc_GiveFloatingpointErrors("cast", fpes) < 0) {
+            goto fail;
+        }
+    }
+
     Py_DECREF(mit);
     goto success;
 
@@ -2071,6 +2067,8 @@ array_assign_subscript(PyArrayObject *self, PyObject *ind, PyObject *op)
     Py_XDECREF((PyObject *)view);
     Py_XDECREF((PyObject *)tmp_arr);
     Py_XDECREF((PyObject *)mit);
+    NPY_cast_info_xfree(&cast_info);
+
     for (i=0; i < index_num; i++) {
         Py_XDECREF(indices[i].object);
     }
@@ -2079,6 +2077,8 @@ array_assign_subscript(PyArrayObject *self, PyObject *ind, PyObject *op)
   success:
     Py_XDECREF((PyObject *)view);
     Py_XDECREF((PyObject *)tmp_arr);
+    NPY_cast_info_xfree(&cast_info);
+
     for (i=0; i < index_num; i++) {
         Py_XDECREF(indices[i].object);
     }
@@ -2199,7 +2199,7 @@ _nonzero_indices(PyObject *myBool, PyArrayObject **arrays)
 
 
 /* Reset the map iterator to the beginning */
-NPY_NO_EXPORT void
+NPY_NO_EXPORT int
 PyArray_MapIterReset(PyArrayMapIterObject *mit)
 {
     npy_intp indval;
@@ -2207,12 +2207,16 @@ PyArray_MapIterReset(PyArrayMapIterObject *mit)
     int i;
 
     if (mit->size == 0) {
-        return;
+        return 0;
     }
 
-    NpyIter_Reset(mit->outer, NULL);
+    if (!NpyIter_Reset(mit->outer, NULL)) {
+        return -1;
+    }
     if (mit->extra_op_iter) {
-        NpyIter_Reset(mit->extra_op_iter, NULL);
+        if (!NpyIter_Reset(mit->extra_op_iter, NULL)) {
+            return -1;
+        }
 
         baseptrs[1] = mit->extra_op_ptrs[0];
     }
@@ -2229,14 +2233,16 @@ PyArray_MapIterReset(PyArrayMapIterObject *mit)
     mit->dataptr = baseptrs[0];
 
     if (mit->subspace_iter) {
-        NpyIter_ResetBasePointers(mit->subspace_iter, baseptrs, NULL);
+        if (!NpyIter_ResetBasePointers(mit->subspace_iter, baseptrs, NULL)) {
+            return -1;
+        }
         mit->iter_count = *NpyIter_GetInnerLoopSizePtr(mit->subspace_iter);
     }
     else {
         mit->iter_count = *NpyIter_GetInnerLoopSizePtr(mit->outer);
     }
 
-    return;
+    return 0;
 }
 
 
@@ -2702,13 +2708,14 @@ PyArray_MapIterNew(npy_index_info *indices , int index_num, int index_type,
     }
 
     /* create new MapIter object */
-    mit = (PyArrayMapIterObject *)PyArray_malloc(sizeof(PyArrayMapIterObject));
+    mit = (PyArrayMapIterObject *)PyArray_malloc(
+            sizeof(PyArrayMapIterObject) + sizeof(NPY_cast_info));
     if (mit == NULL) {
         Py_DECREF(intp_descr);
         return NULL;
     }
     /* set all attributes of mapiter to zero */
-    memset(mit, 0, sizeof(PyArrayMapIterObject));
+    memset(mit, 0, sizeof(PyArrayMapIterObject) + sizeof(NPY_cast_info));
     PyObject_Init((PyObject *)mit, &PyArrayMapIter_Type);
 
     Py_INCREF(arr);
@@ -2984,6 +2991,11 @@ PyArray_MapIterNew(npy_index_info *indices , int index_num, int index_type,
 
     /* If external array is iterated, and no subspace is needed */
     nops = mit->numiter;
+
+    if (!uses_subspace) {
+        outer_flags |= NPY_ITER_EXTERNAL_LOOP;
+    }
+
     if (extra_op_flags && !uses_subspace) {
         /*
          * NOTE: This small limitation should practically not matter.
@@ -3031,9 +3043,6 @@ PyArray_MapIterNew(npy_index_info *indices , int index_num, int index_type,
     if (mit->outer == NULL) {
         goto fail;
     }
-    if (!uses_subspace) {
-        NpyIter_EnableExternalLoop(mit->outer);
-    }
 
     mit->outer_next = NpyIter_GetIterNext(mit->outer, NULL);
     if (mit->outer_next == NULL) {
@@ -3171,7 +3180,7 @@ PyArray_MapIterNew(npy_index_info *indices , int index_num, int index_type,
     mit->subspace_ptrs = NpyIter_GetDataPtrArray(mit->subspace_iter);
     mit->subspace_strides = NpyIter_GetInnerStrideArray(mit->subspace_iter);
 
-    if (NpyIter_IterationNeedsAPI(mit->outer)) {
+    if (NpyIter_IterationNeedsAPI(mit->subspace_iter)) {
         mit->needs_api = 1;
         /*
          * NOTE: In this case, need to call PyErr_Occurred() after
@@ -3254,7 +3263,7 @@ PyArray_MapIterNew(npy_index_info *indices , int index_num, int index_type,
  * If copy_if_overlap != 0, check if `a` has memory overlap with any of the
  * arrays in `index` and with `extra_op`. If yes, make copies as appropriate
  * to avoid problems if `a` is modified during the iteration.
- * `iter->array` may contain a copied array (UPDATEIFCOPY/WRITEBACKIFCOPY set).
+ * `iter->array` may contain a copied array (WRITEBACKIFCOPY set).
  */
 NPY_NO_EXPORT PyObject *
 PyArray_MapIterArrayCopyIfOverlap(PyArrayObject * a, PyObject * index,
@@ -3322,9 +3331,12 @@ PyArray_MapIterArrayCopyIfOverlap(PyArrayObject * a, PyObject * index,
         goto fail;
     }
 
+    if (PyArray_MapIterReset(mit) < 0) {
+        goto fail;
+    }
+
     Py_XDECREF(a_copy);
     Py_XDECREF(subspace);
-    PyArray_MapIterReset(mit);
 
     for (i=0; i < index_num; i++) {
         Py_XDECREF(indices[i].object);
diff --git a/numpy/core/src/multiarray/mapping.h b/numpy/core/src/multiarray/mapping.h
index e929b8b3f729..4e5d06238795 100644
--- a/numpy/core/src/multiarray/mapping.h
+++ b/numpy/core/src/multiarray/mapping.h
@@ -51,7 +51,7 @@ array_assign_item(PyArrayObject *self, Py_ssize_t i, PyObject *v);
  * Prototypes for Mapping calls --- not part of the C-API
  * because only useful as part of a getitem call.
  */
-NPY_NO_EXPORT void
+NPY_NO_EXPORT int
 PyArray_MapIterReset(PyArrayMapIterObject *mit);
 
 NPY_NO_EXPORT void
diff --git a/numpy/core/src/multiarray/methods.c b/numpy/core/src/multiarray/methods.c
index 627096b3cfb2..fff772769ebb 100644
--- a/numpy/core/src/multiarray/methods.c
+++ b/numpy/core/src/multiarray/methods.c
@@ -17,7 +17,7 @@
 #include "ufunc_override.h"
 #include "array_coercion.h"
 #include "common.h"
-#include "templ_common.h" /* for npy_mul_with_overflow_intp */
+#include "templ_common.h" /* for npy_mul_sizes_with_overflow */
 #include "ctors.h"
 #include "calculation.h"
 #include "convert_datatype.h"
@@ -379,6 +379,18 @@ PyArray_GetField(PyArrayObject *self, PyArray_Descr *typed, int offset)
     static PyObject *checkfunc = NULL;
     int self_elsize, typed_elsize;
 
+    if (self == NULL) {
+        PyErr_SetString(PyExc_ValueError,
+            "self is NULL in PyArray_GetField");
+        return NULL;
+    }
+
+    if (typed == NULL) {
+        PyErr_SetString(PyExc_ValueError,
+            "typed is NULL in PyArray_GetField");
+        return NULL;
+    }
+
     /* check that we are not reinterpreting memory containing Objects. */
     if (_may_have_objects(PyArray_DESCR(self)) || _may_have_objects(typed)) {
         npy_cache_import("numpy.core._internal", "_getfield_is_safe",
@@ -457,6 +469,18 @@ PyArray_SetField(PyArrayObject *self, PyArray_Descr *dtype,
     PyObject *ret = NULL;
     int retval = 0;
 
+    if (self == NULL) {
+        PyErr_SetString(PyExc_ValueError,
+            "self is NULL in PyArray_SetField");
+        return -1;
+    }
+
+    if (dtype == NULL) {
+        PyErr_SetString(PyExc_ValueError,
+            "dtype is NULL in PyArray_SetField");
+        return -1;
+    }
+
     if (PyArray_FailUnlessWriteable(self, "assignment destination") < 0) {
         Py_DECREF(dtype);
         return -1;
@@ -859,7 +883,7 @@ array_astype(PyArrayObject *self,
      * and it's not a subtype if subok is False, then we
      * can skip the copy.
      */
-    if (forcecopy != NPY_COPY_ALWAYS && 
+    if (forcecopy != NPY_COPY_ALWAYS &&
                     (order == NPY_KEEPORDER ||
                     (order == NPY_ANYORDER &&
                         (PyArray_IS_C_CONTIGUOUS(self) ||
@@ -881,7 +905,7 @@ array_astype(PyArrayObject *self,
         Py_DECREF(dtype);
         return NULL;
     }
-    
+
     if (!PyArray_CanCastArrayTo(self, dtype, casting)) {
         PyErr_Clear();
         npy_set_invalid_cast_error(
@@ -925,6 +949,13 @@ array_astype(PyArrayObject *self,
 /* default sub-type implementation */
 
 
+static PyObject *
+array_finalizearray(PyArrayObject *self, PyObject *obj)
+{
+    Py_RETURN_NONE;
+}
+
+
 static PyObject *
 array_wraparray(PyArrayObject *self, PyObject *args)
 {
@@ -1330,6 +1361,10 @@ array_sort(PyArrayObject *self,
             return NULL;
         }
         newd = PyArray_DescrNew(saved);
+        if (newd == NULL) {
+            Py_DECREF(new_name);
+            return NULL;
+        }
         Py_DECREF(newd->names);
         newd->names = new_name;
         ((PyArrayObject_fields *)self)->descr = newd;
@@ -1392,6 +1427,10 @@ array_partition(PyArrayObject *self,
             return NULL;
         }
         newd = PyArray_DescrNew(saved);
+        if (newd == NULL) {
+            Py_DECREF(new_name);
+            return NULL;
+        }
         Py_DECREF(newd->names);
         newd->names = new_name;
         ((PyArrayObject_fields *)self)->descr = newd;
@@ -1455,6 +1494,10 @@ array_argsort(PyArrayObject *self,
             return NULL;
         }
         newd = PyArray_DescrNew(saved);
+        if (newd == NULL) {
+            Py_DECREF(new_name);
+            return NULL;
+        }
         Py_DECREF(newd->names);
         newd->names = new_name;
         ((PyArrayObject_fields *)self)->descr = newd;
@@ -1512,6 +1555,10 @@ array_argpartition(PyArrayObject *self,
             return NULL;
         }
         newd = PyArray_DescrNew(saved);
+        if (newd == NULL) {
+            Py_DECREF(new_name);
+            return NULL;
+        }
         Py_DECREF(newd->names);
         newd->names = new_name;
         ((PyArrayObject_fields *)self)->descr = newd;
@@ -1555,17 +1602,17 @@ array_searchsorted(PyArrayObject *self,
     return PyArray_Return((PyArrayObject *)PyArray_SearchSorted(self, keys, side, sorter));
 }
 
-static void
+static int
 _deepcopy_call(char *iptr, char *optr, PyArray_Descr *dtype,
                PyObject *deepcopy, PyObject *visit)
 {
     if (!PyDataType_REFCHK(dtype)) {
-        return;
+        return 0;
     }
     else if (PyDataType_HASFIELDS(dtype)) {
         PyObject *key, *value, *title = NULL;
         PyArray_Descr *new;
-        int offset;
+        int offset, res;
         Py_ssize_t pos = 0;
         while (PyDict_Next(dtype->fields, &pos, &key, &value)) {
             if (NPY_TITLE_KEY(key, value)) {
@@ -1573,10 +1620,13 @@ _deepcopy_call(char *iptr, char *optr, PyArray_Descr *dtype,
             }
             if (!PyArg_ParseTuple(value, "Oi|O", &new, &offset,
                                   &title)) {
-                return;
+                return -1;
+            }
+            res = _deepcopy_call(iptr + offset, optr + offset, new,
+                                 deepcopy, visit);
+            if (res < 0) {
+                return -1;
             }
-            _deepcopy_call(iptr + offset, optr + offset, new,
-                           deepcopy, visit);
         }
     }
     else {
@@ -1584,13 +1634,20 @@ _deepcopy_call(char *iptr, char *optr, PyArray_Descr *dtype,
         PyObject *res;
         memcpy(&itemp, iptr, sizeof(itemp));
         memcpy(&otemp, optr, sizeof(otemp));
-        Py_XINCREF(itemp);
+        if (itemp == NULL) {
+            itemp = Py_None;
+        }
+        Py_INCREF(itemp);
         /* call deepcopy on this argument */
         res = PyObject_CallFunctionObjArgs(deepcopy, itemp, visit, NULL);
-        Py_XDECREF(itemp);
+        Py_DECREF(itemp);
+        if (res == NULL) {
+            return -1;
+        }
         Py_XDECREF(otemp);
         memcpy(optr, &res, sizeof(res));
     }
+    return 0;
 
 }
 
@@ -1600,13 +1657,14 @@ array_deepcopy(PyArrayObject *self, PyObject *args)
 {
     PyArrayObject *copied_array;
     PyObject *visit;
-    NpyIter *iter;
+    NpyIter *iter = NULL;
     NpyIter_IterNextFunc *iternext;
     char *data;
     char **dataptr;
     npy_intp *strideptr, *innersizeptr;
     npy_intp stride, count;
     PyObject *copy, *deepcopy;
+    int deepcopy_res;
 
     if (!PyArg_ParseTuple(args, "O:__deepcopy__", &visit)) {
         return NULL;
@@ -1615,60 +1673,73 @@ array_deepcopy(PyArrayObject *self, PyObject *args)
     if (copied_array == NULL) {
         return NULL;
     }
-    if (PyDataType_REFCHK(PyArray_DESCR(self))) {
-        copy = PyImport_ImportModule("copy");
-        if (copy == NULL) {
-            Py_DECREF(copied_array);
-            return NULL;
-        }
-        deepcopy = PyObject_GetAttrString(copy, "deepcopy");
-        Py_DECREF(copy);
-        if (deepcopy == NULL) {
-            Py_DECREF(copied_array);
-            return NULL;
-        }
-        iter = NpyIter_New(copied_array,
-                           NPY_ITER_READWRITE |
-                           NPY_ITER_EXTERNAL_LOOP |
-                           NPY_ITER_REFS_OK |
-                           NPY_ITER_ZEROSIZE_OK,
-                           NPY_KEEPORDER, NPY_NO_CASTING,
-                           NULL);
-        if (iter == NULL) {
-            Py_DECREF(deepcopy);
-            Py_DECREF(copied_array);
-            return NULL;
-        }
-        if (NpyIter_GetIterSize(iter) != 0) {
-            iternext = NpyIter_GetIterNext(iter, NULL);
-            if (iternext == NULL) {
-                NpyIter_Deallocate(iter);
-                Py_DECREF(deepcopy);
-                Py_DECREF(copied_array);
-                return NULL;
-            }
 
-            dataptr = NpyIter_GetDataPtrArray(iter);
-            strideptr = NpyIter_GetInnerStrideArray(iter);
-            innersizeptr = NpyIter_GetInnerLoopSizePtr(iter);
-
-            do {
-                data = *dataptr;
-                stride = *strideptr;
-                count = *innersizeptr;
-                while (count--) {
-                    _deepcopy_call(data, data, PyArray_DESCR(copied_array),
-                                   deepcopy, visit);
-                    data += stride;
+    if (!PyDataType_REFCHK(PyArray_DESCR(self))) {
+        return (PyObject *)copied_array;
+    }
+
+    /* If the array contains objects, need to deepcopy them as well */
+    copy = PyImport_ImportModule("copy");
+    if (copy == NULL) {
+        Py_DECREF(copied_array);
+        return NULL;
+    }
+    deepcopy = PyObject_GetAttrString(copy, "deepcopy");
+    Py_DECREF(copy);
+    if (deepcopy == NULL) {
+        goto error;
+    }
+    iter = NpyIter_New(copied_array,
+                        NPY_ITER_READWRITE |
+                        NPY_ITER_EXTERNAL_LOOP |
+                        NPY_ITER_REFS_OK |
+                        NPY_ITER_ZEROSIZE_OK,
+                        NPY_KEEPORDER, NPY_NO_CASTING,
+                        NULL);
+    if (iter == NULL) {
+        goto error;
+    }
+    if (NpyIter_GetIterSize(iter) != 0) {
+        iternext = NpyIter_GetIterNext(iter, NULL);
+        if (iternext == NULL) {
+            goto error;
+        }
+
+        dataptr = NpyIter_GetDataPtrArray(iter);
+        strideptr = NpyIter_GetInnerStrideArray(iter);
+        innersizeptr = NpyIter_GetInnerLoopSizePtr(iter);
+
+        do {
+            data = *dataptr;
+            stride = *strideptr;
+            count = *innersizeptr;
+            while (count--) {
+                deepcopy_res = _deepcopy_call(data, data, PyArray_DESCR(copied_array),
+                                                deepcopy, visit);
+                if (deepcopy_res == -1) {
+                    goto error;
                 }
-            } while (iternext(iter));
-        }
-        NpyIter_Deallocate(iter);
-        Py_DECREF(deepcopy);
+
+                data += stride;
+            }
+        } while (iternext(iter));
+    }
+
+    Py_DECREF(deepcopy);
+    if (!NpyIter_Deallocate(iter)) {
+        Py_DECREF(copied_array);
+        return NULL;
     }
-    return (PyObject*) copied_array;
+    return (PyObject *)copied_array;
+
+  error:
+    Py_DECREF(deepcopy);
+    Py_DECREF(copied_array);
+    NpyIter_Deallocate(iter);
+    return NULL;
 }
 
+
 /* Convert Array to flat list (using getitem) */
 static PyObject *
 _getlist_pkl(PyArrayObject *self)
@@ -1934,7 +2005,7 @@ array_setstate(PyArrayObject *self, PyObject *args)
     PyObject *rawdata = NULL;
     char *datastr;
     Py_ssize_t len;
-    npy_intp size, dimensions[NPY_MAXDIMS];
+    npy_intp dimensions[NPY_MAXDIMS];
     int nd;
     npy_intp nbytes;
     int overflowed;
@@ -1978,8 +2049,7 @@ array_setstate(PyArrayObject *self, PyObject *args)
      */
     size_t n_tofree = PyArray_NBYTES(self);
     if (n_tofree == 0) {
-        PyArray_Descr *dtype = PyArray_DESCR(self);
-        n_tofree = dtype->elsize ? dtype->elsize : 1;
+        n_tofree = 1;
     }
     Py_XDECREF(PyArray_DESCR(self));
     fa->descr = typecode;
@@ -1988,17 +2058,39 @@ array_setstate(PyArrayObject *self, PyObject *args)
     if (nd < 0) {
         return NULL;
     }
-    size = PyArray_MultiplyList(dimensions, nd);
-    if (size < 0) {
-        /* More items than are addressable */
-        return PyErr_NoMemory();
+    /*
+     * We should do two things here:
+     * 1. Validate the input, that it is neither invalid, nor "too big"
+     *    ("too big" ignores dimensios of size 0).
+     * 2. Find `PyArray_NBYTES` of the result, as this is what we may need to
+     *    copy from the pickled data (may not match allocation currently if 0).
+     * Compare with `PyArray_NewFromDescr`, raise MemoryError for simplicity.
+     */
+    npy_bool empty = NPY_FALSE;
+    nbytes = 1;
+    for (int i = 0; i < nd; i++) {
+        if (dimensions[i] < 0) {
+            PyErr_SetString(PyExc_TypeError,
+                    "impossible dimension while unpickling array");
+            return NULL;
+        }
+        if (dimensions[i] == 0) {
+            empty = NPY_TRUE;
+        }
+        overflowed = npy_mul_sizes_with_overflow(
+                &nbytes, nbytes, dimensions[i]);
+        if (overflowed) {
+            return PyErr_NoMemory();
+        }
     }
-    overflowed = npy_mul_with_overflow_intp(
-        &nbytes, size, PyArray_DESCR(self)->elsize);
+    overflowed = npy_mul_sizes_with_overflow(
+            &nbytes, nbytes, PyArray_DESCR(self)->elsize);
     if (overflowed) {
-        /* More bytes than are addressable */
         return PyErr_NoMemory();
     }
+    if (empty) {
+        nbytes = 0;
+    }
 
     if (PyDataType_FLAGCHK(typecode, NPY_LIST_PICKLE)) {
         if (!PyList_Check(rawdata)) {
@@ -2039,8 +2131,7 @@ array_setstate(PyArrayObject *self, PyObject *args)
 
         if (len != nbytes) {
             PyErr_SetString(PyExc_ValueError,
-                            "buffer size does not"  \
-                            " match array size");
+                    "buffer size does not match array size");
             Py_DECREF(rawdata);
             return NULL;
         }
@@ -2065,7 +2156,6 @@ array_setstate(PyArrayObject *self, PyObject *args)
     fa->base = NULL;
 
     PyArray_CLEARFLAGS(self, NPY_ARRAY_WRITEBACKIFCOPY);
-    PyArray_CLEARFLAGS(self, NPY_ARRAY_UPDATEIFCOPY);
 
     if (PyArray_DIMS(self) != NULL) {
         npy_free_cache_dim_array(self);
@@ -2099,19 +2189,19 @@ array_setstate(PyArrayObject *self, PyObject *args)
         if (!IsAligned(self) || swap || (len <= 1000)) {
             npy_intp num = PyArray_NBYTES(self);
             if (num == 0) {
-                Py_DECREF(rawdata);
-                Py_RETURN_NONE;
+                num = 1;
             }
             /* Store the handler in case the default is modified */
             Py_XDECREF(fa->mem_handler);
             fa->mem_handler = PyDataMem_GetHandler();
             if (fa->mem_handler == NULL) {
+                Py_CLEAR(fa->mem_handler);
                 Py_DECREF(rawdata);
                 return NULL;
             }
             fa->data = PyDataMem_UserNEW(num, PyArray_HANDLER(self));
             if (PyArray_DATA(self) == NULL) {
-                Py_DECREF(fa->mem_handler);
+                Py_CLEAR(fa->mem_handler);
                 Py_DECREF(rawdata);
                 return PyErr_NoMemory();
             }
@@ -2130,6 +2220,11 @@ array_setstate(PyArrayObject *self, PyObject *args)
                 }
                 else {
                     fa->descr = PyArray_DescrNew(typecode);
+                    if (fa->descr == NULL) {
+                        Py_CLEAR(fa->mem_handler);
+                        Py_DECREF(rawdata);
+                        return NULL;
+                    }
                     if (PyArray_DESCR(self)->byteorder == NPY_BIG) {
                         PyArray_DESCR(self)->byteorder = NPY_LITTLE;
                     }
@@ -2140,7 +2235,7 @@ array_setstate(PyArrayObject *self, PyObject *args)
                 Py_DECREF(typecode);
             }
             else {
-                memcpy(PyArray_DATA(self), datastr, num);
+                memcpy(PyArray_DATA(self), datastr, PyArray_NBYTES(self));
             }
             PyArray_ENABLEFLAGS(self, NPY_ARRAY_OWNDATA);
             fa->base = NULL;
@@ -2159,10 +2254,10 @@ array_setstate(PyArrayObject *self, PyObject *args)
     }
     else {
         npy_intp num = PyArray_NBYTES(self);
-        int elsize = PyArray_DESCR(self)->elsize;
-        if (num == 0 || elsize == 0) {
-            Py_RETURN_NONE;
+        if (num == 0) {
+            num = 1;
         }
+
         /* Store the functions in case the default handler is modified */
         Py_XDECREF(fa->mem_handler);
         fa->mem_handler = PyDataMem_GetHandler();
@@ -2171,7 +2266,7 @@ array_setstate(PyArrayObject *self, PyObject *args)
         }
         fa->data = PyDataMem_UserNEW(num, PyArray_HANDLER(self));
         if (PyArray_DATA(self) == NULL) {
-            Py_DECREF(fa->mem_handler);
+            Py_CLEAR(fa->mem_handler);
             return PyErr_NoMemory();
         }
         if (PyDataType_FLAGCHK(PyArray_DESCR(self), NPY_NEEDS_INIT)) {
@@ -2180,7 +2275,6 @@ array_setstate(PyArrayObject *self, PyObject *args)
         PyArray_ENABLEFLAGS(self, NPY_ARRAY_OWNDATA);
         fa->base = NULL;
         if (_setlist_pkl(self, rawdata) < 0) {
-            Py_DECREF(fa->mem_handler);
             return NULL;
         }
     }
@@ -2246,7 +2340,7 @@ array_dumps(PyArrayObject *self, PyObject *args, PyObject *kwds)
 
 
 static PyObject *
-array_sizeof(PyArrayObject *self)
+array_sizeof(PyArrayObject *self, PyObject *NPY_UNUSED(args))
 {
     /* object + dimension and strides */
     Py_ssize_t nbytes = Py_TYPE(self)->tp_basicsize +
@@ -2621,7 +2715,6 @@ array_setflags(PyArrayObject *self, PyObject *args, PyObject *kwds)
         }
         else {
             PyArray_CLEARFLAGS(self, NPY_ARRAY_WRITEBACKIFCOPY);
-            PyArray_CLEARFLAGS(self, NPY_ARRAY_UPDATEIFCOPY);
             Py_XDECREF(fa->base);
             fa->base = NULL;
         }
@@ -2745,7 +2838,7 @@ array_class_getitem(PyObject *cls, PyObject *args)
     Py_ssize_t args_len;
 
     args_len = PyTuple_Check(args) ? PyTuple_Size(args) : 1;
-    if (args_len != 2) {
+    if ((args_len > 2) || (args_len == 0)) {
         return PyErr_Format(PyExc_TypeError,
                             "Too %s arguments for %s",
                             args_len > 2 ? "many" : "few",
@@ -2769,6 +2862,9 @@ NPY_NO_EXPORT PyMethodDef array_methods[] = {
     {"__array_prepare__",
         (PyCFunction)array_preparearray,
         METH_VARARGS, NULL},
+    {"__array_finalize__",
+        (PyCFunction)array_finalizearray,
+        METH_O, NULL},
     {"__array_wrap__",
         (PyCFunction)array_wraparray,
         METH_VARARGS, NULL},
diff --git a/numpy/core/src/multiarray/multiarraymodule.c b/numpy/core/src/multiarray/multiarraymodule.c
index dbf5ab161dd1..b2925f758718 100644
--- a/numpy/core/src/multiarray/multiarraymodule.c
+++ b/numpy/core/src/multiarray/multiarraymodule.c
@@ -62,26 +62,33 @@ NPY_NO_EXPORT int NPY_NUMUSERTYPES = 0;
 #include "multiarraymodule.h"
 #include "cblasfuncs.h"
 #include "vdot.h"
-#include "templ_common.h" /* for npy_mul_with_overflow_intp */
+#include "templ_common.h" /* for npy_mul_sizes_with_overflow */
 #include "compiled_base.h"
 #include "mem_overlap.h"
 #include "typeinfo.h"
 
 #include "get_attr_string.h"
 #include "experimental_public_dtype_api.h"  /* _get_experimental_dtype_api */
+#include "textreading/readtext.h"  /* _readtext_from_file_object */
 
 #include "npy_dlpack.h"
 
+#include "umathmodule.h"
+
 /*
  *****************************************************************************
  **                    INCLUDE GENERATED CODE                               **
  *****************************************************************************
  */
-#include "funcs.inc"
-#include "umathmodule.h"
+/* __ufunc_api.c define is the PyUFunc_API table: */
+#include "__ufunc_api.c"
 
 NPY_NO_EXPORT int initscalarmath(PyObject *);
 NPY_NO_EXPORT int set_matmul_flags(PyObject *d); /* in ufunc_object.c */
+/* From umath/string_ufuncs.cpp/h */
+NPY_NO_EXPORT PyObject *
+_umath_strings_richcompare(
+        PyArrayObject *self, PyArrayObject *other, int cmp_op, int rstrip);
 
 /*
  * global variable to determine if legacy printing is enabled, accessible from
@@ -125,16 +132,22 @@ PyArray_GetPriority(PyObject *obj, double default_)
         return NPY_SCALAR_PRIORITY;
     }
 
-    ret = PyArray_LookupSpecial_OnInstance(obj, "__array_priority__");
+    ret = PyArray_LookupSpecial_OnInstance(obj, npy_ma_str_array_priority);
     if (ret == NULL) {
         if (PyErr_Occurred()) {
-            PyErr_Clear(); /* TODO[gh-14801]: propagate crashes during attribute access? */
+            /* TODO[gh-14801]: propagate crashes during attribute access? */
+            PyErr_Clear();
         }
         return default_;
     }
 
     priority = PyFloat_AsDouble(ret);
     Py_DECREF(ret);
+    if (error_converting(priority)) {
+        /* TODO[gh-14801]: propagate crashes for bad priority? */
+        PyErr_Clear();
+        return default_;
+    }
     return priority;
 }
 
@@ -181,7 +194,7 @@ PyArray_OverflowMultiplyList(npy_intp const *l1, int n)
         if (dim == 0) {
             return 0;
         }
-        if (npy_mul_with_overflow_intp(&prod, prod, dim)) {
+        if (npy_mul_sizes_with_overflow(&prod, prod, dim)) {
             return -1;
         }
     }
@@ -423,7 +436,7 @@ PyArray_ConcatenateArrays(int narrays, PyArrayObject **arrays, int axis,
             /* Validate that the rest of the dimensions match */
             else if (shape[idim] != arr_shape[idim]) {
                 PyErr_Format(PyExc_ValueError,
-                             "all the input array dimensions for the "
+                             "all the input array dimensions except for the "
                              "concatenation axis must match exactly, but "
                              "along dimension %d, the array at index %d has "
                              "size %d and the array at index %d has size %d",
@@ -886,11 +899,15 @@ PyArray_InnerProduct(PyObject *op1, PyObject *op2)
     int i;
     PyObject* ret = NULL;
 
-    typenum = PyArray_ObjectType(op1, 0);
-    if (typenum == NPY_NOTYPE && PyErr_Occurred()) {
+    typenum = PyArray_ObjectType(op1, NPY_NOTYPE);
+    if (typenum == NPY_NOTYPE) {
         return NULL;
     }
     typenum = PyArray_ObjectType(op2, typenum);
+    if (typenum == NPY_NOTYPE) {
+        return NULL;
+    }
+
     typec = PyArray_DescrFromType(typenum);
     if (typec == NULL) {
         if (!PyErr_Occurred()) {
@@ -978,11 +995,15 @@ PyArray_MatrixProduct2(PyObject *op1, PyObject *op2, PyArrayObject* out)
     PyArray_Descr *typec = NULL;
     NPY_BEGIN_THREADS_DEF;
 
-    typenum = PyArray_ObjectType(op1, 0);
-    if (typenum == NPY_NOTYPE && PyErr_Occurred()) {
+    typenum = PyArray_ObjectType(op1, NPY_NOTYPE);
+    if (typenum == NPY_NOTYPE) {
         return NULL;
     }
     typenum = PyArray_ObjectType(op2, typenum);
+    if (typenum == NPY_NOTYPE) {
+        return NULL;
+    }
+
     typec = PyArray_DescrFromType(typenum);
     if (typec == NULL) {
         if (!PyErr_Occurred()) {
@@ -1126,6 +1147,15 @@ PyArray_MatrixProduct2(PyObject *op1, PyObject *op2, PyArrayObject* out)
 NPY_NO_EXPORT PyObject *
 PyArray_CopyAndTranspose(PyObject *op)
 {
+    /* DEPRECATED 2022-09-30, NumPy 1.24 - see gh-22313 */
+    if (DEPRECATE(
+            "fastCopyAndTranspose and the underlying C function "
+            "PyArray_CopyAndTranspose have been deprecated.\n\n"
+            "Use the transpose method followed by a C-order copy instead, "
+            "e.g. ``arr.T.copy()``") < 0) {
+        return NULL;
+    }
+
     PyArrayObject *arr, *tmp, *ret;
     int i;
     npy_intp new_axes_values[NPY_MAXDIMS];
@@ -1351,8 +1381,14 @@ PyArray_Correlate2(PyObject *op1, PyObject *op2, int mode)
     int inverted;
     int st;
 
-    typenum = PyArray_ObjectType(op1, 0);
+    typenum = PyArray_ObjectType(op1, NPY_NOTYPE);
+    if (typenum == NPY_NOTYPE) {
+        return NULL;
+    }
     typenum = PyArray_ObjectType(op2, typenum);
+    if (typenum == NPY_NOTYPE) {
+        return NULL;
+    }
 
     typec = PyArray_DescrFromType(typenum);
     Py_INCREF(typec);
@@ -1418,8 +1454,14 @@ PyArray_Correlate(PyObject *op1, PyObject *op2, int mode)
     int unused;
     PyArray_Descr *typec;
 
-    typenum = PyArray_ObjectType(op1, 0);
+    typenum = PyArray_ObjectType(op1, NPY_NOTYPE);
+    if (typenum == NPY_NOTYPE) {
+        return NULL;
+    }
     typenum = PyArray_ObjectType(op2, typenum);
+    if (typenum == NPY_NOTYPE) {
+        return NULL;
+    }
 
     typec = PyArray_DescrFromType(typenum);
     Py_INCREF(typec);
@@ -1478,11 +1520,30 @@ PyArray_EquivTypes(PyArray_Descr *type1, PyArray_Descr *type2)
     if (type1 == type2) {
         return 1;
     }
+
+    if (Py_TYPE(Py_TYPE(type1)) == &PyType_Type) {
+        /*
+         * 2021-12-17: This case is nonsense and should be removed eventually!
+         *
+         * boost::python has/had a bug effectively using EquivTypes with
+         * `type(arbitrary_obj)`.  That is clearly wrong as that cannot be a
+         * `PyArray_Descr *`.  We assume that `type(type(type(arbitrary_obj))`
+         * is always in practice `type` (this is the type of the metaclass),
+         * but for our descriptors, `type(type(descr))` is DTypeMeta.
+         *
+         * In that case, we just return False.  There is a possibility that
+         * this actually _worked_ effectively (returning 1 sometimes).
+         * We ignore that possibility for simplicity; it really is not our bug.
+         */
+        return 0;
+    }
+
     /*
      * Do not use PyArray_CanCastTypeTo because it supports legacy flexible
      * dtypes as input.
      */
-    NPY_CASTING safety = PyArray_GetCastSafety(type1, type2, NULL);
+    npy_intp view_offset;
+    NPY_CASTING safety = PyArray_GetCastInfo(type1, type2, NULL, &view_offset);
     if (safety < 0) {
         PyErr_Clear();
         return 0;
@@ -1513,8 +1574,9 @@ PyArray_EquivTypenums(int typenum1, int typenum2)
 
 /*** END C-API FUNCTIONS **/
 /*
- * NPY_RELAXED_STRIDES_CHECKING: If the strides logic is changed, the
- * order specific stride setting is not necessary.
+ * NOTE: The order specific stride setting is not necessary to preserve
+ *       contiguity and could be removed.  However, this way the resulting
+ *       strides strides look better for fortran order inputs.
  */
 static NPY_STEALS_REF_TO_ARG(1) PyObject *
 _prepend_ones(PyArrayObject *arr, int nd, int ndmin, NPY_ORDER order)
@@ -1594,12 +1656,31 @@ _array_fromobject_generic(
                 goto finish;
             }
         }
-        /* One more chance */
+        /* One more chance for faster exit if user specified the dtype. */
         oldtype = PyArray_DESCR(oparr);
         if (PyArray_EquivTypes(oldtype, type)) {
             if (copy != NPY_COPY_ALWAYS && STRIDING_OK(oparr, order)) {
-                Py_INCREF(op);
-                ret = oparr;
+                if (oldtype == type) {
+                    Py_INCREF(op);
+                    ret = oparr;
+                }
+                else {
+                    /* Create a new PyArrayObject from the caller's
+                     * PyArray_Descr. Use the reference `op` as the base
+                     * object. */
+                    Py_INCREF(type);
+                    ret = (PyArrayObject *)PyArray_NewFromDescrAndBase(
+                            Py_TYPE(op),
+                            type,
+                            PyArray_NDIM(oparr),
+                            PyArray_DIMS(oparr),
+                            PyArray_STRIDES(oparr),
+                            PyArray_DATA(oparr),
+                            PyArray_FLAGS(oparr),
+                            op,
+                            op
+                            );
+                }
                 goto finish;
             }
             else {
@@ -1673,7 +1754,7 @@ array_array(PyObject *NPY_UNUSED(ignored),
     int ndmin = 0;
     PyArray_Descr *type = NULL;
     NPY_ORDER order = NPY_KEEPORDER;
-    PyObject *like = NULL;
+    PyObject *like = Py_None;
     NPY_PREPARE_ARGPARSER;
 
     if (len_args != 1 || (kwnames != NULL)) {
@@ -1689,7 +1770,7 @@ array_array(PyObject *NPY_UNUSED(ignored),
             Py_XDECREF(type);
             return NULL;
         }
-        if (like != NULL) {
+        if (like != Py_None) {
             PyObject *deferred = array_implement_c_array_function_creation(
                     "array", like, NULL, NULL, args, len_args, kwnames);
             if (deferred != Py_NotImplemented) {
@@ -1716,7 +1797,7 @@ array_asarray(PyObject *NPY_UNUSED(ignored),
     PyObject *op;
     PyArray_Descr *type = NULL;
     NPY_ORDER order = NPY_KEEPORDER;
-    PyObject *like = NULL;
+    PyObject *like = Py_None;
     NPY_PREPARE_ARGPARSER;
 
     if (len_args != 1 || (kwnames != NULL)) {
@@ -1729,7 +1810,7 @@ array_asarray(PyObject *NPY_UNUSED(ignored),
             Py_XDECREF(type);
             return NULL;
         }
-        if (like != NULL) {
+        if (like != Py_None) {
             PyObject *deferred = array_implement_c_array_function_creation(
                     "asarray", like, NULL, NULL, args, len_args, kwnames);
             if (deferred != Py_NotImplemented) {
@@ -1755,7 +1836,7 @@ array_asanyarray(PyObject *NPY_UNUSED(ignored),
     PyObject *op;
     PyArray_Descr *type = NULL;
     NPY_ORDER order = NPY_KEEPORDER;
-    PyObject *like = NULL;
+    PyObject *like = Py_None;
     NPY_PREPARE_ARGPARSER;
 
     if (len_args != 1 || (kwnames != NULL)) {
@@ -1768,7 +1849,7 @@ array_asanyarray(PyObject *NPY_UNUSED(ignored),
             Py_XDECREF(type);
             return NULL;
         }
-        if (like != NULL) {
+        if (like != Py_None) {
             PyObject *deferred = array_implement_c_array_function_creation(
                     "asanyarray", like, NULL, NULL, args, len_args, kwnames);
             if (deferred != Py_NotImplemented) {
@@ -1794,7 +1875,7 @@ array_ascontiguousarray(PyObject *NPY_UNUSED(ignored),
 {
     PyObject *op;
     PyArray_Descr *type = NULL;
-    PyObject *like = NULL;
+    PyObject *like = Py_None;
     NPY_PREPARE_ARGPARSER;
 
     if (len_args != 1 || (kwnames != NULL)) {
@@ -1806,7 +1887,7 @@ array_ascontiguousarray(PyObject *NPY_UNUSED(ignored),
             Py_XDECREF(type);
             return NULL;
         }
-        if (like != NULL) {
+        if (like != Py_None) {
             PyObject *deferred = array_implement_c_array_function_creation(
                     "ascontiguousarray", like, NULL, NULL, args, len_args, kwnames);
             if (deferred != Py_NotImplemented) {
@@ -1832,7 +1913,7 @@ array_asfortranarray(PyObject *NPY_UNUSED(ignored),
 {
     PyObject *op;
     PyArray_Descr *type = NULL;
-    PyObject *like = NULL;
+    PyObject *like = Py_None;
     NPY_PREPARE_ARGPARSER;
 
     if (len_args != 1 || (kwnames != NULL)) {
@@ -1844,7 +1925,7 @@ array_asfortranarray(PyObject *NPY_UNUSED(ignored),
             Py_XDECREF(type);
             return NULL;
         }
-        if (like != NULL) {
+        if (like != Py_None) {
             PyObject *deferred = array_implement_c_array_function_creation(
                     "asfortranarray", like, NULL, NULL, args, len_args, kwnames);
             if (deferred != Py_NotImplemented) {
@@ -1917,7 +1998,7 @@ array_empty(PyObject *NPY_UNUSED(ignored),
     NPY_ORDER order = NPY_CORDER;
     npy_bool is_f_order;
     PyArrayObject *ret = NULL;
-    PyObject *like = NULL;
+    PyObject *like = Py_None;
     NPY_PREPARE_ARGPARSER;
 
     if (npy_parse_arguments("empty", args, len_args, kwnames,
@@ -1929,7 +2010,7 @@ array_empty(PyObject *NPY_UNUSED(ignored),
         goto fail;
     }
 
-    if (like != NULL) {
+    if (like != Py_None) {
         PyObject *deferred = array_implement_c_array_function_creation(
                 "empty", like, NULL, NULL, args, len_args, kwnames);
         if (deferred != Py_NotImplemented) {
@@ -2119,7 +2200,7 @@ array_zeros(PyObject *NPY_UNUSED(ignored),
     NPY_ORDER order = NPY_CORDER;
     npy_bool is_f_order = NPY_FALSE;
     PyArrayObject *ret = NULL;
-    PyObject *like = NULL;
+    PyObject *like = Py_None;
     NPY_PREPARE_ARGPARSER;
 
     if (npy_parse_arguments("zeros", args, len_args, kwnames,
@@ -2132,7 +2213,7 @@ array_zeros(PyObject *NPY_UNUSED(ignored),
     }
 
 
-    if (like != NULL) {
+    if (like != Py_None) {
         PyObject *deferred = array_implement_c_array_function_creation(
                 "zeros", like, NULL, NULL, args, len_args, kwnames);
         if (deferred != Py_NotImplemented) {
@@ -2195,7 +2276,7 @@ array_fromstring(PyObject *NPY_UNUSED(ignored), PyObject *args, PyObject *keywds
     char *sep = NULL;
     Py_ssize_t s;
     static char *kwlist[] = {"string", "dtype", "count", "sep", "like", NULL};
-    PyObject *like = NULL;
+    PyObject *like = Py_None;
     PyArray_Descr *descr = NULL;
 
     if (!PyArg_ParseTupleAndKeywords(args, keywds,
@@ -2204,7 +2285,7 @@ array_fromstring(PyObject *NPY_UNUSED(ignored), PyObject *args, PyObject *keywds
         Py_XDECREF(descr);
         return NULL;
     }
-    if (like != NULL) {
+    if (like != Py_None) {
         PyObject *deferred = array_implement_c_array_function_creation(
                 "fromstring", like, args, keywds, NULL, 0, NULL);
         if (deferred != Py_NotImplemented) {
@@ -2236,7 +2317,7 @@ array_fromfile(PyObject *NPY_UNUSED(ignored), PyObject *args, PyObject *keywds)
     char *sep = "";
     Py_ssize_t nin = -1;
     static char *kwlist[] = {"file", "dtype", "count", "sep", "offset", "like", NULL};
-    PyObject *like = NULL;
+    PyObject *like = Py_None;
     PyArray_Descr *type = NULL;
     int own;
     npy_off_t orig_pos = 0, offset = 0;
@@ -2249,7 +2330,7 @@ array_fromfile(PyObject *NPY_UNUSED(ignored), PyObject *args, PyObject *keywds)
         return NULL;
     }
 
-    if (like != NULL) {
+    if (like != Py_None) {
         PyObject *deferred = array_implement_c_array_function_creation(
                 "fromfile", like, args, keywds, NULL, 0, NULL);
         if (deferred != Py_NotImplemented) {
@@ -2326,7 +2407,7 @@ array_fromiter(PyObject *NPY_UNUSED(ignored), PyObject *args, PyObject *keywds)
     PyObject *iter;
     Py_ssize_t nin = -1;
     static char *kwlist[] = {"iter", "dtype", "count", "like", NULL};
-    PyObject *like = NULL;
+    PyObject *like = Py_None;
     PyArray_Descr *descr = NULL;
 
     if (!PyArg_ParseTupleAndKeywords(args, keywds,
@@ -2335,7 +2416,7 @@ array_fromiter(PyObject *NPY_UNUSED(ignored), PyObject *args, PyObject *keywds)
         Py_XDECREF(descr);
         return NULL;
     }
-    if (like != NULL) {
+    if (like != Py_None) {
         PyObject *deferred = array_implement_c_array_function_creation(
                 "fromiter", like, args, keywds, NULL, 0, NULL);
         if (deferred != Py_NotImplemented) {
@@ -2353,7 +2434,7 @@ array_frombuffer(PyObject *NPY_UNUSED(ignored), PyObject *args, PyObject *keywds
     PyObject *obj = NULL;
     Py_ssize_t nin = -1, offset = 0;
     static char *kwlist[] = {"buffer", "dtype", "count", "offset", "like", NULL};
-    PyObject *like = NULL;
+    PyObject *like = Py_None;
     PyArray_Descr *type = NULL;
 
     if (!PyArg_ParseTupleAndKeywords(args, keywds,
@@ -2363,7 +2444,7 @@ array_frombuffer(PyObject *NPY_UNUSED(ignored), PyObject *args, PyObject *keywds
         return NULL;
     }
 
-    if (like != NULL) {
+    if (like != Py_None) {
         PyObject *deferred = array_implement_c_array_function_creation(
                 "frombuffer", like, args, keywds, NULL, 0, NULL);
         if (deferred != Py_NotImplemented) {
@@ -2480,8 +2561,14 @@ array_vdot(PyObject *NPY_UNUSED(dummy), PyObject *args)
      * Conjugating dot product using the BLAS for vectors.
      * Flattens both op1 and op2 before dotting.
      */
-    typenum = PyArray_ObjectType(op1, 0);
+    typenum = PyArray_ObjectType(op1, NPY_NOTYPE);
+    if (typenum == NPY_NOTYPE) {
+        return NULL;
+    }
     typenum = PyArray_ObjectType(op2, typenum);
+    if (typenum == NPY_NOTYPE) {
+        return NULL;
+    }
 
     type = PyArray_DescrFromType(typenum);
     Py_INCREF(type);
@@ -2934,7 +3021,7 @@ array_fastCopyAndTranspose(PyObject *NPY_UNUSED(dummy), PyObject *args)
 {
     PyObject *a0;
 
-    if (!PyArg_ParseTuple(args, "O:_fastCopyAndTranspose", &a0)) {
+    if (!PyArg_ParseTuple(args, "O:fastCopyAndTranspose", &a0)) {
         return NULL;
     }
     return PyArray_Return((PyArrayObject *)PyArray_CopyAndTranspose(a0));
@@ -2982,7 +3069,7 @@ array_arange(PyObject *NPY_UNUSED(ignored),
 {
     PyObject *o_start = NULL, *o_stop = NULL, *o_step = NULL, *range=NULL;
     PyArray_Descr *typecode = NULL;
-    PyObject *like = NULL;
+    PyObject *like = Py_None;
     NPY_PREPARE_ARGPARSER;
 
     if (npy_parse_arguments("arange", args, len_args, kwnames,
@@ -2995,7 +3082,7 @@ array_arange(PyObject *NPY_UNUSED(ignored),
         Py_XDECREF(typecode);
         return NULL;
     }
-    if (like != NULL) {
+    if (like != Py_None) {
         PyObject *deferred = array_implement_c_array_function_creation(
                 "arange", like, NULL, NULL, args, len_args, kwnames);
         if (deferred != Py_NotImplemented) {
@@ -3504,10 +3591,11 @@ array_result_type(PyObject *NPY_UNUSED(dummy), PyObject *args)
             if (arr[narr] == NULL) {
                 goto finish;
             }
-            if (PyLong_CheckExact(obj) || PyFloat_CheckExact(obj) ||
-                    PyComplex_CheckExact(obj)) {
-                ((PyArrayObject_fields *)arr[narr])->flags |= _NPY_ARRAY_WAS_PYSCALAR;
-            }
+            /*
+             * Mark array if it was a python scalar (we do not need the actual
+             * DType here yet, this is figured out inside ResultType.
+             */
+            npy_mark_tmp_array_if_pyscalar(obj, arr[narr], NULL);
             ++narr;
         }
         else {
@@ -3697,6 +3785,12 @@ format_longfloat(PyObject *NPY_UNUSED(dummy), PyObject *args, PyObject *kwds)
                               TrimMode_LeaveOneZero, -1, -1);
 }
 
+
+/*
+ * The only purpose of this function is that it allows the "rstrip".
+ * From my (@seberg's) perspective, this function should be deprecated
+ * and I do not think it matters if it is not particularly fast.
+ */
 static PyObject *
 compare_chararrays(PyObject *NPY_UNUSED(dummy), PyObject *args, PyObject *kwds)
 {
@@ -3762,7 +3856,7 @@ compare_chararrays(PyObject *NPY_UNUSED(dummy), PyObject *args, PyObject *kwds)
         return NULL;
     }
     if (PyArray_ISSTRING(newarr) && PyArray_ISSTRING(newoth)) {
-        res = _strings_richcompare(newarr, newoth, cmp_op, rstrip != 0);
+        res = _umath_strings_richcompare(newarr, newoth, cmp_op, rstrip != 0);
     }
     else {
         PyErr_SetString(PyExc_TypeError,
@@ -4212,7 +4306,7 @@ normalize_axis_index(PyObject *NPY_UNUSED(self),
 
 
 static PyObject *
-_reload_guard(PyObject *NPY_UNUSED(self)) {
+_reload_guard(PyObject *NPY_UNUSED(self), PyObject *NPY_UNUSED(args)) {
     static int initialized = 0;
 
 #if !defined(PYPY_VERSION)
@@ -4337,7 +4431,7 @@ static struct PyMethodDef array_module_methods[] = {
     {"c_einsum",
         (PyCFunction)array_einsum,
         METH_VARARGS|METH_KEYWORDS, NULL},
-    {"_fastCopyAndTranspose",
+    {"fastCopyAndTranspose",
         (PyCFunction)array_fastCopyAndTranspose,
         METH_VARARGS, NULL},
     {"correlate",
@@ -4437,6 +4531,8 @@ static struct PyMethodDef array_module_methods[] = {
         METH_VARARGS | METH_KEYWORDS, NULL},
     {"_get_experimental_dtype_api", (PyCFunction)_get_experimental_dtype_api,
         METH_O, NULL},
+    {"_load_from_filelike", (PyCFunction)_load_from_filelike,
+        METH_FASTCALL | METH_KEYWORDS, NULL},
     /* from umath */
     {"frompyfunc",
         (PyCFunction) ufunc_frompyfunc,
@@ -4453,16 +4549,26 @@ static struct PyMethodDef array_module_methods[] = {
     {"get_handler_version",
         (PyCFunction) get_handler_version,
         METH_VARARGS, NULL},
+    {"_get_promotion_state",
+        (PyCFunction)npy__get_promotion_state,
+        METH_NOARGS, "Get the current NEP 50 promotion state."},
+    {"_set_promotion_state",
+         (PyCFunction)npy__set_promotion_state,
+         METH_O, "Set the NEP 50 promotion state.  This is not thread-safe.\n"
+                 "The optional warnings can be safely silenced using the \n"
+                 "`np._no_nep50_warning()` context manager."},
     {"_add_newdoc_ufunc", (PyCFunction)add_newdoc_ufunc,
         METH_VARARGS, NULL},
     {"_get_sfloat_dtype",
         get_sfloat_dtype, METH_NOARGS, NULL},
+    {"_get_madvise_hugepage", (PyCFunction)_get_madvise_hugepage,
+        METH_NOARGS, NULL},
     {"_set_madvise_hugepage", (PyCFunction)_set_madvise_hugepage,
         METH_O, NULL},
     {"_reload_guard", (PyCFunction)_reload_guard,
         METH_NOARGS,
         "Give a warning on reload and big warning in sub-interpreters."},
-    {"_from_dlpack", (PyCFunction)_from_dlpack,
+    {"from_dlpack", (PyCFunction)from_dlpack,
         METH_O, NULL},
     {NULL, NULL, 0, NULL}                /* sentinel */
 };
@@ -4621,7 +4727,6 @@ set_flaginfo(PyObject *d)
     _addnew(FORTRAN, NPY_ARRAY_F_CONTIGUOUS, F);
     _addnew(CONTIGUOUS, NPY_ARRAY_C_CONTIGUOUS, C);
     _addnew(ALIGNED, NPY_ARRAY_ALIGNED, A);
-    _addnew(UPDATEIFCOPY, NPY_ARRAY_UPDATEIFCOPY, U);
     _addnew(WRITEBACKIFCOPY, NPY_ARRAY_WRITEBACKIFCOPY, X);
     _addnew(WRITEABLE, NPY_ARRAY_WRITEABLE, W);
     _addone(C_CONTIGUOUS, NPY_ARRAY_C_CONTIGUOUS);
@@ -4635,6 +4740,12 @@ set_flaginfo(PyObject *d)
     return;
 }
 
+NPY_VISIBILITY_HIDDEN PyObject * npy_ma_str_current_allocator = NULL;
+NPY_VISIBILITY_HIDDEN PyObject * npy_ma_str_array = NULL;
+NPY_VISIBILITY_HIDDEN PyObject * npy_ma_str_array_function = NULL;
+NPY_VISIBILITY_HIDDEN PyObject * npy_ma_str_array_struct = NULL;
+NPY_VISIBILITY_HIDDEN PyObject * npy_ma_str_array_interface = NULL;
+NPY_VISIBILITY_HIDDEN PyObject * npy_ma_str_array_priority = NULL;
 NPY_VISIBILITY_HIDDEN PyObject * npy_ma_str_array_wrap = NULL;
 NPY_VISIBILITY_HIDDEN PyObject * npy_ma_str_array_finalize = NULL;
 NPY_VISIBILITY_HIDDEN PyObject * npy_ma_str_implementation = NULL;
@@ -4646,6 +4757,30 @@ NPY_VISIBILITY_HIDDEN PyObject * npy_ma_str_numpy = NULL;
 static int
 intern_strings(void)
 {
+    npy_ma_str_current_allocator = PyUnicode_InternFromString("current_allocator");
+    if (npy_ma_str_current_allocator == NULL) {
+        return -1;
+    }
+    npy_ma_str_array = PyUnicode_InternFromString("__array__");
+    if (npy_ma_str_array == NULL) {
+        return -1;
+    }
+    npy_ma_str_array_function = PyUnicode_InternFromString("__array_function__");
+    if (npy_ma_str_array_function == NULL) {
+        return -1;
+    }
+    npy_ma_str_array_struct = PyUnicode_InternFromString("__array_struct__");
+    if (npy_ma_str_array_struct == NULL) {
+        return -1;
+    }
+    npy_ma_str_array_priority = PyUnicode_InternFromString("__array_priority__");
+    if (npy_ma_str_array_priority == NULL) {
+        return -1;
+    }
+    npy_ma_str_array_interface = PyUnicode_InternFromString("__array_interface__");
+    if (npy_ma_str_array_interface == NULL) {
+        return -1;
+    }
     npy_ma_str_array_wrap = PyUnicode_InternFromString("__array_wrap__");
     if (npy_ma_str_array_wrap == NULL) {
         return -1;
@@ -4920,8 +5055,7 @@ PyMODINIT_FUNC PyInit__multiarray_umath(void) {
         goto err;
     }
 
-    /* Load the ufunc operators into the array module's namespace */
-    if (InitOperators(d) < 0) {
+    if (initumath(m) != 0) {
         goto err;
     }
 
@@ -4929,9 +5063,6 @@ PyMODINIT_FUNC PyInit__multiarray_umath(void) {
         goto err;
     }
 
-    if (initumath(m) != 0) {
-        goto err;
-    }
     /*
      * Initialize the default PyDataMem_Handler capsule singleton.
      */
@@ -4939,16 +5070,15 @@ PyMODINIT_FUNC PyInit__multiarray_umath(void) {
     if (PyDataMem_DefaultHandler == NULL) {
         goto err;
     }
-#if (!defined(PYPY_VERSION_NUM) || PYPY_VERSION_NUM >= 0x07030600)
     /*
      * Initialize the context-local current handler
      * with the default PyDataMem_Handler capsule.
-    */
+     */
     current_handler = PyContextVar_New("current_allocator", PyDataMem_DefaultHandler);
     if (current_handler == NULL) {
         goto err;
     }
-#endif
+
     return m;
 
  err:
diff --git a/numpy/core/src/multiarray/multiarraymodule.h b/numpy/core/src/multiarray/multiarraymodule.h
index 640940d2a978..809736cd2df0 100644
--- a/numpy/core/src/multiarray/multiarraymodule.h
+++ b/numpy/core/src/multiarray/multiarraymodule.h
@@ -1,6 +1,12 @@
 #ifndef NUMPY_CORE_SRC_MULTIARRAY_MULTIARRAYMODULE_H_
 #define NUMPY_CORE_SRC_MULTIARRAY_MULTIARRAYMODULE_H_
 
+NPY_VISIBILITY_HIDDEN extern PyObject * npy_ma_str_current_allocator;
+NPY_VISIBILITY_HIDDEN extern PyObject * npy_ma_str_array;
+NPY_VISIBILITY_HIDDEN extern PyObject * npy_ma_str_array_function;
+NPY_VISIBILITY_HIDDEN extern PyObject * npy_ma_str_array_struct;
+NPY_VISIBILITY_HIDDEN extern PyObject * npy_ma_str_array_priority;
+NPY_VISIBILITY_HIDDEN extern PyObject * npy_ma_str_array_interface;
 NPY_VISIBILITY_HIDDEN extern PyObject * npy_ma_str_array_wrap;
 NPY_VISIBILITY_HIDDEN extern PyObject * npy_ma_str_array_finalize;
 NPY_VISIBILITY_HIDDEN extern PyObject * npy_ma_str_implementation;
diff --git a/numpy/core/src/multiarray/nditer_api.c b/numpy/core/src/multiarray/nditer_api.c
index 860c8c1f65fa..37e8acd84ca5 100644
--- a/numpy/core/src/multiarray/nditer_api.c
+++ b/numpy/core/src/multiarray/nditer_api.c
@@ -132,7 +132,7 @@ NpyIter_RemoveAxis(NpyIter *iter, int axis)
     NIT_ITERSIZE(iter) = 1;
     axisdata = NIT_AXISDATA(iter);
     for (idim = 0; idim < ndim-1; ++idim) {
-        if (npy_mul_with_overflow_intp(&NIT_ITERSIZE(iter),
+        if (npy_mul_sizes_with_overflow(&NIT_ITERSIZE(iter),
                     NIT_ITERSIZE(iter), NAD_SHAPE(axisdata))) {
             NIT_ITERSIZE(iter) = -1;
             break;
@@ -857,6 +857,13 @@ NpyIter_RequiresBuffering(NpyIter *iter)
  * Whether the iteration loop, and in particular the iternext()
  * function, needs API access.  If this is true, the GIL must
  * be retained while iterating.
+ *
+ * NOTE: Internally (currently), `NpyIter_GetTransferFlags` will
+ *       additionally provide information on whether floating point errors
+ *       may be given during casts.  The flags only require the API use
+ *       necessary for buffering though.  So an iterate which does not require
+ *       buffering may indicate `NpyIter_IterationNeedsAPI`, but not include
+ *       the flag in `NpyIter_GetTransferFlags`.
  */
 NPY_NO_EXPORT npy_bool
 NpyIter_IterationNeedsAPI(NpyIter *iter)
@@ -864,6 +871,21 @@ NpyIter_IterationNeedsAPI(NpyIter *iter)
     return (NIT_ITFLAGS(iter)&NPY_ITFLAG_NEEDSAPI) != 0;
 }
 
+
+/*
+ * Fetch the ArrayMethod (runtime) flags for all "transfer functions' (i.e.
+ * copy to buffer/casts).
+ *
+ * TODO: This should be public API, but that only makes sense when the
+ *       ArrayMethod API is made public.
+ */
+NPY_NO_EXPORT int
+NpyIter_GetTransferFlags(NpyIter *iter)
+{
+    return NIT_ITFLAGS(iter) >> NPY_ITFLAG_TRANSFERFLAGS_SHIFT;
+}
+
+
 /*NUMPY_API
  * Gets the number of dimensions being iterated
  */
diff --git a/numpy/core/src/multiarray/nditer_constr.c b/numpy/core/src/multiarray/nditer_constr.c
index bf32e1f6b706..93d2bc961ea7 100644
--- a/numpy/core/src/multiarray/nditer_constr.c
+++ b/numpy/core/src/multiarray/nditer_constr.c
@@ -992,7 +992,7 @@ npyiter_check_per_op_flags(npy_uint32 op_flags, npyiter_opitflags *op_itflags)
 }
 
 /*
- * Prepares a a constructor operand.  Assumes a reference to 'op'
+ * Prepares a constructor operand.  Assumes a reference to 'op'
  * is owned, and that 'op' may be replaced.  Fills in 'op_dataptr',
  * 'op_dtype', and may modify 'op_itflags'.
  *
@@ -1128,13 +1128,12 @@ npyiter_prepare_one_operand(PyArrayObject **op,
         if (op_flags & NPY_ITER_NBO) {
             /* Check byte order */
             if (!PyArray_ISNBO((*op_dtype)->byteorder)) {
-                PyArray_Descr *nbo_dtype;
-
                 /* Replace with a new descr which is in native byte order */
-                nbo_dtype = PyArray_DescrNewByteorder(*op_dtype, NPY_NATIVE);
-                Py_DECREF(*op_dtype);
-                *op_dtype = nbo_dtype;
-
+                Py_SETREF(*op_dtype,
+                          PyArray_DescrNewByteorder(*op_dtype, NPY_NATIVE));
+                if (*op_dtype == NULL) {
+                    return 0;
+                }                
                 NPY_IT_DBG_PRINT("Iterator: Setting NPY_OP_ITFLAG_CAST "
                                     "because of NPY_ITER_NBO\n");
                 /* Indicate that byte order or alignment needs fixing */
@@ -1226,22 +1225,6 @@ npyiter_prepare_operands(int nop, PyArrayObject **op_in,
         }
     }
 
-    /* If all the operands were NULL, it's an error */
-    if (op[0] == NULL) {
-        int all_null = 1;
-        for (iop = 1; iop < nop; ++iop) {
-            if (op[iop] != NULL) {
-                all_null = 0;
-                break;
-            }
-        }
-        if (all_null) {
-            PyErr_SetString(PyExc_ValueError,
-                    "At least one iterator operand must be non-NULL");
-            goto fail_nop;
-        }
-    }
-
     if (any_writemasked_ops && maskop < 0) {
         PyErr_SetString(PyExc_ValueError,
                 "An iterator operand was flagged as WRITEMASKED, "
@@ -1411,9 +1394,9 @@ check_mask_for_writemasked_reduction(NpyIter *iter, int iop)
 static int
 npyiter_check_reduce_ok_and_set_flags(
         NpyIter *iter, npy_uint32 flags, npyiter_opitflags *op_itflags,
-        int dim) {
+        int iop, int maskop, int dim) {
     /* If it's writeable, this means a reduction */
-    if (*op_itflags & NPY_OP_ITFLAG_WRITE) {
+    if (op_itflags[iop] & NPY_OP_ITFLAG_WRITE) {
         if (!(flags & NPY_ITER_REDUCE_OK)) {
             PyErr_Format(PyExc_ValueError,
                     "output operand requires a reduction along dimension %d, "
@@ -1421,17 +1404,35 @@ npyiter_check_reduce_ok_and_set_flags(
                     "does not match the expected output shape.", dim);
             return 0;
         }
-        if (!(*op_itflags & NPY_OP_ITFLAG_READ)) {
+        if (!(op_itflags[iop] & NPY_OP_ITFLAG_READ)) {
             PyErr_SetString(PyExc_ValueError,
                     "output operand requires a reduction, but is flagged as "
                     "write-only, not read-write");
             return 0;
         }
+        /*
+         * The ARRAYMASK can't be a reduction, because
+         * it would be possible to write back to the
+         * array once when the ARRAYMASK says 'True',
+         * then have the reduction on the ARRAYMASK
+         * later flip to 'False', indicating that the
+         * write back should never have been done,
+         * and violating the strict masking semantics
+         */
+        if (iop == maskop) {
+            PyErr_SetString(PyExc_ValueError,
+                    "output operand requires a "
+                    "reduction, but is flagged as "
+                    "the ARRAYMASK operand which "
+                    "is not permitted to be the "
+                    "result of a reduction");
+            return 0;
+        }
         NPY_IT_DBG_PRINT("Iterator: Indicating that a reduction is"
                          "occurring\n");
 
         NIT_ITFLAGS(iter) |= NPY_ITFLAG_REDUCE;
-        *op_itflags |= NPY_OP_ITFLAG_REDUCE;
+        op_itflags[iop] |= NPY_OP_ITFLAG_REDUCE;
     }
     return 1;
 }
@@ -1614,42 +1615,9 @@ npyiter_fill_axisdata(NpyIter *iter, npy_uint32 flags, npyiter_opitflags *op_itf
                             goto operand_different_than_broadcast;
                         }
                         /* If it's writeable, this means a reduction */
-                        if (op_itflags[iop] & NPY_OP_ITFLAG_WRITE) {
-                            if (!(flags & NPY_ITER_REDUCE_OK)) {
-                                PyErr_SetString(PyExc_ValueError,
-                                        "output operand requires a "
-                                        "reduction, but reduction is "
-                                        "not enabled");
-                                return 0;
-                            }
-                            if (!(op_itflags[iop] & NPY_OP_ITFLAG_READ)) {
-                                PyErr_SetString(PyExc_ValueError,
-                                        "output operand requires a "
-                                        "reduction, but is flagged as "
-                                        "write-only, not read-write");
-                                return 0;
-                            }
-                            /*
-                             * The ARRAYMASK can't be a reduction, because
-                             * it would be possible to write back to the
-                             * array once when the ARRAYMASK says 'True',
-                             * then have the reduction on the ARRAYMASK
-                             * later flip to 'False', indicating that the
-                             * write back should never have been done,
-                             * and violating the strict masking semantics
-                             */
-                            if (iop == maskop) {
-                                PyErr_SetString(PyExc_ValueError,
-                                        "output operand requires a "
-                                        "reduction, but is flagged as "
-                                        "the ARRAYMASK operand which "
-                                        "is not permitted to be the "
-                                        "result of a reduction");
-                                return 0;
-                            }
-
-                            NIT_ITFLAGS(iter) |= NPY_ITFLAG_REDUCE;
-                            op_itflags[iop] |= NPY_OP_ITFLAG_REDUCE;
+                        if (!npyiter_check_reduce_ok_and_set_flags(
+                                iter, flags, op_itflags, iop, maskop, idim)) {
+                            return 0;
                         }
                     }
                     else {
@@ -1698,7 +1666,7 @@ npyiter_fill_axisdata(NpyIter *iter, npy_uint32 flags, npyiter_opitflags *op_itf
                             goto operand_different_than_broadcast;
                         }
                         if (!npyiter_check_reduce_ok_and_set_flags(
-                                iter, flags, &op_itflags[iop], i)) {
+                                iter, flags, op_itflags, iop, maskop, i)) {
                             return 0;
                         }
                     }
@@ -1708,8 +1676,14 @@ npyiter_fill_axisdata(NpyIter *iter, npy_uint32 flags, npyiter_opitflags *op_itf
                 }
                 else {
                     strides[iop] = 0;
+                    /*
+                     * If deleting this axis produces a reduction, but
+                     * reduction wasn't enabled, throw an error.
+                     * NOTE: We currently always allow new-axis if the iteration
+                     *       size is 1 (thus allowing broadcasting sometimes).
+                     */
                     if (!npyiter_check_reduce_ok_and_set_flags(
-                            iter, flags, &op_itflags[iop], i)) {
+                            iter, flags, op_itflags, iop, maskop, i)) {
                         return 0;
                     }
                 }
@@ -1722,7 +1696,7 @@ npyiter_fill_axisdata(NpyIter *iter, npy_uint32 flags, npyiter_opitflags *op_itf
     /* Now fill in the ITERSIZE member */
     NIT_ITERSIZE(iter) = 1;
     for (idim = 0; idim < ndim; ++idim) {
-        if (npy_mul_with_overflow_intp(&NIT_ITERSIZE(iter),
+        if (npy_mul_sizes_with_overflow(&NIT_ITERSIZE(iter),
                     NIT_ITERSIZE(iter), broadcast_shape[idim])) {
             if ((itflags & NPY_ITFLAG_HASMULTIINDEX) &&
                     !(itflags & NPY_ITFLAG_HASINDEX) &&
@@ -2546,6 +2520,11 @@ npyiter_new_temp_array(NpyIter *iter, PyTypeObject *subtype,
             i = npyiter_undo_iter_axis_perm(idim, ndim, perm, NULL);
             i = npyiter_get_op_axis(op_axes[i], &reduction_axis);
 
+            /*
+             * If i < 0, this is a new axis (the operand does not have it)
+             * so we can ignore it here.  The iterator setup will have
+             * ensured already that a potential reduction/broadcast is valid.
+             */
             if (i >= 0) {
                 NPY_IT_DBG_PRINT3("Iterator: Setting allocated stride %d "
                                     "for iterator dimension %d to %d\n", (int)i,
@@ -2576,22 +2555,6 @@ npyiter_new_temp_array(NpyIter *iter, PyTypeObject *subtype,
                     stride *= shape[i];
                 }
             }
-            else {
-                if (shape == NULL) {
-                    /*
-                     * If deleting this axis produces a reduction, but
-                     * reduction wasn't enabled, throw an error.
-                     * NOTE: We currently always allow new-axis if the iteration
-                     *       size is 1 (thus allowing broadcasting sometimes).
-                     */
-                    if (!reduction_axis && NAD_SHAPE(axisdata) != 1) {
-                        if (!npyiter_check_reduce_ok_and_set_flags(
-                                iter, flags, op_itflags, i)) {
-                            return NULL;
-                        }
-                    }
-                }
-            }
         }
     }
     else {
@@ -3142,7 +3105,9 @@ npyiter_allocate_transfer_functions(NpyIter *iter)
     npy_intp *strides = NAD_STRIDES(axisdata), op_stride;
     NpyIter_TransferInfo *transferinfo = NBF_TRANSFERINFO(bufferdata);
 
-    int needs_api = 0;
+    /* combined cast flags, the new cast flags for each cast: */
+    NPY_ARRAYMETHOD_FLAGS cflags = PyArrayMethod_MINIMAL_FLAGS;
+    NPY_ARRAYMETHOD_FLAGS nc_flags;
 
     for (iop = 0; iop < nop; ++iop) {
         npyiter_opitflags flags = op_itflags[iop];
@@ -3168,10 +3133,11 @@ npyiter_allocate_transfer_functions(NpyIter *iter)
                                         op_dtype[iop],
                                         move_references,
                                         &transferinfo[iop].read,
-                                        &needs_api) != NPY_SUCCEED) {
+                                        &nc_flags) != NPY_SUCCEED) {
                     iop -= 1;  /* This one cannot be cleaned up yet. */
                     goto fail;
                 }
+                cflags = PyArrayMethod_COMBINED_FLAGS(cflags, nc_flags);
             }
             else {
                 transferinfo[iop].read.func = NULL;
@@ -3200,9 +3166,10 @@ npyiter_allocate_transfer_functions(NpyIter *iter)
                             mask_dtype,
                             move_references,
                             &transferinfo[iop].write,
-                            &needs_api) != NPY_SUCCEED) {
+                            &nc_flags) != NPY_SUCCEED) {
                         goto fail;
                     }
+                    cflags = PyArrayMethod_COMBINED_FLAGS(cflags, nc_flags);
                 }
                 else {
                     if (PyArray_GetDTypeTransferFunction(
@@ -3213,9 +3180,10 @@ npyiter_allocate_transfer_functions(NpyIter *iter)
                             PyArray_DESCR(op[iop]),
                             move_references,
                             &transferinfo[iop].write,
-                            &needs_api) != NPY_SUCCEED) {
+                            &nc_flags) != NPY_SUCCEED) {
                         goto fail;
                     }
+                    cflags = PyArrayMethod_COMBINED_FLAGS(cflags, nc_flags);
                 }
             }
             /* If no write back but there are references make a decref fn */
@@ -3231,9 +3199,10 @@ npyiter_allocate_transfer_functions(NpyIter *iter)
                         op_dtype[iop], NULL,
                         1,
                         &transferinfo[iop].write,
-                        &needs_api) != NPY_SUCCEED) {
+                        &nc_flags) != NPY_SUCCEED) {
                     goto fail;
                 }
+                cflags = PyArrayMethod_COMBINED_FLAGS(cflags, nc_flags);
             }
             else {
                 transferinfo[iop].write.func = NULL;
@@ -3245,8 +3214,12 @@ npyiter_allocate_transfer_functions(NpyIter *iter)
         }
     }
 
-    /* If any of the dtype transfer functions needed the API, flag it */
-    if (needs_api) {
+    /* Store the combined transfer flags on the iterator */
+    NIT_ITFLAGS(iter) |= cflags << NPY_ITFLAG_TRANSFERFLAGS_SHIFT;
+    assert(NIT_ITFLAGS(iter) >> NPY_ITFLAG_TRANSFERFLAGS_SHIFT == cflags);
+
+    /* If any of the dtype transfer functions needed the API, flag it. */
+    if (cflags & NPY_METH_REQUIRES_PYAPI) {
         NIT_ITFLAGS(iter) |= NPY_ITFLAG_NEEDSAPI;
     }
 
diff --git a/numpy/core/src/multiarray/nditer_impl.h b/numpy/core/src/multiarray/nditer_impl.h
index 2a82b7e5410d..6650fc0a84cf 100644
--- a/numpy/core/src/multiarray/nditer_impl.h
+++ b/numpy/core/src/multiarray/nditer_impl.h
@@ -76,33 +76,38 @@
 /* Internal iterator flags */
 
 /* The perm is the identity */
-#define NPY_ITFLAG_IDENTPERM    0x0001
+#define NPY_ITFLAG_IDENTPERM    (1 << 0)
 /* The perm has negative entries (indicating flipped axes) */
-#define NPY_ITFLAG_NEGPERM      0x0002
+#define NPY_ITFLAG_NEGPERM      (1 << 1)
 /* The iterator is tracking an index */
-#define NPY_ITFLAG_HASINDEX     0x0004
+#define NPY_ITFLAG_HASINDEX     (1 << 2)
 /* The iterator is tracking a multi-index */
-#define NPY_ITFLAG_HASMULTIINDEX    0x0008
+#define NPY_ITFLAG_HASMULTIINDEX    (1 << 3)
 /* The iteration order was forced on construction */
-#define NPY_ITFLAG_FORCEDORDER  0x0010
+#define NPY_ITFLAG_FORCEDORDER  (1 << 4)
 /* The inner loop is handled outside the iterator */
-#define NPY_ITFLAG_EXLOOP      0x0020
+#define NPY_ITFLAG_EXLOOP      (1 << 5)
 /* The iterator is ranged */
-#define NPY_ITFLAG_RANGE        0x0040
+#define NPY_ITFLAG_RANGE        (1 << 6)
 /* The iterator is buffered */
-#define NPY_ITFLAG_BUFFER       0x0080
+#define NPY_ITFLAG_BUFFER       (1 << 7)
 /* The iterator should grow the buffered inner loop when possible */
-#define NPY_ITFLAG_GROWINNER    0x0100
+#define NPY_ITFLAG_GROWINNER    (1 << 8)
 /* There is just one iteration, can specialize iternext for that */
-#define NPY_ITFLAG_ONEITERATION 0x0200
+#define NPY_ITFLAG_ONEITERATION (1 << 9)
 /* Delay buffer allocation until first Reset* call */
-#define NPY_ITFLAG_DELAYBUF     0x0400
+#define NPY_ITFLAG_DELAYBUF     (1 << 10)
 /* Iteration needs API access during iternext */
-#define NPY_ITFLAG_NEEDSAPI     0x0800
+#define NPY_ITFLAG_NEEDSAPI     (1 << 11)
 /* Iteration includes one or more operands being reduced */
-#define NPY_ITFLAG_REDUCE       0x1000
+#define NPY_ITFLAG_REDUCE       (1 << 12)
 /* Reduce iteration doesn't need to recalculate reduce loops next time */
-#define NPY_ITFLAG_REUSE_REDUCE_LOOPS 0x2000
+#define NPY_ITFLAG_REUSE_REDUCE_LOOPS (1 << 13)
+/*
+ * Offset of (combined) ArrayMethod flags for all transfer functions.
+ * For now, we use the top 8 bits.
+ */
+#define NPY_ITFLAG_TRANSFERFLAGS_SHIFT 24
 
 /* Internal iterator per-operand iterator flags */
 
@@ -147,7 +152,7 @@ struct NpyIter_InternalOnly {
     /* iterindex is only used if RANGED or BUFFERED is set */
     npy_intp iterindex;
     /* The rest is variable */
-    char iter_flexdata;
+    char iter_flexdata[];
 };
 
 typedef struct NpyIter_AxisData_tag NpyIter_AxisData;
@@ -216,21 +221,21 @@ typedef npy_int16 npyiter_opitflags;
 #define NIT_ITERINDEX(iter) \
         (iter->iterindex)
 #define NIT_PERM(iter)  ((npy_int8 *)( \
-        &(iter)->iter_flexdata + NIT_PERM_OFFSET()))
+        iter->iter_flexdata + NIT_PERM_OFFSET()))
 #define NIT_DTYPES(iter) ((PyArray_Descr **)( \
-        &(iter)->iter_flexdata + NIT_DTYPES_OFFSET(itflags, ndim, nop)))
+        iter->iter_flexdata + NIT_DTYPES_OFFSET(itflags, ndim, nop)))
 #define NIT_RESETDATAPTR(iter) ((char **)( \
-        &(iter)->iter_flexdata + NIT_RESETDATAPTR_OFFSET(itflags, ndim, nop)))
+        iter->iter_flexdata + NIT_RESETDATAPTR_OFFSET(itflags, ndim, nop)))
 #define NIT_BASEOFFSETS(iter) ((npy_intp *)( \
-        &(iter)->iter_flexdata + NIT_BASEOFFSETS_OFFSET(itflags, ndim, nop)))
+        iter->iter_flexdata + NIT_BASEOFFSETS_OFFSET(itflags, ndim, nop)))
 #define NIT_OPERANDS(iter) ((PyArrayObject **)( \
-        &(iter)->iter_flexdata + NIT_OPERANDS_OFFSET(itflags, ndim, nop)))
+        iter->iter_flexdata + NIT_OPERANDS_OFFSET(itflags, ndim, nop)))
 #define NIT_OPITFLAGS(iter) ((npyiter_opitflags *)( \
-        &(iter)->iter_flexdata + NIT_OPITFLAGS_OFFSET(itflags, ndim, nop)))
+        iter->iter_flexdata + NIT_OPITFLAGS_OFFSET(itflags, ndim, nop)))
 #define NIT_BUFFERDATA(iter) ((NpyIter_BufferData *)( \
-        &(iter)->iter_flexdata + NIT_BUFFERDATA_OFFSET(itflags, ndim, nop)))
+        iter->iter_flexdata + NIT_BUFFERDATA_OFFSET(itflags, ndim, nop)))
 #define NIT_AXISDATA(iter) ((NpyIter_AxisData *)( \
-        &(iter)->iter_flexdata + NIT_AXISDATA_OFFSET(itflags, ndim, nop)))
+        iter->iter_flexdata + NIT_AXISDATA_OFFSET(itflags, ndim, nop)))
 
 /* Internal-only BUFFERDATA MEMBER ACCESS */
 
@@ -356,4 +361,12 @@ npyiter_copy_to_buffers(NpyIter *iter, char **prev_dataptrs);
 NPY_NO_EXPORT void
 npyiter_clear_buffers(NpyIter *iter);
 
+/*
+ * Function to get the ArrayMethod flags of the transfer functions.
+ * TODO: This function should be public and removed from `nditer_impl.h`, but
+ *       this requires making the ArrayMethod flags public API first.
+ */
+NPY_NO_EXPORT int
+NpyIter_GetTransferFlags(NpyIter *iter);
+
 #endif  /* NUMPY_CORE_SRC_MULTIARRAY_NDITER_IMPL_H_ */
diff --git a/numpy/core/src/multiarray/nditer_pywrap.c b/numpy/core/src/multiarray/nditer_pywrap.c
index 8e072d5f4c1e..94dd526ceb6c 100644
--- a/numpy/core/src/multiarray/nditer_pywrap.c
+++ b/numpy/core/src/multiarray/nditer_pywrap.c
@@ -1045,6 +1045,7 @@ NpyIter_NestedIters(PyObject *NPY_UNUSED(self),
 
         if (iter->iter == NULL) {
             Py_DECREF(ret);
+            Py_DECREF(iter);
             goto fail;
         }
 
@@ -1190,7 +1191,7 @@ npyiter_resetbasepointers(NewNpyArrayIterObject *self)
 }
 
 static PyObject *
-npyiter_reset(NewNpyArrayIterObject *self)
+npyiter_reset(NewNpyArrayIterObject *self, PyObject *NPY_UNUSED(args))
 {
     if (self->iter == NULL) {
         PyErr_SetString(PyExc_ValueError,
@@ -1227,7 +1228,7 @@ npyiter_reset(NewNpyArrayIterObject *self)
  * copied.
  */
 static PyObject *
-npyiter_copy(NewNpyArrayIterObject *self)
+npyiter_copy(NewNpyArrayIterObject *self, PyObject *NPY_UNUSED(args))
 {
     NewNpyArrayIterObject *iter;
 
@@ -1263,7 +1264,7 @@ npyiter_copy(NewNpyArrayIterObject *self)
 }
 
 static PyObject *
-npyiter_iternext(NewNpyArrayIterObject *self)
+npyiter_iternext(NewNpyArrayIterObject *self, PyObject *NPY_UNUSED(args))
 {
     if (self->iter != NULL && self->iternext != NULL &&
                         !self->finished && self->iternext(self->iter)) {
@@ -1320,7 +1321,8 @@ npyiter_remove_axis(NewNpyArrayIterObject *self, PyObject *args)
 }
 
 static PyObject *
-npyiter_remove_multi_index(NewNpyArrayIterObject *self)
+npyiter_remove_multi_index(
+    NewNpyArrayIterObject *self, PyObject *NPY_UNUSED(args))
 {
     if (self->iter == NULL) {
         PyErr_SetString(PyExc_ValueError,
@@ -1345,7 +1347,8 @@ npyiter_remove_multi_index(NewNpyArrayIterObject *self)
 }
 
 static PyObject *
-npyiter_enable_external_loop(NewNpyArrayIterObject *self)
+npyiter_enable_external_loop(
+    NewNpyArrayIterObject *self, PyObject *NPY_UNUSED(args))
 {
     if (self->iter == NULL) {
         PyErr_SetString(PyExc_ValueError,
@@ -1370,7 +1373,7 @@ npyiter_enable_external_loop(NewNpyArrayIterObject *self)
 }
 
 static PyObject *
-npyiter_debug_print(NewNpyArrayIterObject *self)
+npyiter_debug_print(NewNpyArrayIterObject *self, PyObject *NPY_UNUSED(args))
 {
     if (self->iter != NULL) {
         NpyIter_DebugPrint(self->iter);
@@ -2315,7 +2318,7 @@ npyiter_ass_subscript(NewNpyArrayIterObject *self, PyObject *op,
 }
 
 static PyObject *
-npyiter_enter(NewNpyArrayIterObject *self)
+npyiter_enter(NewNpyArrayIterObject *self, PyObject *NPY_UNUSED(args))
 {
     if (self->iter == NULL) {
         PyErr_SetString(PyExc_RuntimeError, "operation on non-initialized iterator");
@@ -2326,7 +2329,7 @@ npyiter_enter(NewNpyArrayIterObject *self)
 }
 
 static PyObject *
-npyiter_close(NewNpyArrayIterObject *self)
+npyiter_close(NewNpyArrayIterObject *self, PyObject *NPY_UNUSED(args))
 {
     NpyIter *iter = self->iter;
     int ret;
@@ -2347,7 +2350,7 @@ static PyObject *
 npyiter_exit(NewNpyArrayIterObject *self, PyObject *NPY_UNUSED(args))
 {
     /* even if called via exception handling, writeback any data */
-    return npyiter_close(self);
+    return npyiter_close(self, NULL);
 }
 
 static PyMethodDef npyiter_methods[] = {
diff --git a/numpy/core/src/multiarray/number.c b/numpy/core/src/multiarray/number.c
index 292ef55a630f..df814a79625f 100644
--- a/numpy/core/src/multiarray/number.c
+++ b/numpy/core/src/multiarray/number.c
@@ -925,7 +925,6 @@ NPY_NO_EXPORT PyNumberMethods array_as_number = {
 
     .nb_int = (unaryfunc)array_int,
     .nb_float = (unaryfunc)array_float,
-    .nb_index = (unaryfunc)array_index,
 
     .nb_inplace_add = (binaryfunc)array_inplace_add,
     .nb_inplace_subtract = (binaryfunc)array_inplace_subtract,
@@ -943,6 +942,8 @@ NPY_NO_EXPORT PyNumberMethods array_as_number = {
     .nb_inplace_floor_divide = (binaryfunc)array_inplace_floor_divide,
     .nb_inplace_true_divide = (binaryfunc)array_inplace_true_divide,
 
+    .nb_index = (unaryfunc)array_index,
+
     .nb_matrix_multiply = array_matrix_multiply,
     .nb_inplace_matrix_multiply = (binaryfunc)array_inplace_matrix_multiply,
 };
diff --git a/numpy/core/src/multiarray/scalarapi.c b/numpy/core/src/multiarray/scalarapi.c
index 564352f1fd3f..40f1da2c4a96 100644
--- a/numpy/core/src/multiarray/scalarapi.c
+++ b/numpy/core/src/multiarray/scalarapi.c
@@ -88,83 +88,12 @@ scalar_value(PyObject *scalar, PyArray_Descr *descr)
     }
 
     /*
-     * Must be a user-defined type --- check to see which
-     * scalar it inherits from.
+     * Must be a user defined type with an associated (registered) dtype.
+     * Thus, it cannot be flexible (user dtypes cannot be), so we can (and
+     * pretty much have no choice but to) assume the below logic always works.
+     * I.e. this assumes that the logic would also works for most of our types.
      */
 
-#define _CHK(cls) PyObject_IsInstance(scalar, \
-            (PyObject *)&Py##cls##ArrType_Type)
-#define _IFCASE(cls) if (_CHK(cls)) return &PyArrayScalar_VAL(scalar, cls)
-
-    if (_CHK(Number)) {
-        if (_CHK(Integer)) {
-            if (_CHK(SignedInteger)) {
-                _IFCASE(Byte);
-                _IFCASE(Short);
-                _IFCASE(Int);
-                _IFCASE(Long);
-                _IFCASE(LongLong);
-                _IFCASE(Timedelta);
-            }
-            else {
-                /* Unsigned Integer */
-                _IFCASE(UByte);
-                _IFCASE(UShort);
-                _IFCASE(UInt);
-                _IFCASE(ULong);
-                _IFCASE(ULongLong);
-            }
-        }
-        else {
-            /* Inexact */
-            if (_CHK(Floating)) {
-                _IFCASE(Half);
-                _IFCASE(Float);
-                _IFCASE(Double);
-                _IFCASE(LongDouble);
-            }
-            else {
-                /*ComplexFloating */
-                _IFCASE(CFloat);
-                _IFCASE(CDouble);
-                _IFCASE(CLongDouble);
-            }
-        }
-    }
-    else if (_CHK(Bool)) {
-        return &PyArrayScalar_VAL(scalar, Bool);
-    }
-    else if (_CHK(Datetime)) {
-        return &PyArrayScalar_VAL(scalar, Datetime);
-    }
-    else if (_CHK(Flexible)) {
-        if (_CHK(String)) {
-            return (void *)PyBytes_AS_STRING(scalar);
-        }
-        if (_CHK(Unicode)) {
-            /* Treat this the same as the NPY_UNICODE base class */
-
-            /* lazy initialization, to reduce the memory used by string scalars */
-            if (PyArrayScalar_VAL(scalar, Unicode) == NULL) {
-                Py_UCS4 *raw_data = PyUnicode_AsUCS4Copy(scalar);
-                if (raw_data == NULL) {
-                    return NULL;
-                }
-                PyArrayScalar_VAL(scalar, Unicode) = raw_data;
-                return (void *)raw_data;
-            }
-            return PyArrayScalar_VAL(scalar, Unicode);
-        }
-        if (_CHK(Void)) {
-            /* Note: no & needed here, so can't use _IFCASE */
-            return PyArrayScalar_VAL(scalar, Void);
-        }
-    }
-    else {
-        _IFCASE(Object);
-    }
-
-
     /*
      * Use the alignment flag to figure out where the data begins
      * after a PyObject_HEAD
@@ -177,16 +106,20 @@ scalar_value(PyObject *scalar, PyArray_Descr *descr)
         memloc = ((memloc + align - 1)/align)*align;
     }
     return (void *)memloc;
-#undef _IFCASE
-#undef _CHK
 }
 
 /*NUMPY_API
- * return true an object is exactly a numpy scalar
+ * return 1 if an object is exactly a numpy scalar
  */
 NPY_NO_EXPORT int
 PyArray_CheckAnyScalarExact(PyObject * obj)
 {
+    if (obj == NULL) {
+        PyErr_SetString(PyExc_ValueError,
+            "obj is NULL in PyArray_CheckAnyScalarExact");
+        return 0;
+    }
+
     return is_anyscalar_exact(obj);
 }
 
@@ -379,6 +312,14 @@ PyArray_FromScalar(PyObject *scalar, PyArray_Descr *outcode)
 NPY_NO_EXPORT PyObject *
 PyArray_ScalarFromObject(PyObject *object)
 {
+    if (DEPRECATE(
+            "PyArray_ScalarFromObject() is deprecated and scheduled for "
+            "removal. If you are using this (undocumented) function, "
+            "please notify the NumPy developers to look for solutions."
+            "(Deprecated in NumPy 1.23)") < 0) {
+        return NULL;
+    }
+
     PyObject *ret = NULL;
 
     if (PyArray_IsZeroDim(object)) {
@@ -625,6 +566,9 @@ PyArray_DescrFromScalar(PyObject *sc)
     }
     if (PyDataType_ISUNSIZED(descr)) {
         PyArray_DESCR_REPLACE(descr);
+        if (descr == NULL) {
+            return NULL;
+        }
         type_num = descr->type_num;
         if (type_num == NPY_STRING) {
             descr->elsize = PyBytes_GET_SIZE(sc);
@@ -770,7 +714,9 @@ PyArray_Scalar(void *data, PyArray_Descr *descr, PyObject *base)
     if (PyTypeNum_ISFLEXIBLE(type_num)) {
         if (type_num == NPY_STRING) {
             destptr = PyBytes_AS_STRING(obj);
-            ((PyBytesObject *)obj)->ob_shash = -1;
+            #if PY_VERSION_HEX < 0x030b00b0
+                ((PyBytesObject *)obj)->ob_shash = -1;
+            #endif
             memcpy(destptr, data, itemsize);
             return obj;
         }
diff --git a/numpy/core/src/multiarray/scalartypes.c.src b/numpy/core/src/multiarray/scalartypes.c.src
index bbbc5bfa2a4d..16a78aec57d9 100644
--- a/numpy/core/src/multiarray/scalartypes.c.src
+++ b/numpy/core/src/multiarray/scalartypes.c.src
@@ -20,6 +20,7 @@
 #include "ctors.h"
 #include "usertypes.h"
 #include "numpyos.h"
+#include "can_cast_table.h"
 #include "common.h"
 #include "scalartypes.h"
 #include "_datetime.h"
@@ -229,7 +230,7 @@ gentype_multiply(PyObject *m1, PyObject *m2)
  * #convert = Long*8, LongLong*2#
  */
 static PyObject *
-@type@_bit_count(PyObject *self)
+@type@_bit_count(PyObject *self, PyObject *NPY_UNUSED(args))
 {
     @type@ scalar = PyArrayScalar_VAL(self, @Name@);
     uint8_t count = npy_popcount@c@(scalar);
@@ -895,15 +896,21 @@ static PyObject *
 @name@type_@kind@_either(npy_@name@ val, TrimMode trim_pos, TrimMode trim_sci,
                          npy_bool sign)
 {
-    npy_@name@ absval;
 
     if (npy_legacy_print_mode <= 113) {
         return legacy_@name@_format@kind@(val);
     }
 
-    absval = val < 0 ? -val : val;
+    int use_positional;
+    if (npy_isnan(val) || val == 0) {
+         use_positional = 1;
+    }
+    else {
+        npy_@name@ absval = val < 0 ? -val : val;
+        use_positional = absval < 1.e16L && absval >= 1.e-4L;
+    }
 
-    if (absval == 0 || (absval < 1.e16L && absval >= 1.e-4L) ) {
+    if (use_positional) {
         return format_@name@(val, 0, -1, sign, trim_pos, -1, -1, -1);
     }
     return format_@name@(val, 1, -1, sign, trim_sci, -1, -1, -1);
@@ -1071,6 +1078,8 @@ gentype_richcompare(PyObject *self, PyObject *other, int cmp_op)
         }
     }
 
+   RICHCMP_GIVE_UP_IF_NEEDED(self, other);
+
     arr = PyArray_FromScalar(self, NULL);
     if (arr == NULL) {
         return NULL;
@@ -1160,7 +1169,7 @@ gentype_size_get(PyObject *NPY_UNUSED(self), void *NPY_UNUSED(ignored))
 }
 
 static PyObject *
-gentype_sizeof(PyObject *self)
+gentype_sizeof(PyObject *self, PyObject *NPY_UNUSED(args))
 {
     Py_ssize_t nbytes;
     PyObject * isz = gentype_itemsize_get(self, NULL);
@@ -1203,8 +1212,7 @@ gentype_struct_get(PyObject *self, void *NPY_UNUSED(ignored))
     inter->two = 2;
     inter->nd = 0;
     inter->flags = PyArray_FLAGS(arr);
-    inter->flags &= ~(NPY_ARRAY_UPDATEIFCOPY | NPY_ARRAY_WRITEBACKIFCOPY |
-                      NPY_ARRAY_OWNDATA);
+    inter->flags &= ~(NPY_ARRAY_WRITEBACKIFCOPY | NPY_ARRAY_OWNDATA);
     inter->flags |= NPY_ARRAY_NOTSWAPPED;
     inter->typekind = PyArray_DESCR(arr)->kind;
     inter->itemsize = PyArray_DESCR(arr)->elsize;
@@ -1753,11 +1761,13 @@ gentype_reduce(PyObject *self, PyObject *NPY_UNUSED(args))
 
     mod = PyImport_ImportModule("numpy.core._multiarray_umath");
     if (mod == NULL) {
+        Py_DECREF(ret);
         return NULL;
     }
     obj = PyObject_GetAttrString(mod, "scalar");
     Py_DECREF(mod);
     if (obj == NULL) {
+        Py_DECREF(ret);
         return NULL;
     }
     PyTuple_SET_ITEM(ret, 0, obj);
@@ -1766,6 +1776,7 @@ gentype_reduce(PyObject *self, PyObject *NPY_UNUSED(args))
         PyObject *val = PyArrayScalar_VAL(self, Object);
         PyObject *tup = Py_BuildValue("NO", obj, val);
         if (tup == NULL) {
+            Py_DECREF(ret);
             return NULL;
         }
         PyTuple_SET_ITEM(ret, 1, tup);
@@ -1774,11 +1785,13 @@ gentype_reduce(PyObject *self, PyObject *NPY_UNUSED(args))
         /* a structured dtype with an object in a field */
         PyArrayObject *arr = (PyArrayObject *)PyArray_FromScalar(self, NULL);
         if (arr == NULL) {
+            Py_DECREF(ret);
             return NULL;
         }
         /* Use the whole array which handles sturctured void correctly */
         PyObject *tup = Py_BuildValue("NN", obj, arr);
         if (tup == NULL) {
+            Py_DECREF(ret);
             return NULL;
         }
         PyTuple_SET_ITEM(ret, 1, tup);
@@ -1855,7 +1868,7 @@ numbertype_class_getitem_abc(PyObject *cls, PyObject *args)
     }
 
     args_len = PyTuple_Check(args) ? PyTuple_Size(args) : 1;
-    if (args_len != args_len_expected) {
+    if ((args_len > args_len_expected) || (args_len == 0)) {
         return PyErr_Format(PyExc_TypeError,
                             "Too %s arguments for %s",
                             args_len > args_len_expected ? "many" : "few",
@@ -1918,7 +1931,7 @@ static PyObject *
  */
 /* Heavily copied from the builtin float.as_integer_ratio */
 static PyObject *
-@name@_as_integer_ratio(PyObject *self)
+@name@_as_integer_ratio(PyObject *self, PyObject *NPY_UNUSED(args))
 {
 #if @is_half@
     npy_double val = npy_half_to_double(PyArrayScalar_VAL(self, @Name@));
@@ -1999,7 +2012,7 @@ error:
  *  #c    = f, f, , l#
  */
 static PyObject *
-@name@_is_integer(PyObject *self)
+@name@_is_integer(PyObject *self, PyObject *NPY_UNUSED(args))
 {
 #if @is_half@
     npy_double val = npy_half_to_double(PyArrayScalar_VAL(self, @Name@));
@@ -2022,7 +2035,7 @@ static PyObject *
 /**end repeat**/
 
 static PyObject *
-integer_is_integer(PyObject *self) {
+integer_is_integer(PyObject *self, PyObject *NPY_UNUSED(args)) {
     Py_RETURN_TRUE;
 }
 
@@ -2585,6 +2598,7 @@ gentype_arrtype_getbuffer(PyObject *self, Py_buffer *view, int flags)
                 "user-defined scalar %R registered for built-in dtype %S? "
                 "This should be impossible.",
                 self, descr);
+        Py_DECREF(descr);
         return -1;
     }
     view->ndim = 0;
@@ -3169,28 +3183,33 @@ static PyObject *
 void_arrtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 {
     PyObject *obj, *arr;
-    PyObject *new = NULL;
+    PyArray_Descr *descr = NULL;
 
-    static char *kwnames[] = {"", NULL};  /* positional-only */
-    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O:void", kwnames, &obj)) {
+    static char *kwnames[] = {"", "dtype", NULL};
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O&:void", kwnames,
+            &obj, &PyArray_DescrConverter2, &descr)) {
         return NULL;
     }
     /*
      * For a VOID scalar first see if obj is an integer or long
      * and create new memory of that size (filled with 0) for the scalar
      */
-    if (PyLong_Check(obj) ||
+    if (descr == NULL && (
+            PyLong_Check(obj) ||
             PyArray_IsScalar(obj, Integer) ||
             (PyArray_Check(obj) &&
                      PyArray_NDIM((PyArrayObject *)obj)==0 &&
-                     PyArray_ISINTEGER((PyArrayObject *)obj))) {
-        new = Py_TYPE(obj)->tp_as_number->nb_int(obj);
-    }
-    if (new && PyLong_Check(new)) {
+                     PyArray_ISINTEGER((PyArrayObject *)obj)))) {
+
+        PyObject *length = Py_TYPE(obj)->tp_as_number->nb_int(obj);
+        if (length == NULL) {
+            return NULL;
+        }
+
         PyObject *ret;
         char *destptr;
-        npy_ulonglong memu = PyLong_AsUnsignedLongLong(new);
-        Py_DECREF(new);
+        npy_ulonglong memu = PyLong_AsUnsignedLongLong(length);
+        Py_DECREF(length);
         if (PyErr_Occurred() || (memu > NPY_MAX_INT)) {
             PyErr_Clear();
             PyErr_Format(PyExc_OverflowError,
@@ -3212,16 +3231,37 @@ void_arrtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
         }
         ((PyVoidScalarObject *)ret)->obval = destptr;
         Py_SET_SIZE((PyVoidScalarObject *)ret, (int) memu);
-        ((PyVoidScalarObject *)ret)->descr =
-            PyArray_DescrNewFromType(NPY_VOID);
-        ((PyVoidScalarObject *)ret)->descr->elsize = (int) memu;
         ((PyVoidScalarObject *)ret)->flags = NPY_ARRAY_BEHAVED |
                                              NPY_ARRAY_OWNDATA;
         ((PyVoidScalarObject *)ret)->base = NULL;
+        ((PyVoidScalarObject *)ret)->descr =
+            PyArray_DescrNewFromType(NPY_VOID);
+        if (((PyVoidScalarObject *)ret)->descr == NULL) {
+            Py_DECREF(ret);
+            return NULL;
+        }
+        ((PyVoidScalarObject *)ret)->descr->elsize = (int) memu;
         return ret;
     }
 
-    arr = PyArray_FROM_OTF(obj, NPY_VOID, NPY_ARRAY_FORCECAST);
+    if (descr == NULL) {
+        /* Use the "size-less" void dtype to discover the size. */
+        descr = PyArray_DescrNewFromType(NPY_VOID);
+        if (descr == NULL) {
+            return NULL;
+        }
+    }
+    else if (descr->type_num != NPY_VOID || PyDataType_HASSUBARRAY(descr)) {
+        /* we reject subarrays, since subarray scalars do not exist. */
+        PyErr_Format(PyExc_TypeError,
+                "void: descr must be a `void` dtype that is not "
+                "a subarray dtype (structured or unstructured). "
+                "Got '%.100R'.", descr);
+        Py_DECREF(descr);
+        return NULL;
+    }
+
+    arr = PyArray_FromAny(obj, descr, 0, 0, NPY_ARRAY_FORCECAST, NULL);
     return PyArray_Return((PyArrayObject *)arr);
 }
 
@@ -3558,7 +3598,6 @@ NPY_NO_EXPORT PyTypeObject PyObjectArrType_Type = {
     PyVarObject_HEAD_INIT(NULL, 0)
     .tp_name = "numpy.object_",
     .tp_basicsize = sizeof(PyObjectScalarObject),
-    .tp_alloc = object_arrtype_alloc,
     .tp_dealloc = (destructor)object_arrtype_dealloc,
     .tp_as_sequence = &object_arrtype_as_sequence,
     .tp_as_mapping = &object_arrtype_as_mapping,
@@ -3566,6 +3605,7 @@ NPY_NO_EXPORT PyTypeObject PyObjectArrType_Type = {
     .tp_getattro = (getattrofunc)object_arrtype_getattro,
     .tp_setattro = (setattrofunc)object_arrtype_setattro,
     .tp_as_buffer = &object_arrtype_as_buffer,
+    .tp_alloc = object_arrtype_alloc,
 };
 
 static PyObject *
@@ -3707,13 +3747,6 @@ _npy_smallest_type_of_kind_table[NPY_NSCALARKINDS];
 NPY_NO_EXPORT signed char
 _npy_next_larger_type_table[NPY_NTYPES];
 
-/*
- * This table describes safe casting for small type numbers,
- * and is used by PyArray_CanCastSafely.
- */
-NPY_NO_EXPORT unsigned char
-_npy_can_cast_safely_table[NPY_NTYPES][NPY_NTYPES];
-
 /*
  * This table gives the smallest-size and smallest-kind type to which
  * the input types may be safely cast, according to _npy_can_cast_safely.
@@ -3764,161 +3797,6 @@ initialize_casting_tables(void)
 
     /**end repeat**/
 
-    memset(_npy_can_cast_safely_table, 0, sizeof(_npy_can_cast_safely_table));
-
-    for (i = 0; i < NPY_NTYPES; ++i) {
-        /* Identity */
-        _npy_can_cast_safely_table[i][i] = 1;
-        if (i != NPY_DATETIME) {
-            /*
-             * Bool ->  except datetime (since
-             *                    it conceptually has no zero)
-             */
-            _npy_can_cast_safely_table[NPY_BOOL][i] = 1;
-        }
-        /*  -> Object */
-        _npy_can_cast_safely_table[i][NPY_OBJECT] = 1;
-        /*  -> Void */
-        _npy_can_cast_safely_table[i][NPY_VOID] = 1;
-    }
-
-    _npy_can_cast_safely_table[NPY_STRING][NPY_UNICODE] = 1;
-
-#ifndef NPY_SIZEOF_BYTE
-#define NPY_SIZEOF_BYTE 1
-#endif
-
-    /* Compile-time loop of casting rules */
-
-    /**begin repeat
-     * #FROM_NAME = BYTE, UBYTE, SHORT, USHORT, INT, UINT,
-     *              LONG, ULONG, LONGLONG, ULONGLONG,
-     *              HALF, FLOAT, DOUBLE, LONGDOUBLE,
-     *              CFLOAT, CDOUBLE, CLONGDOUBLE#
-     * #FROM_BASENAME = BYTE, BYTE, SHORT, SHORT, INT, INT,
-     *                  LONG, LONG, LONGLONG, LONGLONG,
-     *                  HALF, FLOAT, DOUBLE, LONGDOUBLE,
-     *                  FLOAT, DOUBLE, LONGDOUBLE#
-     * #from_isint = 1, 0, 1, 0, 1, 0, 1, 0,
-     *               1, 0, 0, 0, 0, 0,
-     *               0, 0, 0#
-     * #from_isuint = 0, 1, 0, 1, 0, 1, 0, 1,
-     *                0, 1, 0, 0, 0, 0,
-     *                0, 0, 0#
-     * #from_isfloat = 0, 0, 0, 0, 0, 0, 0, 0,
-     *                 0, 0, 1, 1, 1, 1,
-     *                 0, 0, 0#
-     * #from_iscomplex = 0, 0, 0, 0, 0, 0, 0, 0,
-     *                   0, 0, 0, 0, 0, 0,
-     *                   1, 1, 1#
-     */
-
-#define _FROM_BSIZE NPY_SIZEOF_@FROM_BASENAME@
-#define _FROM_NUM   (NPY_@FROM_NAME@)
-
-    _npy_can_cast_safely_table[_FROM_NUM][NPY_STRING] = 1;
-    _npy_can_cast_safely_table[_FROM_NUM][NPY_UNICODE] = 1;
-
-#if @from_isint@ && NPY_SIZEOF_TIMEDELTA >= _FROM_BSIZE
-    /* Allow casts from smaller or equal signed integers to the TIMEDELTA type */
-    _npy_can_cast_safely_table[_FROM_NUM][NPY_TIMEDELTA] = 1;
-#elif @from_isuint@ && NPY_SIZEOF_TIMEDELTA > _FROM_BSIZE
-    /* Allow casts from smaller unsigned integers to the TIMEDELTA type */
-    _npy_can_cast_safely_table[_FROM_NUM][NPY_TIMEDELTA] = 1;
-#endif
-
-    /**begin repeat1
-     * #TO_NAME = BYTE, UBYTE, SHORT, USHORT, INT, UINT,
-     *            LONG, ULONG, LONGLONG, ULONGLONG,
-     *            HALF, FLOAT, DOUBLE, LONGDOUBLE,
-     *            CFLOAT, CDOUBLE, CLONGDOUBLE#
-     * #TO_BASENAME = BYTE, BYTE, SHORT, SHORT, INT, INT,
-     *                LONG, LONG, LONGLONG, LONGLONG,
-     *                HALF, FLOAT, DOUBLE, LONGDOUBLE,
-     *                FLOAT, DOUBLE, LONGDOUBLE#
-     * #to_isint = 1, 0, 1, 0, 1, 0, 1, 0,
-     *             1, 0, 0, 0, 0, 0,
-     *             0, 0, 0#
-     * #to_isuint = 0, 1, 0, 1, 0, 1, 0, 1,
-     *              0, 1, 0, 0, 0, 0,
-     *              0, 0, 0#
-     * #to_isfloat = 0, 0, 0, 0, 0, 0, 0, 0,
-     *               0, 0, 1, 1, 1, 1,
-     *               0, 0, 0#
-     * #to_iscomplex = 0, 0, 0, 0, 0, 0, 0, 0,
-     *                 0, 0, 0, 0, 0, 0,
-     *                 1, 1, 1#
-     */
-#define _TO_BSIZE NPY_SIZEOF_@TO_BASENAME@
-#define _TO_NUM   (NPY_@TO_NAME@)
-
-    /*
-     * NOTE: _FROM_BSIZE and _TO_BSIZE are the sizes of the "base type"
-     *       which is the same as the size of the type except for
-     *       complex, where it is the size of the real type.
-     */
-
-#if @from_isint@
-
-#  if @to_isint@ && (_TO_BSIZE >= _FROM_BSIZE)
-    /* int -> int */
-    _npy_can_cast_safely_table[_FROM_NUM][_TO_NUM] = 1;
-#  elif @to_isfloat@ && (_FROM_BSIZE < 8) && (_TO_BSIZE > _FROM_BSIZE)
-    /* int -> float */
-    _npy_can_cast_safely_table[_FROM_NUM][_TO_NUM] = 1;
-#  elif @to_isfloat@ && (_FROM_BSIZE >= 8) && (_TO_BSIZE >= _FROM_BSIZE)
-    /* int -> float */
-    _npy_can_cast_safely_table[_FROM_NUM][_TO_NUM] = 1;
-#  elif @to_iscomplex@ && (_FROM_BSIZE < 8) && (_TO_BSIZE > _FROM_BSIZE)
-    /* int -> complex */
-    _npy_can_cast_safely_table[_FROM_NUM][_TO_NUM] = 1;
-#  elif @to_iscomplex@ && (_FROM_BSIZE >= 8) && (_TO_BSIZE >= _FROM_BSIZE)
-    /* int -> complex */
-    _npy_can_cast_safely_table[_FROM_NUM][_TO_NUM] = 1;
-#  endif
-
-#elif @from_isuint@
-
-#  if @to_isint@ && (_TO_BSIZE > _FROM_BSIZE)
-    /* uint -> int */
-    _npy_can_cast_safely_table[_FROM_NUM][_TO_NUM] = 1;
-#  elif @to_isuint@ && (_TO_BSIZE >= _FROM_BSIZE)
-    /* uint -> uint */
-    _npy_can_cast_safely_table[_FROM_NUM][_TO_NUM] = 1;
-#  elif @to_isfloat@ && (_FROM_BSIZE < 8) && (_TO_BSIZE > _FROM_BSIZE)
-    /* uint -> float */
-    _npy_can_cast_safely_table[_FROM_NUM][_TO_NUM] = 1;
-#  elif @to_isfloat@ && (_FROM_BSIZE >= 8) && (_TO_BSIZE >= _FROM_BSIZE)
-    /* uint -> float */
-    _npy_can_cast_safely_table[_FROM_NUM][_TO_NUM] = 1;
-#  elif @to_iscomplex@ && (_FROM_BSIZE < 8) && (_TO_BSIZE > _FROM_BSIZE)
-    /* uint -> complex */
-    _npy_can_cast_safely_table[_FROM_NUM][_TO_NUM] = 1;
-#  elif @to_iscomplex@ && (_FROM_BSIZE >= 8) && (_TO_BSIZE >= _FROM_BSIZE)
-    /* uint -> complex */
-    _npy_can_cast_safely_table[_FROM_NUM][_TO_NUM] = 1;
-#  endif
-
-
-#elif @from_isfloat@
-
-#  if @to_isfloat@ && (_TO_BSIZE >= _FROM_BSIZE)
-    /* float -> float */
-    _npy_can_cast_safely_table[_FROM_NUM][_TO_NUM] = 1;
-#  elif @to_iscomplex@ && (_TO_BSIZE >= _FROM_BSIZE)
-    /* float -> complex */
-    _npy_can_cast_safely_table[_FROM_NUM][_TO_NUM] = 1;
-#  endif
-
-#elif @from_iscomplex@
-
-#  if @to_iscomplex@ && (_TO_BSIZE >= _FROM_BSIZE)
-    /* complex -> complex */
-    _npy_can_cast_safely_table[_FROM_NUM][_TO_NUM] = 1;
-#  endif
-
-#endif
-
 #undef _TO_NUM
 #undef _TO_BSIZE
 
diff --git a/numpy/core/src/multiarray/scalartypes.h b/numpy/core/src/multiarray/scalartypes.h
index 95a2f66c6fbc..4d6eda2a1b7b 100644
--- a/numpy/core/src/multiarray/scalartypes.h
+++ b/numpy/core/src/multiarray/scalartypes.h
@@ -1,9 +1,10 @@
 #ifndef NUMPY_CORE_SRC_MULTIARRAY_SCALARTYPES_H_
 #define NUMPY_CORE_SRC_MULTIARRAY_SCALARTYPES_H_
 
-/* Internal look-up tables */
-extern NPY_NO_EXPORT unsigned char
-_npy_can_cast_safely_table[NPY_NTYPES][NPY_NTYPES];
+/*
+ * Internal look-up tables, casting safety is defined in convert_datatype.h.
+ * Most of these should be phased out eventually, but some are still used.
+ */
 extern NPY_NO_EXPORT signed char
 _npy_scalar_kinds_table[NPY_NTYPES];
 extern NPY_NO_EXPORT signed char
diff --git a/numpy/core/src/multiarray/shape.c b/numpy/core/src/multiarray/shape.c
index 162abd6a49c8..dc7151a9bef5 100644
--- a/numpy/core/src/multiarray/shape.c
+++ b/numpy/core/src/multiarray/shape.c
@@ -19,7 +19,7 @@
 #include "shape.h"
 
 #include "multiarraymodule.h" /* for interned strings */
-#include "templ_common.h" /* for npy_mul_with_overflow_intp */
+#include "templ_common.h" /* for npy_mul_sizes_with_overflow */
 #include "common.h" /* for convert_shape_to_string */
 #include "alloc.h"
 
@@ -71,7 +71,7 @@ PyArray_Resize(PyArrayObject *self, PyArray_Dims *newshape, int refcheck,
                     "negative dimensions not allowed");
             return NULL;
         }
-        if (npy_mul_with_overflow_intp(&newsize, newsize, new_dimensions[k])) {
+        if (npy_mul_sizes_with_overflow(&newsize, newsize, new_dimensions[k])) {
             return PyErr_NoMemory();
         }
     }
@@ -79,7 +79,7 @@ PyArray_Resize(PyArrayObject *self, PyArray_Dims *newshape, int refcheck,
     /* Convert to number of bytes. The new count might overflow */
     elsize = PyArray_DESCR(self)->elsize;
     oldnbytes = oldsize * elsize;
-    if (npy_mul_with_overflow_intp(&newnbytes, newsize, elsize)) {
+    if (npy_mul_sizes_with_overflow(&newnbytes, newsize, elsize)) {
         return PyErr_NoMemory();
     }
 
@@ -211,7 +211,7 @@ PyArray_Newshape(PyArrayObject *self, PyArray_Dims *newdims,
     int flags;
 
     if (order == NPY_ANYORDER) {
-        order = PyArray_ISFORTRAN(self);
+        order = PyArray_ISFORTRAN(self) ? NPY_FORTRANORDER : NPY_CORDER;
     }
     else if (order == NPY_KEEPORDER) {
         PyErr_SetString(PyExc_ValueError,
@@ -244,11 +244,9 @@ PyArray_Newshape(PyArrayObject *self, PyArray_Dims *newdims,
      * in order to get the right orientation and
      * because we can't just re-use the buffer with the
      * data in the order it is in.
-     * NPY_RELAXED_STRIDES_CHECKING: size check is unnecessary when set.
      */
     Py_INCREF(self);
-    if ((PyArray_SIZE(self) > 1) &&
-        ((order == NPY_CORDER && !PyArray_IS_C_CONTIGUOUS(self)) ||
+    if (((order == NPY_CORDER && !PyArray_IS_C_CONTIGUOUS(self)) ||
          (order == NPY_FORTRANORDER && !PyArray_IS_F_CONTIGUOUS(self)))) {
         int success = 0;
         success = _attempt_nocopy_reshape(self, ndim, dimensions,
@@ -500,7 +498,7 @@ _fix_unknown_dimension(PyArray_Dims *newshape, PyArrayObject *arr)
                 return -1;
             }
         }
-        else if (npy_mul_with_overflow_intp(&s_known, s_known,
+        else if (npy_mul_sizes_with_overflow(&s_known, s_known,
                                             dimensions[i])) {
             raise_reshape_size_mismatch(newshape, arr);
             return -1;
@@ -1000,7 +998,6 @@ PyArray_Flatten(PyArrayObject *a, NPY_ORDER order)
  *          If an axis flagged for removal has a shape larger than one,
  *          the aligned flag (and in the future the contiguous flags),
  *          may need explicit update.
- *          (check also NPY_RELAXED_STRIDES_CHECKING)
  *
  * For example, this can be used to remove the reduction axes
  * from a reduction result once its computation is complete.
@@ -1024,6 +1021,6 @@ PyArray_RemoveAxesInPlace(PyArrayObject *arr, const npy_bool *flags)
     /* The final number of dimensions */
     fa->nd = idim_out;
 
-    /* May not be necessary for NPY_RELAXED_STRIDES_CHECKING (see comment) */
+    /* NOTE: This is only necessary if a dimension with size != 1 was removed */
     PyArray_UpdateFlags(arr, NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_F_CONTIGUOUS);
 }
diff --git a/numpy/core/src/multiarray/temp_elide.c b/numpy/core/src/multiarray/temp_elide.c
index f615aa3360e6..0bf500ed29c5 100644
--- a/numpy/core/src/multiarray/temp_elide.c
+++ b/numpy/core/src/multiarray/temp_elide.c
@@ -82,7 +82,12 @@
 #define NPY_MIN_ELIDE_BYTES (32)
 #endif
 #include 
+
+#if defined HAVE_EXECINFO_H
 #include 
+#elif defined HAVE_LIBUNWIND_H
+#include 
+#endif
 
 /*
  * linear search pointer in table
@@ -286,7 +291,6 @@ can_elide_temp(PyObject *olhs, PyObject *orhs, int *cannot)
             !PyArray_ISNUMBER(alhs) ||
             !PyArray_CHKFLAGS(alhs, NPY_ARRAY_OWNDATA) ||
             !PyArray_ISWRITEABLE(alhs) ||
-            PyArray_CHKFLAGS(alhs, NPY_ARRAY_UPDATEIFCOPY) ||
             PyArray_CHKFLAGS(alhs, NPY_ARRAY_WRITEBACKIFCOPY) ||
             PyArray_NBYTES(alhs) < NPY_MIN_ELIDE_BYTES) {
         return 0;
@@ -365,7 +369,6 @@ can_elide_temp_unary(PyArrayObject * m1)
             !PyArray_ISNUMBER(m1) ||
             !PyArray_CHKFLAGS(m1, NPY_ARRAY_OWNDATA) ||
             !PyArray_ISWRITEABLE(m1) ||
-            PyArray_CHKFLAGS(m1, NPY_ARRAY_UPDATEIFCOPY) ||
             PyArray_NBYTES(m1) < NPY_MIN_ELIDE_BYTES) {
         return 0;
     }
diff --git a/numpy/core/src/multiarray/textreading/conversions.c b/numpy/core/src/multiarray/textreading/conversions.c
new file mode 100644
index 000000000000..6c93e02d8797
--- /dev/null
+++ b/numpy/core/src/multiarray/textreading/conversions.c
@@ -0,0 +1,395 @@
+
+#include 
+
+#include 
+#include 
+#include 
+
+#define NPY_NO_DEPRECATED_API NPY_API_VERSION
+#define _MULTIARRAYMODULE
+#include "lowlevel_strided_loops.h"
+
+#include "conversions.h"
+#include "str_to_int.h"
+
+#include "array_coercion.h"
+
+
+/*
+ * Coercion to boolean is done via integer right now.
+ */
+NPY_NO_EXPORT int
+npy_to_bool(PyArray_Descr *NPY_UNUSED(descr),
+        const Py_UCS4 *str, const Py_UCS4 *end, char *dataptr,
+        parser_config *NPY_UNUSED(pconfig))
+{
+    int64_t res;
+    if (str_to_int64(str, end, INT64_MIN, INT64_MAX, &res) < 0) {
+        return -1;
+    }
+    *dataptr = (char)(res != 0);
+    return 0;
+}
+
+
+/*
+ * In order to not pack a whole copy of a floating point parser, we copy the
+ * result into ascii and call the Python one.  Float parsing isn't super quick
+ * so this is not terrible, but avoiding it would speed up things.
+ *
+ * Also note that parsing the first float of a complex will copy the whole
+ * string to ascii rather than just the first part.
+ * TODO: A tweak of the break might be a simple mitigation there.
+ *
+ * @param str The UCS4 string to parse
+ * @param end Pointer to the end of the string
+ * @param skip_trailing_whitespace If false does not skip trailing whitespace
+ *        (used by the complex parser).
+ * @param result Output stored as double value.
+ */
+static NPY_INLINE int
+double_from_ucs4(
+        const Py_UCS4 *str, const Py_UCS4 *end,
+        bool strip_whitespace, double *result, const Py_UCS4 **p_end)
+{
+    /* skip leading whitespace */
+    if (strip_whitespace) {
+        while (Py_UNICODE_ISSPACE(*str)) {
+            str++;
+        }
+    }
+    if (str == end) {
+        return -1;  /* empty or only whitespace: not a floating point number */
+    }
+
+    /* We convert to ASCII for the Python parser, use stack if small: */
+    char stack_buf[128];
+    char *heap_buf = NULL;
+    char *ascii = stack_buf;
+
+    size_t str_len = end - str + 1;
+    if (str_len > 128) {
+        heap_buf = PyMem_MALLOC(str_len);
+        if (heap_buf == NULL) {
+            PyErr_NoMemory();
+            return -1;
+        }
+        ascii = heap_buf;
+    }
+    char *c = ascii;
+    for (; str < end; str++, c++) {
+        if (NPY_UNLIKELY(*str >= 128)) {
+            /* Character cannot be used, ignore for end calculation and stop */
+            end = str;
+            break;
+        }
+        *c = (char)(*str);
+    }
+    *c = '\0';
+
+    char *end_parsed;
+    *result = PyOS_string_to_double(ascii, &end_parsed, NULL);
+    /* Rewind `end` to the first UCS4 character not parsed: */
+    end = end - (c - end_parsed);
+
+    PyMem_FREE(heap_buf);
+
+    if (*result == -1. && PyErr_Occurred()) {
+        return -1;
+    }
+
+    if (strip_whitespace) {
+        /* and then skip any remaining whitespace: */
+        while (Py_UNICODE_ISSPACE(*end)) {
+            end++;
+        }
+    }
+    *p_end = end;
+    return 0;
+}
+
+
+NPY_NO_EXPORT int
+npy_to_float(PyArray_Descr *descr,
+        const Py_UCS4 *str, const Py_UCS4 *end, char *dataptr,
+        parser_config *NPY_UNUSED(pconfig))
+{
+    double double_val;
+    const Py_UCS4 *p_end;
+    if (double_from_ucs4(str, end, true, &double_val, &p_end) < 0) {
+        return -1;
+    }
+    if (p_end != end) {
+        return -1;
+    }
+
+    float val = (float)double_val;
+    memcpy(dataptr, &val, sizeof(float));
+    if (!PyArray_ISNBO(descr->byteorder)) {
+        npy_bswap4_unaligned(dataptr);
+    }
+    return 0;
+}
+
+
+NPY_NO_EXPORT int
+npy_to_double(PyArray_Descr *descr,
+        const Py_UCS4 *str, const Py_UCS4 *end, char *dataptr,
+        parser_config *NPY_UNUSED(pconfig))
+{
+    double val;
+    const Py_UCS4 *p_end;
+    if (double_from_ucs4(str, end, true, &val, &p_end) < 0) {
+        return -1;
+    }
+    if (p_end != end) {
+        return -1;
+    }
+
+    memcpy(dataptr, &val, sizeof(double));
+    if (!PyArray_ISNBO(descr->byteorder)) {
+        npy_bswap8_unaligned(dataptr);
+    }
+    return 0;
+}
+
+
+static bool
+to_complex_int(
+        const Py_UCS4 *item, const Py_UCS4 *token_end,
+        double *p_real, double *p_imag,
+        Py_UCS4 imaginary_unit, bool allow_parens)
+{
+    const Py_UCS4 *p_end;
+    bool unmatched_opening_paren = false;
+
+    /* Remove whitespace before the possibly leading '(' */
+    while (Py_UNICODE_ISSPACE(*item)) {
+        ++item;
+    }
+    if (allow_parens && (*item == '(')) {
+        unmatched_opening_paren = true;
+        ++item;
+        /* Allow whitespace within the parentheses: "( 1j)" */
+        while (Py_UNICODE_ISSPACE(*item)) {
+            ++item;
+        }
+    }
+    if (double_from_ucs4(item, token_end, false, p_real, &p_end) < 0) {
+        return false;
+    }
+    if (p_end == token_end) {
+        // No imaginary part in the string (e.g. "3.5")
+        *p_imag = 0.0;
+        return !unmatched_opening_paren;
+    }
+    if (*p_end == imaginary_unit) {
+        /* Only an imaginary part (e.g "1.5j") */
+        *p_imag = *p_real;
+        *p_real = 0.0;
+        ++p_end;
+    }
+    else if (*p_end == '+' || *p_end == '-') {
+        /* Imaginary part still to parse */
+        if (*p_end == '+') {
+            ++p_end;  /* Advance to support +- (and ++) */
+        }
+        if (double_from_ucs4(p_end, token_end, false, p_imag, &p_end) < 0) {
+            return false;
+        }
+        if (*p_end != imaginary_unit) {
+            return false;
+        }
+        ++p_end;
+    }
+    else {
+        *p_imag = 0;
+    }
+
+    if (unmatched_opening_paren) {
+        /* Allow whitespace inside brackets as in "(1+2j )" or "( 1j )" */
+        while (Py_UNICODE_ISSPACE(*p_end)) {
+            ++p_end;
+        }
+        if (*p_end == ')') {
+            ++p_end;
+        }
+        else {
+            /* parentheses was not closed */
+            return false;
+        }
+    }
+
+    while (Py_UNICODE_ISSPACE(*p_end)) {
+        ++p_end;
+    }
+    return p_end == token_end;
+}
+
+
+NPY_NO_EXPORT int
+npy_to_cfloat(PyArray_Descr *descr,
+        const Py_UCS4 *str, const Py_UCS4 *end, char *dataptr,
+        parser_config *pconfig)
+{
+    double real;
+    double imag;
+
+    bool success = to_complex_int(
+            str, end, &real, &imag,
+            pconfig->imaginary_unit, true);
+
+    if (!success) {
+        return -1;
+    }
+    npy_complex64 val = {(float)real, (float)imag};
+    memcpy(dataptr, &val, sizeof(npy_complex64));
+    if (!PyArray_ISNBO(descr->byteorder)) {
+        npy_bswap4_unaligned(dataptr);
+        npy_bswap4_unaligned(dataptr + 4);
+    }
+    return 0;
+}
+
+
+NPY_NO_EXPORT int
+npy_to_cdouble(PyArray_Descr *descr,
+        const Py_UCS4 *str, const Py_UCS4 *end, char *dataptr,
+        parser_config *pconfig)
+{
+    double real;
+    double imag;
+
+    bool success = to_complex_int(
+            str, end, &real, &imag, pconfig->imaginary_unit, true);
+
+    if (!success) {
+        return -1;
+    }
+    npy_complex128 val = {real, imag};
+    memcpy(dataptr, &val, sizeof(npy_complex128));
+    if (!PyArray_ISNBO(descr->byteorder)) {
+        npy_bswap8_unaligned(dataptr);
+        npy_bswap8_unaligned(dataptr + 8);
+    }
+    return 0;
+}
+
+
+/*
+ * String and unicode conversion functions.
+ */
+NPY_NO_EXPORT int
+npy_to_string(PyArray_Descr *descr,
+        const Py_UCS4 *str, const Py_UCS4 *end, char *dataptr,
+        parser_config *NPY_UNUSED(unused))
+{
+    const Py_UCS4* c = str;
+    size_t length = descr->elsize;
+
+    for (size_t i = 0; i < length; i++) {
+        if (c < end) {
+            /*
+             * loadtxt assumed latin1, which is compatible with UCS1 (first
+             * 256 unicode characters).
+             */
+            if (NPY_UNLIKELY(*c > 255)) {
+                /* TODO: Was UnicodeDecodeError, is unspecific error good? */
+                return -1;
+            }
+            dataptr[i] = (Py_UCS1)(*c);
+            c++;
+        }
+        else {
+            dataptr[i] = '\0';
+        }
+    }
+    return 0;
+}
+
+
+NPY_NO_EXPORT int
+npy_to_unicode(PyArray_Descr *descr,
+        const Py_UCS4 *str, const Py_UCS4 *end, char *dataptr,
+        parser_config *NPY_UNUSED(unused))
+{
+    int length = descr->elsize / 4;
+
+    if (length <= end - str) {
+        memcpy(dataptr, str, length * 4);
+    }
+    else {
+        size_t given_len = end - str;
+        memcpy(dataptr, str, given_len * 4);
+        memset(dataptr + given_len * 4, '\0', (length - given_len) * 4);
+    }
+
+    if (!PyArray_ISNBO(descr->byteorder)) {
+        for (int i = 0; i < length; i++) {
+            npy_bswap4_unaligned(dataptr);
+            dataptr += 4;
+        }
+    }
+    return 0;
+}
+
+
+
+/*
+ * Convert functions helper for the generic converter.
+ */
+static PyObject *
+call_converter_function(
+        PyObject *func, const Py_UCS4 *str, size_t length, bool byte_converters)
+{
+    PyObject *s = PyUnicode_FromKindAndData(PyUnicode_4BYTE_KIND, str, length);
+    if (s == NULL) {
+        return s;
+    }
+    if (byte_converters) {
+        Py_SETREF(s, PyUnicode_AsEncodedString(s, "latin1", NULL));
+        if (s == NULL) {
+            return NULL;
+        }
+    }
+    if (func == NULL) {
+        return s;
+    }
+    PyObject *result = PyObject_CallFunctionObjArgs(func, s, NULL);
+    Py_DECREF(s);
+    return result;
+}
+
+
+NPY_NO_EXPORT int
+npy_to_generic_with_converter(PyArray_Descr *descr,
+        const Py_UCS4 *str, const Py_UCS4 *end, char *dataptr,
+        parser_config *config, PyObject *func)
+{
+    bool use_byte_converter;
+    if (func == NULL) {
+        use_byte_converter = config->c_byte_converters;
+    }
+    else {
+        use_byte_converter = config->python_byte_converters;
+    }
+    /* Converts to unicode and calls custom converter (if set) */
+    PyObject *converted = call_converter_function(
+            func, str, (size_t)(end - str), use_byte_converter);
+    if (converted == NULL) {
+        return -1;
+    }
+
+    int res = PyArray_Pack(descr, dataptr, converted);
+    Py_DECREF(converted);
+    return res;
+}
+
+
+NPY_NO_EXPORT int
+npy_to_generic(PyArray_Descr *descr,
+        const Py_UCS4 *str, const Py_UCS4 *end, char *dataptr,
+        parser_config *config)
+{
+    return npy_to_generic_with_converter(descr, str, end, dataptr, config, NULL);
+}
diff --git a/numpy/core/src/multiarray/textreading/conversions.h b/numpy/core/src/multiarray/textreading/conversions.h
new file mode 100644
index 000000000000..09f2510413b5
--- /dev/null
+++ b/numpy/core/src/multiarray/textreading/conversions.h
@@ -0,0 +1,57 @@
+#ifndef NUMPY_CORE_SRC_MULTIARRAY_TEXTREADING_CONVERSIONS_H_
+#define NUMPY_CORE_SRC_MULTIARRAY_TEXTREADING_CONVERSIONS_H_
+
+#include 
+
+#define NPY_NO_DEPRECATED_API NPY_API_VERSION
+#define _MULTIARRAYMODULE
+#include "numpy/arrayobject.h"
+
+#include "textreading/parser_config.h"
+
+NPY_NO_EXPORT int
+npy_to_bool(PyArray_Descr *descr,
+        const Py_UCS4 *str, const Py_UCS4 *end, char *dataptr,
+        parser_config *pconfig);
+
+NPY_NO_EXPORT int
+npy_to_float(PyArray_Descr *descr,
+        const Py_UCS4 *str, const Py_UCS4 *end, char *dataptr,
+        parser_config *pconfig);
+
+NPY_NO_EXPORT int
+npy_to_double(PyArray_Descr *descr,
+        const Py_UCS4 *str, const Py_UCS4 *end, char *dataptr,
+        parser_config *pconfig);
+
+NPY_NO_EXPORT int
+npy_to_cfloat(PyArray_Descr *descr,
+        const Py_UCS4 *str, const Py_UCS4 *end, char *dataptr,
+        parser_config *pconfig);
+
+NPY_NO_EXPORT int
+npy_to_cdouble(PyArray_Descr *descr,
+        const Py_UCS4 *str, const Py_UCS4 *end, char *dataptr,
+        parser_config *pconfig);
+
+NPY_NO_EXPORT int
+npy_to_string(PyArray_Descr *descr,
+        const Py_UCS4 *str, const Py_UCS4 *end, char *dataptr,
+        parser_config *unused);
+
+NPY_NO_EXPORT int
+npy_to_unicode(PyArray_Descr *descr,
+        const Py_UCS4 *str, const Py_UCS4 *end, char *dataptr,
+        parser_config *unused);
+
+NPY_NO_EXPORT int
+npy_to_generic_with_converter(PyArray_Descr *descr,
+        const Py_UCS4 *str, const Py_UCS4 *end, char *dataptr,
+        parser_config *unused, PyObject *func);
+
+NPY_NO_EXPORT int
+npy_to_generic(PyArray_Descr *descr,
+        const Py_UCS4 *str, const Py_UCS4 *end, char *dataptr,
+        parser_config *pconfig);
+
+#endif  /* NUMPY_CORE_SRC_MULTIARRAY_TEXTREADING_CONVERSIONS_H_ */
diff --git a/numpy/core/src/multiarray/textreading/field_types.c b/numpy/core/src/multiarray/textreading/field_types.c
new file mode 100644
index 000000000000..c3202bd2a1c8
--- /dev/null
+++ b/numpy/core/src/multiarray/textreading/field_types.c
@@ -0,0 +1,201 @@
+#include "field_types.h"
+#include "conversions.h"
+#include "str_to_int.h"
+
+#define NPY_NO_DEPRECATED_API NPY_API_VERSION
+#define _MULTIARRAYMODULE
+#include "numpy/ndarraytypes.h"
+#include "alloc.h"
+
+#include "textreading/growth.h"
+
+
+NPY_NO_EXPORT void
+field_types_xclear(int num_field_types, field_type *ft) {
+    assert(num_field_types >= 0);
+    if (ft == NULL) {
+        return;
+    }
+    for (int i = 0; i < num_field_types; i++) {
+        Py_XDECREF(ft[i].descr);
+        ft[i].descr = NULL;
+    }
+    PyMem_Free(ft);
+}
+
+
+/*
+ * Fetch custom converters for the builtin NumPy DTypes (or the generic one).
+ * Structured DTypes get unpacked and `object` uses the generic method.
+ *
+ * TODO: This should probably be moved on the DType object in some form,
+ *       to allow user DTypes to define their own converters.
+ */
+static set_from_ucs4_function *
+get_from_ucs4_function(PyArray_Descr *descr)
+{
+    if (descr->type_num == NPY_BOOL) {
+        return &npy_to_bool;
+    }
+    else if (PyDataType_ISSIGNED(descr)) {
+        switch (descr->elsize) {
+            case 1:
+                return &npy_to_int8;
+            case 2:
+                return &npy_to_int16;
+            case 4:
+                return &npy_to_int32;
+            case 8:
+                return &npy_to_int64;
+            default:
+                assert(0);
+        }
+    }
+    else if (PyDataType_ISUNSIGNED(descr)) {
+        switch (descr->elsize) {
+            case 1:
+                return &npy_to_uint8;
+            case 2:
+                return &npy_to_uint16;
+            case 4:
+                return &npy_to_uint32;
+            case 8:
+                return &npy_to_uint64;
+            default:
+                assert(0);
+        }
+    }
+    else if (descr->type_num == NPY_FLOAT) {
+        return &npy_to_float;
+    }
+    else if (descr->type_num == NPY_DOUBLE) {
+        return &npy_to_double;
+    }
+    else if (descr->type_num == NPY_CFLOAT) {
+        return &npy_to_cfloat;
+    }
+    else if (descr->type_num == NPY_CDOUBLE) {
+        return &npy_to_cdouble;
+    }
+    else if (descr->type_num == NPY_STRING) {
+        return &npy_to_string;
+    }
+    else if (descr->type_num == NPY_UNICODE) {
+        return &npy_to_unicode;
+    }
+    return &npy_to_generic;
+}
+
+
+/*
+ * Note that the function cleans up `ft` on error.  If `num_field_types < 0`
+ * cleanup has already happened in the internal call.
+ */
+static npy_intp
+field_type_grow_recursive(PyArray_Descr *descr,
+        npy_intp num_field_types, field_type **ft, npy_intp *ft_size,
+        npy_intp field_offset)
+{
+    if (PyDataType_HASSUBARRAY(descr)) {
+        PyArray_Dims shape = {NULL, -1};
+
+        if (!(PyArray_IntpConverter(descr->subarray->shape, &shape))) {
+             PyErr_SetString(PyExc_ValueError, "invalid subarray shape");
+             field_types_xclear(num_field_types, *ft);
+             return -1;
+        }
+        npy_intp size = PyArray_MultiplyList(shape.ptr, shape.len);
+        npy_free_cache_dim_obj(shape);
+        for (npy_intp i = 0; i < size; i++) {
+            num_field_types = field_type_grow_recursive(descr->subarray->base,
+                    num_field_types, ft, ft_size, field_offset);
+            field_offset += descr->subarray->base->elsize;
+            if (num_field_types < 0) {
+                return -1;
+            }
+        }
+        return num_field_types;
+    }
+    else if (PyDataType_HASFIELDS(descr)) {
+        npy_int num_descr_fields = PyTuple_Size(descr->names);
+        if (num_descr_fields < 0) {
+            field_types_xclear(num_field_types, *ft);
+            return -1;
+        }
+        for (npy_intp i = 0; i < num_descr_fields; i++) {
+            PyObject *key = PyTuple_GET_ITEM(descr->names, i);
+            PyObject *tup = PyObject_GetItem(descr->fields, key);
+            if (tup == NULL) {
+                field_types_xclear(num_field_types, *ft);
+                return -1;
+            }
+            PyArray_Descr *field_descr;
+            PyObject *title;
+            int offset;
+            if (!PyArg_ParseTuple(tup, "Oi|O", &field_descr, &offset, &title)) {
+                Py_DECREF(tup);
+                field_types_xclear(num_field_types, *ft);
+                return -1;
+            }
+            Py_DECREF(tup);
+            num_field_types = field_type_grow_recursive(
+                    field_descr, num_field_types, ft, ft_size,
+                    field_offset + offset);
+            if (num_field_types < 0) {
+                return -1;
+            }
+        }
+        return num_field_types;
+    }
+
+    if (*ft_size <= num_field_types) {
+        npy_intp alloc_size = grow_size_and_multiply(
+                ft_size, 4, sizeof(field_type));
+        if (alloc_size < 0) {
+            field_types_xclear(num_field_types, *ft);
+            return -1;
+        }
+        field_type *new_ft = PyMem_Realloc(*ft, alloc_size);
+        if (new_ft == NULL) {
+            field_types_xclear(num_field_types, *ft);
+            return -1;
+        }
+        *ft = new_ft;
+    }
+
+    Py_INCREF(descr);
+    (*ft)[num_field_types].descr = descr;
+    (*ft)[num_field_types].set_from_ucs4 = get_from_ucs4_function(descr);
+    (*ft)[num_field_types].structured_offset = field_offset;
+
+    return num_field_types + 1;
+}
+
+
+/*
+ * Prepare the "field_types" for the given dtypes/descriptors.  Currently,
+ * we copy the itemsize, but the main thing is that we check for custom
+ * converters.
+ */
+NPY_NO_EXPORT npy_intp
+field_types_create(PyArray_Descr *descr, field_type **ft)
+{
+    if (descr->subarray != NULL) {
+        /*
+         * This could probably be allowed, but NumPy absorbs the dimensions
+         * so it is an awkward corner case that probably never really worked.
+         */
+        PyErr_SetString(PyExc_TypeError,
+                "file reader does not support subarray dtypes.  You can"
+                "put the dtype into a structured one using "
+                "`np.dtype(('name', dtype))` to avoid this limitation.");
+        return -1;
+    }
+
+    npy_intp ft_size = 4;
+    *ft = PyMem_Malloc(ft_size * sizeof(field_type));
+    if (*ft == NULL) {
+        return -1;
+    }
+    return field_type_grow_recursive(descr, 0, ft, &ft_size, 0);
+}
diff --git a/numpy/core/src/multiarray/textreading/field_types.h b/numpy/core/src/multiarray/textreading/field_types.h
new file mode 100644
index 000000000000..d335a366595f
--- /dev/null
+++ b/numpy/core/src/multiarray/textreading/field_types.h
@@ -0,0 +1,67 @@
+
+#ifndef NUMPY_CORE_SRC_MULTIARRAY_TEXTREADING_FIELD_TYPES_H_
+#define NUMPY_CORE_SRC_MULTIARRAY_TEXTREADING_FIELD_TYPES_H_
+
+#include 
+#include 
+#define NPY_NO_DEPRECATED_API NPY_API_VERSION
+#define _MULTIARRAYMODULE
+#include "numpy/ndarraytypes.h"
+
+#include "textreading/parser_config.h"
+
+/**
+ * Function defining the conversion for each value.
+ *
+ * This function must support unaligned memory access.  As of now, there is
+ * no special error handling (in whatever form):  We assume that it is always
+ * reasonable to raise a `ValueError` noting the string that failed to be
+ * converted.
+ *
+ * NOTE: An earlier version of the code had unused default values (pandas
+ *       does this) when columns are missing.  We could define this either
+ *       by passing `NULL` in, or by adding a default explicitly somewhere.
+ *       (I think users should probably have to define the default, at which
+ *       point it doesn't matter here.)
+ *
+ * NOTE: We are currently passing the parser config, this could be made public
+ *       or could be set up to be dtype specific/private.  Always passing
+ *       pconfig fully seems easier right now even if it may change.
+ *       (A future use-case may for example be user-specified strings that are
+ *       considered boolean True or False).
+ *
+ * TODO: Aside from nailing down the above notes, it may be nice to expose
+ *       these function publicly.  This could allow user DTypes to provide
+ *       a converter or custom converters written in C rather than Python.
+ *
+ * @param descr The NumPy descriptor of the field (may be byte-swapped, etc.)
+ * @param str Pointer to the beginning of the UCS4 string to be parsed.
+ * @param end Pointer to the end of the UCS4 string.  This value is currently
+ *            guaranteed to be `\0`, ensuring that parsers can rely on
+ *            nul-termination.
+ * @param dataptr The pointer where to store the parsed value
+ * @param pconfig Additional configuration for the parser.
+ * @returns 0 on success and -1 on failure.  If the return value is -1 an
+ *          error may or may not be set.  If an error is set, it is chained
+ *          behind the generic ValueError.
+ */
+typedef int (set_from_ucs4_function)(
+        PyArray_Descr *descr, const Py_UCS4 *str, const Py_UCS4 *end,
+        char *dataptr, parser_config *pconfig);
+
+typedef struct _field_type {
+    set_from_ucs4_function *set_from_ucs4;
+    /* The original NumPy descriptor */
+    PyArray_Descr *descr;
+    /* Offset to this entry within row. */
+    npy_intp structured_offset;
+} field_type;
+
+
+NPY_NO_EXPORT void
+field_types_xclear(int num_field_types, field_type *ft);
+
+NPY_NO_EXPORT npy_intp
+field_types_create(PyArray_Descr *descr, field_type **ft);
+
+#endif  /* NUMPY_CORE_SRC_MULTIARRAY_TEXTREADING_FIELD_TYPES_H_ */
diff --git a/numpy/core/src/multiarray/textreading/growth.c b/numpy/core/src/multiarray/textreading/growth.c
new file mode 100644
index 000000000000..1686aad7208d
--- /dev/null
+++ b/numpy/core/src/multiarray/textreading/growth.c
@@ -0,0 +1,47 @@
+#define NPY_NO_DEPRECATED_API NPY_API_VERSION
+#define _MULTIARRAYMODULE
+#include "numpy/ndarraytypes.h"
+
+#include "templ_common.h"
+
+/*
+ * Helper function taking the size input and growing it (based on min_grow).
+ * The current scheme is a minimum growth and a general growth by 25%
+ * overallocation.  This is then capped at 2**20 elements, as that propels us
+ * in the range of large page sizes (so it is presumably more than enough).
+ *
+ * It further multiplies it with `itemsize` and ensures that all results fit
+ * into an `npy_intp`.
+ * Returns -1 if any overflow occurred or the result would not fit.
+ * The user has to ensure the input is ssize_t but not negative.
+ */
+NPY_NO_EXPORT npy_intp
+grow_size_and_multiply(npy_intp *size, npy_intp min_grow, npy_intp itemsize) {
+    /* min_grow must be a power of two: */
+    assert((min_grow & (min_grow - 1)) == 0);
+    npy_uintp new_size = (npy_uintp)*size;
+    npy_intp growth = *size >> 2;
+    if (growth <= min_grow) {
+        /* can never lead to overflow if we are using min_growth */
+        new_size += min_grow;
+    }
+    else {
+        if (growth > 1 << 20) {
+            /* limit growth to order of MiB (even hugepages are not larger) */
+            growth = 1 << 20;
+        }
+        new_size += growth + min_grow - 1;
+        new_size &= ~min_grow;
+
+        if (new_size > NPY_MAX_INTP) {
+            return -1;
+        }
+    }
+    *size = (npy_intp)new_size;
+    npy_intp alloc_size;
+    if (npy_mul_sizes_with_overflow(&alloc_size, (npy_intp)new_size, itemsize)) {
+        return -1;
+    }
+    return alloc_size;
+}
+
diff --git a/numpy/core/src/multiarray/textreading/growth.h b/numpy/core/src/multiarray/textreading/growth.h
new file mode 100644
index 000000000000..c7ebe365194a
--- /dev/null
+++ b/numpy/core/src/multiarray/textreading/growth.h
@@ -0,0 +1,15 @@
+#ifndef NUMPY_CORE_SRC_MULTIARRAY_TEXTREADING_GROWTH_H_
+#define NUMPY_CORE_SRC_MULTIARRAY_TEXTREADING_GROWTH_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+NPY_NO_EXPORT npy_intp
+grow_size_and_multiply(npy_intp *size, npy_intp min_grow, npy_intp itemsize);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  /* NUMPY_CORE_SRC_MULTIARRAY_TEXTREADING_GROWTH_H_ */
diff --git a/numpy/core/src/multiarray/textreading/parser_config.h b/numpy/core/src/multiarray/textreading/parser_config.h
new file mode 100644
index 000000000000..022ba952c796
--- /dev/null
+++ b/numpy/core/src/multiarray/textreading/parser_config.h
@@ -0,0 +1,74 @@
+
+#ifndef NUMPY_CORE_SRC_MULTIARRAY_TEXTREADING_PARSER_CONFIG_H_
+#define NUMPY_CORE_SRC_MULTIARRAY_TEXTREADING_PARSER_CONFIG_H_
+
+#include 
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+    /*
+     *  Field delimiter character.
+     *  Typically ',', ' ', '\t', ignored if `delimiter_is_whitespace` is true.
+     */
+    Py_UCS4 delimiter;
+
+    /*
+     *  Character used to quote fields.
+     *  Typically '"' or "'".  To disable quoting we set this to UINT_MAX
+     *  (which is not a valid unicode character and thus cannot occur in the
+     *  file; the same is used for all other characters if necessary).
+     */
+    Py_UCS4 quote;
+
+    /*
+     *  Character(s) that indicates the start of a comment.
+     *  Typically '#', '%' or ';'.
+     *  When encountered in a line and not inside quotes, all character
+     *  from the comment character(s) to the end of the line are ignored.
+     */
+    Py_UCS4 comment;
+
+    /*
+     *  Ignore whitespace at the beginning of a field (outside/before quotes).
+     *  Is (and must be) set if `delimiter_is_whitespace`.
+     */
+    bool ignore_leading_whitespace;
+
+    /*
+     * If true, the delimiter is ignored and any unicode whitespace is used
+     * for splitting (same as `string.split()` in Python). In that case
+     * `ignore_leading_whitespace` should also be set.
+     */
+    bool delimiter_is_whitespace;
+
+    /*
+     *  The imaginary unit character. Default is `j`.
+     */
+    Py_UCS4 imaginary_unit;
+
+     /*
+      * Data should be encoded as `latin1` when using python converter
+      * (implementing `loadtxt` default Python 2 compatibility mode).
+      * The c byte converter is used when the user requested `dtype="S"`.
+      * In this case we go via `dtype=object`, however, loadtxt allows latin1
+      * while normal object to string casts only accept ASCII, so it ensures
+      * that that the object array already contains bytes and not strings.
+      */
+     bool python_byte_converters;
+     bool c_byte_converters;
+     /*
+      * Flag to store whether a warning was already given for an integer being
+      * parsed by first converting to a float.
+      */
+     bool gave_int_via_float_warning;
+} parser_config;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  /* NUMPY_CORE_SRC_MULTIARRAY_TEXTREADING_PARSER_CONFIG_H_ */
diff --git a/numpy/core/src/multiarray/textreading/readtext.c b/numpy/core/src/multiarray/textreading/readtext.c
new file mode 100644
index 000000000000..5646b3d3002b
--- /dev/null
+++ b/numpy/core/src/multiarray/textreading/readtext.c
@@ -0,0 +1,317 @@
+#include 
+#include 
+
+#define PY_SSIZE_T_CLEAN
+#include 
+
+#define NPY_NO_DEPRECATED_API NPY_API_VERSION
+#define _MULTIARRAYMODULE
+#include "numpy/arrayobject.h"
+#include "npy_argparse.h"
+#include "common.h"
+#include "conversion_utils.h"
+
+#include "textreading/parser_config.h"
+#include "textreading/stream_pyobject.h"
+#include "textreading/field_types.h"
+#include "textreading/rows.h"
+#include "textreading/str_to_int.h"
+
+
+//
+// `usecols` must point to a Python object that is Py_None or a 1-d contiguous
+// numpy array with data type int32.
+//
+// `dtype` must point to a Python object that is Py_None or a numpy dtype
+// instance.  If the latter, code and sizes must be arrays of length
+// num_dtype_fields, holding the flattened data field type codes and byte
+// sizes. (num_dtype_fields, codes, and sizes can be inferred from dtype,
+// but we do that in Python code.)
+//
+// If both `usecols` and `dtype` are not None, and the data type is compound,
+// then len(usecols) must equal num_dtype_fields.
+//
+// If `dtype` is given and it is compound, and `usecols` is None, then the
+// number of columns in the file must match the number of fields in `dtype`.
+//
+static PyObject *
+_readtext_from_stream(stream *s,
+        parser_config *pc, Py_ssize_t num_usecols, Py_ssize_t usecols[],
+        Py_ssize_t skiplines, Py_ssize_t max_rows,
+        PyObject *converters, PyObject *dtype)
+{
+    PyArrayObject *arr = NULL;
+    PyArray_Descr *out_dtype = NULL;
+    field_type *ft = NULL;
+
+    /*
+     * If dtypes[0] is dtype the input was not structured and the result
+     * is considered "homogeneous" and we have to discover the number of
+     * columns/
+     */
+    out_dtype = (PyArray_Descr *)dtype;
+    Py_INCREF(out_dtype);
+
+    Py_ssize_t num_fields = field_types_create(out_dtype, &ft);
+    if (num_fields < 0) {
+        goto finish;
+    }
+    bool homogeneous = num_fields == 1 && ft[0].descr == out_dtype;
+
+    if (!homogeneous && usecols != NULL && num_usecols != num_fields) {
+        PyErr_Format(PyExc_TypeError,
+                "If a structured dtype is used, the number of columns in "
+                "`usecols` must match the effective number of fields. "
+                "But %zd usecols were given and the number of fields is %zd.",
+                num_usecols, num_fields);
+        goto finish;
+    }
+
+    arr = read_rows(
+            s, max_rows, num_fields, ft, pc,
+            num_usecols, usecols, skiplines, converters,
+            NULL, out_dtype, homogeneous);
+    if (arr == NULL) {
+        goto finish;
+    }
+
+  finish:
+    Py_XDECREF(out_dtype);
+    field_types_xclear(num_fields, ft);
+    return (PyObject *)arr;
+}
+
+
+static int
+parse_control_character(PyObject *obj, Py_UCS4 *character)
+{
+    if (obj == Py_None) {
+        *character = (Py_UCS4)-1;  /* character beyond unicode range */
+        return 1;
+    }
+    if (!PyUnicode_Check(obj) || PyUnicode_GetLength(obj) != 1) {
+        PyErr_Format(PyExc_TypeError,
+                "Text reading control character must be a single unicode "
+                "character or None; but got: %.100R", obj);
+        return 0;
+    }
+    *character = PyUnicode_READ_CHAR(obj, 0);
+    return 1;
+}
+
+
+/*
+ * A (somewhat verbose) check that none of the control characters match or are
+ * newline.  Most of these combinations are completely fine, just weird or
+ * surprising.
+ * (I.e. there is an implicit priority for control characters, so if a comment
+ * matches a delimiter, it would just be a comment.)
+ * In theory some `delimiter=None` paths could have a "meaning", but let us
+ * assume that users are better of setting one of the control chars to `None`
+ * for clarity.
+ *
+ * This also checks that the control characters cannot be newlines.
+ */
+static int
+error_if_matching_control_characters(
+        Py_UCS4 delimiter, Py_UCS4 quote, Py_UCS4 comment)
+{
+    char *control_char1;
+    char *control_char2 = NULL;
+    if (comment != (Py_UCS4)-1) {
+        control_char1 = "comment";
+        if (comment == '\r' || comment == '\n') {
+            goto error;
+        }
+        else if (comment == quote) {
+            control_char2 = "quotechar";
+            goto error;
+        }
+        else if (comment == delimiter) {
+            control_char2 = "delimiter";
+            goto error;
+        }
+    }
+    if (quote != (Py_UCS4)-1) {
+        control_char1 = "quotechar";
+        if (quote == '\r' || quote == '\n') {
+            goto error;
+        }
+        else if (quote == delimiter) {
+            control_char2 = "delimiter";
+            goto error;
+        }
+    }
+    if (delimiter != (Py_UCS4)-1) {
+        control_char1 = "delimiter";
+        if (delimiter == '\r' || delimiter == '\n') {
+            goto error;
+        }
+    }
+    /* The above doesn't work with delimiter=None, which means "whitespace" */
+    if (delimiter == (Py_UCS4)-1) {
+        control_char1 = "delimiter";
+        if (Py_UNICODE_ISSPACE(comment)) {
+            control_char2 = "comment";
+            goto error;
+        }
+        else if (Py_UNICODE_ISSPACE(quote)) {
+            control_char2 = "quotechar";
+            goto error;
+        }
+    }
+    return 0;
+
+  error:
+    if (control_char2 != NULL) {
+        PyErr_Format(PyExc_TypeError,
+                "The values for control characters '%s' and '%s' are "
+                "incompatible",
+                control_char1, control_char2);
+    }
+    else {
+        PyErr_Format(PyExc_TypeError,
+                "control character '%s' cannot be a newline (`\\r` or `\\n`).",
+                control_char1, control_char2);
+    }
+    return -1;
+}
+
+
+NPY_NO_EXPORT PyObject *
+_load_from_filelike(PyObject *NPY_UNUSED(mod),
+        PyObject *const *args, Py_ssize_t len_args, PyObject *kwnames)
+{
+    PyObject *file;
+    Py_ssize_t skiplines = 0;
+    Py_ssize_t max_rows = -1;
+    PyObject *usecols_obj = Py_None;
+    PyObject *converters = Py_None;
+
+    PyObject *dtype = Py_None;
+    PyObject *encoding_obj = Py_None;
+    const char *encoding = NULL;
+
+    parser_config pc = {
+        .delimiter = ',',
+        .quote = '"',
+        .comment = '#',
+        .ignore_leading_whitespace = false,
+        .delimiter_is_whitespace = false,
+        .imaginary_unit = 'j',
+        .python_byte_converters = false,
+        .c_byte_converters = false,
+        .gave_int_via_float_warning = false,
+    };
+    bool filelike = true;
+
+    PyObject *arr = NULL;
+
+    NPY_PREPARE_ARGPARSER;
+    if (npy_parse_arguments("_load_from_filelike", args, len_args, kwnames,
+            "file", NULL, &file,
+            "|delimiter", &parse_control_character, &pc.delimiter,
+            "|comment", &parse_control_character, &pc.comment,
+            "|quote", &parse_control_character, &pc.quote,
+            "|imaginary_unit", &parse_control_character, &pc.imaginary_unit,
+            "|usecols", NULL, &usecols_obj,
+            "|skiplines", &PyArray_IntpFromPyIntConverter, &skiplines,
+            "|max_rows", &PyArray_IntpFromPyIntConverter, &max_rows,
+            "|converters", NULL, &converters,
+            "|dtype", NULL, &dtype,
+            "|encoding", NULL, &encoding_obj,
+            "|filelike", &PyArray_BoolConverter, &filelike,
+            "|byte_converters", &PyArray_BoolConverter, &pc.python_byte_converters,
+            "|c_byte_converters", PyArray_BoolConverter, &pc.c_byte_converters,
+            NULL, NULL, NULL) < 0) {
+        return NULL;
+    }
+
+    /* Reject matching control characters, they just rarely make sense anyway */
+    if (error_if_matching_control_characters(
+            pc.delimiter, pc.quote, pc.comment) < 0) {
+        return NULL;
+    }
+
+    if (pc.delimiter == (Py_UCS4)-1) {
+        pc.delimiter_is_whitespace = true;
+        /* Ignore leading whitespace to match `string.split(None)` */
+        pc.ignore_leading_whitespace = true;
+    }
+
+    if (!PyArray_DescrCheck(dtype) ) {
+        PyErr_SetString(PyExc_TypeError,
+                "internal error: dtype must be provided and be a NumPy dtype");
+        return NULL;
+    }
+
+    if (encoding_obj != Py_None) {
+        if (!PyUnicode_Check(encoding_obj)) {
+            PyErr_SetString(PyExc_TypeError,
+                    "encoding must be a unicode string.");
+            return NULL;
+        }
+        encoding = PyUnicode_AsUTF8(encoding_obj);
+        if (encoding == NULL) {
+            return NULL;
+        }
+    }
+
+    /*
+     * Parse usecols, the rest of NumPy has no clear helper for this, so do
+     * it here manually.
+     */
+    Py_ssize_t num_usecols = -1;
+    Py_ssize_t *usecols = NULL;
+    if (usecols_obj != Py_None) {
+        num_usecols = PySequence_Length(usecols_obj);
+        if (num_usecols < 0) {
+            return NULL;
+        }
+        /* Calloc just to not worry about overflow */
+        usecols = PyMem_Calloc(num_usecols, sizeof(Py_ssize_t));
+        if (usecols == NULL) {
+            PyErr_NoMemory();
+            return NULL;
+        }
+        for (Py_ssize_t i = 0; i < num_usecols; i++) {
+            PyObject *tmp = PySequence_GetItem(usecols_obj, i);
+            if (tmp == NULL) {
+                PyMem_FREE(usecols);
+                return NULL;
+            }
+            usecols[i] = PyNumber_AsSsize_t(tmp, PyExc_OverflowError);
+            if (error_converting(usecols[i])) {
+                if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+                    PyErr_Format(PyExc_TypeError,
+                            "usecols must be an int or a sequence of ints but "
+                            "it contains at least one element of type '%s'",
+                            Py_TYPE(tmp)->tp_name);
+                }
+                Py_DECREF(tmp);
+                PyMem_FREE(usecols);
+                return NULL;
+            }
+            Py_DECREF(tmp);
+        }
+    }
+
+    stream *s;
+    if (filelike) {
+        s = stream_python_file(file, encoding);
+    }
+    else {
+        s = stream_python_iterable(file, encoding);
+    }
+    if (s == NULL) {
+        PyMem_FREE(usecols);
+        return NULL;
+    }
+
+    arr = _readtext_from_stream(
+            s, &pc, num_usecols, usecols, skiplines, max_rows, converters, dtype);
+    stream_close(s);
+    PyMem_FREE(usecols);
+    return arr;
+}
+
diff --git a/numpy/core/src/multiarray/textreading/readtext.h b/numpy/core/src/multiarray/textreading/readtext.h
new file mode 100644
index 000000000000..133c7883e026
--- /dev/null
+++ b/numpy/core/src/multiarray/textreading/readtext.h
@@ -0,0 +1,8 @@
+#ifndef NUMPY_CORE_SRC_MULTIARRAY_TEXTREADING_READTEXT_H_
+#define NUMPY_CORE_SRC_MULTIARRAY_TEXTREADING_READTEXT_H_
+
+NPY_NO_EXPORT PyObject *
+_load_from_filelike(PyObject *mod,
+        PyObject *const *args, Py_ssize_t len_args, PyObject *kwnames);
+
+#endif  /* NUMPY_CORE_SRC_MULTIARRAY_TEXTREADING_READTEXT_H_ */
diff --git a/numpy/core/src/multiarray/textreading/rows.c b/numpy/core/src/multiarray/textreading/rows.c
new file mode 100644
index 000000000000..9c490b3f710f
--- /dev/null
+++ b/numpy/core/src/multiarray/textreading/rows.c
@@ -0,0 +1,491 @@
+
+#define PY_SSIZE_T_CLEAN
+#include 
+
+#define NPY_NO_DEPRECATED_API NPY_API_VERSION
+#define _MULTIARRAYMODULE
+#include "numpy/arrayobject.h"
+#include "numpy/npy_3kcompat.h"
+#include "alloc.h"
+
+#include 
+#include 
+
+#include "textreading/stream.h"
+#include "textreading/tokenize.h"
+#include "textreading/conversions.h"
+#include "textreading/field_types.h"
+#include "textreading/rows.h"
+#include "textreading/growth.h"
+
+/*
+ * Minimum size to grow the allocation by (or 25%). The 8KiB means the actual
+ * growths is within `8 KiB <= size < 16 KiB` (depending on the row size).
+ */
+#define MIN_BLOCK_SIZE (1 << 13)
+
+
+
+/*
+ *  Create the array of converter functions from the Python converters.
+ */
+static PyObject **
+create_conv_funcs(
+        PyObject *converters, Py_ssize_t num_fields, const Py_ssize_t *usecols)
+{
+    assert(converters != Py_None);
+
+    PyObject **conv_funcs = PyMem_Calloc(num_fields, sizeof(PyObject *));
+    if (conv_funcs == NULL) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+
+    if (PyCallable_Check(converters)) {
+        /* a single converter used for all columns individually */
+        for (Py_ssize_t i = 0; i < num_fields; i++) {
+            Py_INCREF(converters);
+            conv_funcs[i] = converters;
+        }
+        return conv_funcs;
+    }
+    else if (!PyDict_Check(converters)) {
+        PyErr_SetString(PyExc_TypeError,
+                "converters must be a dictionary mapping columns to converter "
+                "functions or a single callable.");
+        goto error;
+    }
+
+    PyObject *key, *value;
+    Py_ssize_t pos = 0;
+    while (PyDict_Next(converters, &pos, &key, &value)) {
+        Py_ssize_t column = PyNumber_AsSsize_t(key, PyExc_IndexError);
+        if (column == -1 && PyErr_Occurred()) {
+            PyErr_Format(PyExc_TypeError,
+                    "keys of the converters dictionary must be integers; "
+                    "got %.100R", key);
+            goto error;
+        }
+        if (usecols != NULL) {
+            /*
+             * This code searches for the corresponding usecol.  It is
+             * identical to the legacy usecols code, which has two weaknesses:
+             * 1. It fails for duplicated usecols only setting converter for
+             *    the first one.
+             * 2. It fails e.g. if usecols uses negative indexing and
+             *    converters does not.  (This is a feature, since it allows
+             *    us to correctly normalize converters to result column here.)
+             */
+            Py_ssize_t i = 0;
+            for (; i < num_fields; i++) {
+                if (column == usecols[i]) {
+                    column = i;
+                    break;
+                }
+            }
+            if (i == num_fields) {
+                continue;  /* ignore unused converter */
+            }
+        }
+        else {
+            if (column < -num_fields || column >= num_fields) {
+                PyErr_Format(PyExc_ValueError,
+                        "converter specified for column %zd, which is invalid "
+                        "for the number of fields %zd.", column, num_fields);
+                goto error;
+            }
+            if (column < 0) {
+                column += num_fields;
+            }
+        }
+        if (!PyCallable_Check(value)) {
+            PyErr_Format(PyExc_TypeError,
+                    "values of the converters dictionary must be callable, "
+                    "but the value associated with key %R is not", key);
+            goto error;
+        }
+        Py_INCREF(value);
+        conv_funcs[column] = value;
+    }
+    return conv_funcs;
+
+  error:
+    for (Py_ssize_t i = 0; i < num_fields; i++) {
+        Py_XDECREF(conv_funcs[i]);
+    }
+    PyMem_FREE(conv_funcs);
+    return NULL;
+}
+
+/**
+ * Read a file into the provided array, or create (and possibly grow) an
+ * array to read into.
+ *
+ * @param s The stream object/struct providing reading capabilities used by
+ *        the tokenizer.
+ * @param max_rows The number of rows to read, or -1.  If negative
+ *        all rows are read.
+ * @param num_field_types The number of field types stored in `field_types`.
+ * @param field_types Information about the dtype for each column (or one if
+ *        `homogeneous`).
+ * @param pconfig Pointer to the parser config object used by both the
+ *        tokenizer and the conversion functions.
+ * @param num_usecols The number of columns in `usecols`.
+ * @param usecols An array of length `num_usecols` or NULL.  If given indicates
+ *        which column is read for each individual row (negative columns are
+ *        accepted).
+ * @param skiplines The number of lines to skip, these lines are ignored.
+ * @param converters Python dictionary of converters.  Finalizing converters
+ *        is difficult without information about the number of columns.
+ * @param data_array An array to be filled or NULL.  In either case a new
+ *        reference is returned (the reference to `data_array` is not stolen).
+ * @param out_descr The dtype used for allocating a new array.  This is not
+ *        used if `data_array` is provided.  Note that the actual dtype of the
+ *        returned array can differ for strings.
+ * @param num_cols Pointer in which the actual (discovered) number of columns
+ *        is returned.  This is only relevant if `homogeneous` is true.
+ * @param homogeneous Whether the datatype of the array is not homogeneous,
+ *        i.e. not structured.  In this case the number of columns has to be
+ *        discovered an the returned array will be 2-dimensional rather than
+ *        1-dimensional.
+ *
+ * @returns Returns the result as an array object or NULL on error.  The result
+ *          is always a new reference (even when `data_array` was passed in).
+ */
+NPY_NO_EXPORT PyArrayObject *
+read_rows(stream *s,
+        npy_intp max_rows, Py_ssize_t num_field_types, field_type *field_types,
+        parser_config *pconfig, Py_ssize_t num_usecols, Py_ssize_t *usecols,
+        Py_ssize_t skiplines, PyObject *converters,
+        PyArrayObject *data_array, PyArray_Descr *out_descr,
+        bool homogeneous)
+{
+    char *data_ptr = NULL;
+    Py_ssize_t current_num_fields;
+    npy_intp row_size = out_descr->elsize;
+    PyObject **conv_funcs = NULL;
+
+    bool needs_init = PyDataType_FLAGCHK(out_descr, NPY_NEEDS_INIT);
+
+    int ndim = homogeneous ? 2 : 1;
+    npy_intp result_shape[2] = {0, 1};
+
+    bool data_array_allocated = data_array == NULL;
+    /* Make sure we own `data_array` for the purpose of error handling */
+    Py_XINCREF(data_array);
+    size_t rows_per_block = 1;  /* will be increased depending on row size */
+    npy_intp data_allocated_rows = 0;
+
+    /* We give a warning if max_rows is used and an empty line is encountered */
+    bool give_empty_row_warning = max_rows >= 0;
+
+    int ts_result = 0;
+    tokenizer_state ts;
+    if (npy_tokenizer_init(&ts, pconfig) < 0) {
+        goto error;
+    }
+
+    /* Set the actual number of fields if it is already known, otherwise -1 */
+    Py_ssize_t actual_num_fields = -1;
+    if (usecols != NULL) {
+        assert(homogeneous || num_field_types == num_usecols);
+        actual_num_fields = num_usecols;
+    }
+    else if (!homogeneous) {
+        assert(usecols == NULL || num_field_types == num_usecols);
+        actual_num_fields = num_field_types;
+    }
+
+    for (Py_ssize_t i = 0; i < skiplines; i++) {
+        ts.state = TOKENIZE_GOTO_LINE_END;
+        ts_result = npy_tokenize(s, &ts, pconfig);
+        if (ts_result < 0) {
+            goto error;
+        }
+        else if (ts_result != 0) {
+            /* Fewer lines than skiplines is acceptable */
+            break;
+        }
+    }
+
+    Py_ssize_t row_count = 0;  /* number of rows actually processed */
+    while ((max_rows < 0 || row_count < max_rows) && ts_result == 0) {
+        ts_result = npy_tokenize(s, &ts, pconfig);
+        if (ts_result < 0) {
+            goto error;
+        }
+        current_num_fields = ts.num_fields;
+        field_info *fields = ts.fields;
+        if (NPY_UNLIKELY(ts.num_fields == 0)) {
+            /*
+             * Deprecated NumPy 1.23, 2021-01-13 (not really a deprecation,
+             * but similar policy should apply to removing the warning again)
+             */
+             /* Tokenizer may give a final "empty line" even if there is none */
+            if (give_empty_row_warning && ts_result == 0) {
+                give_empty_row_warning = false;
+                if (PyErr_WarnFormat(PyExc_UserWarning, 3,
+                        "Input line %zd contained no data and will not be "
+                        "counted towards `max_rows=%zd`.  This differs from "
+                        "the behaviour in NumPy <=1.22 which counted lines "
+                        "rather than rows.  If desired, the previous behaviour "
+                        "can be achieved by using `itertools.islice`.\n"
+                        "Please see the 1.23 release notes for an example on "
+                        "how to do this.  If you wish to ignore this warning, "
+                        "use `warnings.filterwarnings`.  This warning is "
+                        "expected to be removed in the future and is given "
+                        "only once per `loadtxt` call.",
+                        row_count + skiplines + 1, max_rows) < 0) {
+                    goto error;
+                }
+            }
+            continue;  /* Ignore empty line */
+        }
+
+        if (NPY_UNLIKELY(data_ptr == NULL)) {
+            // We've deferred some of the initialization tasks to here,
+            // because we've now read the first line, and we definitively
+            // know how many fields (i.e. columns) we will be processing.
+            if (actual_num_fields == -1) {
+                actual_num_fields = current_num_fields;
+            }
+
+            if (converters != Py_None) {
+                conv_funcs = create_conv_funcs(
+                        converters, actual_num_fields, usecols);
+                if (conv_funcs == NULL) {
+                    goto error;
+                }
+            }
+
+            /* Note that result_shape[1] is only used if homogeneous is true */
+            result_shape[1] = actual_num_fields;
+            if (homogeneous) {
+                row_size *= actual_num_fields;
+            }
+
+            if (data_array == NULL) {
+                if (max_rows < 0) {
+                    /*
+                     * Negative max_rows denotes to read the whole file, we
+                     * approach this by allocating ever larger blocks.
+                     * Adds a number of rows based on `MIN_BLOCK_SIZE`.
+                     * Note: later code grows assuming this is a power of two.
+                     */
+                    if (row_size == 0) {
+                        /* actual rows_per_block should not matter here */
+                        rows_per_block = 512;
+                    }
+                    else {
+                        /* safe on overflow since min_rows will be 0 or 1 */
+                        size_t min_rows = (
+                                (MIN_BLOCK_SIZE + row_size - 1) / row_size);
+                        while (rows_per_block < min_rows) {
+                            rows_per_block *= 2;
+                        }
+                    }
+                    data_allocated_rows = rows_per_block;
+                }
+                else {
+                    data_allocated_rows = max_rows;
+                }
+                result_shape[0] = data_allocated_rows;
+                Py_INCREF(out_descr);
+                /*
+                 * We do not use Empty, as it would fill with None
+                 * and requiring decref'ing if we shrink again.
+                 */
+                data_array = (PyArrayObject *)PyArray_SimpleNewFromDescr(
+                        ndim, result_shape, out_descr);
+#ifdef NPY_RELAXED_STRIDES_DEBUG
+                /* Incompatible with NPY_RELAXED_STRIDES_DEBUG due to growing */
+                if (result_shape[0] == 1) {
+                    PyArray_STRIDES(data_array)[0] = row_size;
+                }
+#endif /* NPY_RELAXED_STRIDES_DEBUG */
+                if (data_array == NULL) {
+                    goto error;
+                }
+                if (needs_init) {
+                    memset(PyArray_BYTES(data_array), 0, PyArray_NBYTES(data_array));
+                }
+            }
+            else {
+                assert(max_rows >=0);
+                data_allocated_rows = max_rows;
+            }
+            data_ptr = PyArray_BYTES(data_array);
+        }
+
+        if (!usecols && (actual_num_fields != current_num_fields)) {
+            PyErr_Format(PyExc_ValueError,
+                    "the number of columns changed from %zd to %zd at row %zd; "
+                    "use `usecols` to select a subset and avoid this error",
+                    actual_num_fields, current_num_fields, row_count+1);
+            goto error;
+        }
+
+        if (NPY_UNLIKELY(data_allocated_rows == row_count)) {
+            /*
+             * Grow by ~25% and rounded up to the next rows_per_block
+             * NOTE: This is based on very crude timings and could be refined!
+             */
+            npy_intp new_rows = data_allocated_rows;
+            npy_intp alloc_size = grow_size_and_multiply(
+                    &new_rows, rows_per_block, row_size);
+            if (alloc_size < 0) {
+                /* should normally error much earlier, but make sure */
+                PyErr_SetString(PyExc_ValueError,
+                        "array is too big. Cannot read file as a single array; "
+                        "providing a maximum number of rows to read may help.");
+                goto error;
+            }
+
+            char *new_data = PyDataMem_UserRENEW(
+                    PyArray_BYTES(data_array), alloc_size ? alloc_size : 1,
+                    PyArray_HANDLER(data_array));
+            if (new_data == NULL) {
+                PyErr_NoMemory();
+                goto error;
+            }
+            /* Replace the arrays data since it may have changed */
+            ((PyArrayObject_fields *)data_array)->data = new_data;
+            ((PyArrayObject_fields *)data_array)->dimensions[0] = new_rows;
+            data_ptr = new_data + row_count * row_size;
+            data_allocated_rows = new_rows;
+            if (needs_init) {
+                memset(data_ptr, '\0', (new_rows - row_count) * row_size);
+            }
+        }
+
+        for (Py_ssize_t i = 0; i < actual_num_fields; ++i) {
+            Py_ssize_t f;  /* The field, either 0 (if homogeneous) or i. */
+            Py_ssize_t col;  /* The column as read, remapped by usecols */
+            char *item_ptr;
+            if (homogeneous) {
+                f = 0;
+                item_ptr = data_ptr + i * field_types[0].descr->elsize;
+            }
+            else {
+                f = i;
+                item_ptr = data_ptr + field_types[f].structured_offset;
+            }
+
+            if (usecols == NULL) {
+                col = i;
+            }
+            else {
+                col = usecols[i];
+                if (col < 0) {
+                    // Python-like column indexing: k = -1 means the last column.
+                    col += current_num_fields;
+                }
+                if (NPY_UNLIKELY((col < 0) || (col >= current_num_fields))) {
+                    PyErr_Format(PyExc_ValueError,
+                            "invalid column index %zd at row %zd with %zd "
+                            "columns",
+                            usecols[i], row_count+1, current_num_fields);
+                    goto error;
+                }
+            }
+
+            /*
+             * The following function calls represent the main "conversion"
+             * step, i.e. parsing the unicode string for each field and storing
+             * the result in the array.
+             */
+            int parser_res;
+            Py_UCS4 *str = ts.field_buffer + fields[col].offset;
+            Py_UCS4 *end = ts.field_buffer + fields[col + 1].offset - 1;
+            if (conv_funcs == NULL || conv_funcs[i] == NULL) {
+                parser_res = field_types[f].set_from_ucs4(field_types[f].descr,
+                        str, end, item_ptr, pconfig);
+            }
+            else {
+                parser_res = npy_to_generic_with_converter(field_types[f].descr,
+                        str, end, item_ptr, pconfig, conv_funcs[i]);
+            }
+
+            if (NPY_UNLIKELY(parser_res < 0)) {
+                PyObject *exc, *val, *tb;
+                PyErr_Fetch(&exc, &val, &tb);
+
+                size_t length = end - str;
+                PyObject *string = PyUnicode_FromKindAndData(
+                        PyUnicode_4BYTE_KIND, str, length);
+                if (string == NULL) {
+                    npy_PyErr_ChainExceptions(exc, val, tb);
+                    goto error;
+                }
+                PyErr_Format(PyExc_ValueError,
+                        "could not convert string %.100R to %S at "
+                        "row %zd, column %zd.",
+                        string, field_types[f].descr, row_count, col+1);
+                Py_DECREF(string);
+                npy_PyErr_ChainExceptionsCause(exc, val, tb);
+                goto error;
+            }
+        }
+
+        ++row_count;
+        data_ptr += row_size;
+    }
+
+    npy_tokenizer_clear(&ts);
+    if (conv_funcs != NULL) {
+        for (Py_ssize_t i = 0; i < actual_num_fields; i++) {
+            Py_XDECREF(conv_funcs[i]);
+        }
+        PyMem_FREE(conv_funcs);
+    }
+
+    if (data_array == NULL) {
+        assert(row_count == 0 && result_shape[0] == 0);
+        if (actual_num_fields == -1) {
+            /*
+             * We found no rows and have to discover the number of elements
+             * we have no choice but to guess 1.
+             * NOTE: It may make sense to move this outside of here to refine
+             *       the behaviour where necessary.
+             */
+            result_shape[1] = 1;
+        }
+        else {
+            result_shape[1] = actual_num_fields;
+        }
+        Py_INCREF(out_descr);
+        data_array = (PyArrayObject *)PyArray_Empty(
+                ndim, result_shape, out_descr, 0);
+    }
+
+    /*
+     * Note that if there is no data, `data_array` may still be NULL and
+     * row_count is 0.  In that case, always realloc just in case.
+     */
+    if (data_array_allocated && data_allocated_rows != row_count) {
+        size_t size = row_count * row_size;
+        char *new_data = PyDataMem_UserRENEW(
+                PyArray_BYTES(data_array), size ? size : 1,
+                PyArray_HANDLER(data_array));
+        if (new_data == NULL) {
+            Py_DECREF(data_array);
+            PyErr_NoMemory();
+            return NULL;
+        }
+        ((PyArrayObject_fields *)data_array)->data = new_data;
+        ((PyArrayObject_fields *)data_array)->dimensions[0] = row_count;
+    }
+
+    return data_array;
+
+  error:
+    if (conv_funcs != NULL) {
+        for (Py_ssize_t i = 0; i < actual_num_fields; i++) {
+            Py_XDECREF(conv_funcs[i]);
+        }
+        PyMem_FREE(conv_funcs);
+    }
+    npy_tokenizer_clear(&ts);
+    Py_XDECREF(data_array);
+    return NULL;
+}
diff --git a/numpy/core/src/multiarray/textreading/rows.h b/numpy/core/src/multiarray/textreading/rows.h
new file mode 100644
index 000000000000..20eb9e186a19
--- /dev/null
+++ b/numpy/core/src/multiarray/textreading/rows.h
@@ -0,0 +1,22 @@
+
+#ifndef NUMPY_CORE_SRC_MULTIARRAY_TEXTREADING_ROWS_H_
+#define NUMPY_CORE_SRC_MULTIARRAY_TEXTREADING_ROWS_H_
+
+#define PY_SSIZE_T_CLEAN
+#include 
+#include 
+
+#include "textreading/stream.h"
+#include "textreading/field_types.h"
+#include "textreading/parser_config.h"
+
+
+NPY_NO_EXPORT PyArrayObject *
+read_rows(stream *s,
+        npy_intp nrows, Py_ssize_t num_field_types, field_type *field_types,
+        parser_config *pconfig, Py_ssize_t num_usecols, Py_ssize_t *usecols,
+        Py_ssize_t skiplines, PyObject *converters,
+        PyArrayObject *data_array, PyArray_Descr *out_descr,
+        bool homogeneous);
+
+#endif  /* NUMPY_CORE_SRC_MULTIARRAY_TEXTREADING_ROWS_H_ */
diff --git a/numpy/core/src/multiarray/textreading/str_to_int.c b/numpy/core/src/multiarray/textreading/str_to_int.c
new file mode 100644
index 000000000000..40b7c67a981c
--- /dev/null
+++ b/numpy/core/src/multiarray/textreading/str_to_int.c
@@ -0,0 +1,110 @@
+
+#include 
+
+#define NPY_NO_DEPRECATED_API NPY_API_VERSION
+#define _MULTIARRAYMODULE
+#include "lowlevel_strided_loops.h"
+
+#include 
+#include "textreading/str_to_int.h"
+#include "textreading/parser_config.h"
+#include "conversions.h"  /* For the deprecated parse-via-float path */
+
+
+const char *deprecation_msg = (
+        "loadtxt(): Parsing an integer via a float is deprecated.  To avoid "
+        "this warning, you can:\n"
+        "    * make sure the original data is stored as integers.\n"
+        "    * use the `converters=` keyword argument.  If you only use\n"
+        "      NumPy 1.23 or later, `converters=float` will normally work.\n"
+        "    * Use `np.loadtxt(...).astype(np.int64)` parsing the file as\n"
+        "      floating point and then convert it.  (On all NumPy versions.)\n"
+        "  (Deprecated NumPy 1.23)");
+
+#define DECLARE_TO_INT(intw, INT_MIN, INT_MAX, byteswap_unaligned)          \
+    NPY_NO_EXPORT int                                                       \
+    npy_to_##intw(PyArray_Descr *descr,                                     \
+            const Py_UCS4 *str, const Py_UCS4 *end, char *dataptr,          \
+            parser_config *pconfig)                                         \
+    {                                                                       \
+        int64_t parsed;                                                     \
+        intw##_t x;                                                         \
+                                                                            \
+        if (NPY_UNLIKELY(                                                   \
+                str_to_int64(str, end, INT_MIN, INT_MAX, &parsed) < 0)) {   \
+            /* DEPRECATED 2022-07-03, NumPy 1.23 */                         \
+            double fval;                                                    \
+            PyArray_Descr *d_descr = PyArray_DescrFromType(NPY_DOUBLE);     \
+            Py_DECREF(d_descr);  /* borrowed */                             \
+            if (npy_to_double(d_descr, str, end, (char *)&fval, pconfig) < 0) { \
+                return -1;                                                  \
+            }                                                               \
+            if (!pconfig->gave_int_via_float_warning) {                     \
+                pconfig->gave_int_via_float_warning = true;                 \
+                if (PyErr_WarnEx(PyExc_DeprecationWarning,                  \
+                        deprecation_msg, 3) < 0) {                          \
+                    return -1;                                              \
+                }                                                           \
+            }                                                               \
+            pconfig->gave_int_via_float_warning = true;                     \
+            x = (intw##_t)fval;                                             \
+        }                                                                   \
+        else {                                                              \
+            x = (intw##_t)parsed;                                           \
+        }                                                                   \
+        memcpy(dataptr, &x, sizeof(x));                                     \
+        if (!PyArray_ISNBO(descr->byteorder)) {                             \
+            byteswap_unaligned(dataptr);                                    \
+        }                                                                   \
+        return 0;                                                           \
+    }
+
+#define DECLARE_TO_UINT(uintw, UINT_MAX, byteswap_unaligned)                \
+    NPY_NO_EXPORT int                                                       \
+    npy_to_##uintw(PyArray_Descr *descr,                                    \
+            const Py_UCS4 *str, const Py_UCS4 *end, char *dataptr,          \
+            parser_config *pconfig)                                         \
+    {                                                                       \
+        uint64_t parsed;                                                    \
+        uintw##_t x;                                                        \
+                                                                            \
+        if (NPY_UNLIKELY(                                                   \
+                str_to_uint64(str, end, UINT_MAX, &parsed) < 0)) {          \
+            /* DEPRECATED 2022-07-03, NumPy 1.23 */                         \
+            double fval;                                                    \
+            PyArray_Descr *d_descr = PyArray_DescrFromType(NPY_DOUBLE);     \
+            Py_DECREF(d_descr);  /* borrowed */                             \
+            if (npy_to_double(d_descr, str, end, (char *)&fval, pconfig) < 0) { \
+                return -1;                                                  \
+            }                                                               \
+            if (!pconfig->gave_int_via_float_warning) {                     \
+                pconfig->gave_int_via_float_warning = true;                 \
+                if (PyErr_WarnEx(PyExc_DeprecationWarning,                  \
+                        deprecation_msg, 3) < 0) {                          \
+                    return -1;                                              \
+                }                                                           \
+            }                                                               \
+            pconfig->gave_int_via_float_warning = true;                     \
+            x = (uintw##_t)fval;                                            \
+        }                                                                   \
+        else {                                                              \
+            x = (uintw##_t)parsed;                                          \
+        }                                                                   \
+        memcpy(dataptr, &x, sizeof(x));                                     \
+        if (!PyArray_ISNBO(descr->byteorder)) {                             \
+            byteswap_unaligned(dataptr);                                    \
+        }                                                                   \
+        return 0;                                                           \
+    }
+
+#define byteswap_nothing(ptr)
+
+DECLARE_TO_INT(int8, INT8_MIN, INT8_MAX, byteswap_nothing)
+DECLARE_TO_INT(int16, INT16_MIN, INT16_MAX, npy_bswap2_unaligned)
+DECLARE_TO_INT(int32, INT32_MIN, INT32_MAX, npy_bswap4_unaligned)
+DECLARE_TO_INT(int64, INT64_MIN, INT64_MAX, npy_bswap8_unaligned)
+
+DECLARE_TO_UINT(uint8, UINT8_MAX, byteswap_nothing)
+DECLARE_TO_UINT(uint16, UINT16_MAX, npy_bswap2_unaligned)
+DECLARE_TO_UINT(uint32, UINT32_MAX, npy_bswap4_unaligned)
+DECLARE_TO_UINT(uint64, UINT64_MAX, npy_bswap8_unaligned)
diff --git a/numpy/core/src/multiarray/textreading/str_to_int.h b/numpy/core/src/multiarray/textreading/str_to_int.h
new file mode 100644
index 000000000000..46b8f6679385
--- /dev/null
+++ b/numpy/core/src/multiarray/textreading/str_to_int.h
@@ -0,0 +1,174 @@
+#ifndef NUMPY_CORE_SRC_MULTIARRAY_TEXTREADING_STR_TO_INT_H_
+#define NUMPY_CORE_SRC_MULTIARRAY_TEXTREADING_STR_TO_INT_H_
+
+#define NPY_NO_DEPRECATED_API NPY_API_VERSION
+#define _MULTIARRAYMODULE
+#include "numpy/ndarraytypes.h"
+
+#include "textreading/parser_config.h"
+
+
+/*
+ * The following two string conversion functions are largely equivalent
+ * in Pandas.  They are in the header file here, to ensure they can be easily
+ * inline in the other function.
+ * Unlike pandas, pass in end-pointer (do not rely on \0) and return 0 or -1.
+ *
+ * The actual functions are defined using macro templating below.
+ */
+NPY_FINLINE int
+str_to_int64(
+        const Py_UCS4 *p_item, const Py_UCS4 *p_end,
+        int64_t int_min, int64_t int_max, int64_t *result)
+{
+    const Py_UCS4 *p = (const Py_UCS4 *)p_item;
+    bool isneg = 0;
+    int64_t number = 0;
+
+    // Skip leading spaces.
+    while (Py_UNICODE_ISSPACE(*p)) {
+        ++p;
+    }
+
+    // Handle sign.
+    if (*p == '-') {
+        isneg = true;
+        ++p;
+    }
+    else if (*p == '+') {
+        p++;
+    }
+
+    // Check that there is a first digit.
+    if (!isdigit(*p)) {
+        return -1;
+    }
+
+    if (isneg) {
+        // If number is greater than pre_min, at least one more digit
+        // can be processed without overflowing.
+        int dig_pre_min = -(int_min % 10);
+        int64_t pre_min = int_min / 10;
+
+        // Process the digits.
+        int d = *p;
+        while (isdigit(d)) {
+            if ((number > pre_min) || ((number == pre_min) && (d - '0' <= dig_pre_min))) {
+                number = number * 10 - (d - '0');
+                d = *++p;
+            }
+            else {
+                return -1;
+            }
+        }
+    }
+    else {
+        // If number is less than pre_max, at least one more digit
+        // can be processed without overflowing.
+        int64_t pre_max = int_max / 10;
+        int dig_pre_max = int_max % 10;
+
+        // Process the digits.
+        int d = *p;
+        while (isdigit(d)) {
+            if ((number < pre_max) || ((number == pre_max) && (d - '0' <= dig_pre_max))) {
+                number = number * 10 + (d - '0');
+                d = *++p;
+            }
+            else {
+                return -1;
+            }
+        }
+    }
+
+    // Skip trailing spaces.
+    while (Py_UNICODE_ISSPACE(*p)) {
+        ++p;
+    }
+
+    // Did we use up all the characters?
+    if (p != p_end) {
+        return -1;
+    }
+
+    *result = number;
+    return 0;
+}
+
+
+NPY_FINLINE int
+str_to_uint64(
+        const Py_UCS4 *p_item, const Py_UCS4 *p_end,
+        uint64_t uint_max, uint64_t *result)
+{
+    const Py_UCS4 *p = (const Py_UCS4 *)p_item;
+    uint64_t number = 0;
+    int d;
+
+    // Skip leading spaces.
+    while (Py_UNICODE_ISSPACE(*p)) {
+        ++p;
+    }
+
+    // Handle sign.
+    if (*p == '-') {
+        return -1;
+    }
+    if (*p == '+') {
+        p++;
+    }
+
+    // Check that there is a first digit.
+    if (!isdigit(*p)) {
+        return -1;
+    }
+
+    // If number is less than pre_max, at least one more digit
+    // can be processed without overflowing.
+    uint64_t pre_max = uint_max / 10;
+    int dig_pre_max = uint_max % 10;
+
+    // Process the digits.
+    d = *p;
+    while (isdigit(d)) {
+        if ((number < pre_max) || ((number == pre_max) && (d - '0' <= dig_pre_max))) {
+            number = number * 10 + (d - '0');
+            d = *++p;
+        }
+        else {
+            return -1;
+        }
+    }
+
+    // Skip trailing spaces.
+    while (Py_UNICODE_ISSPACE(*p)) {
+        ++p;
+    }
+
+    // Did we use up all the characters?
+    if (p != p_end) {
+        return -1;
+    }
+
+    *result = number;
+    return 0;
+}
+
+
+#define DECLARE_TO_INT_PROTOTYPE(intw)                                  \
+    NPY_NO_EXPORT int                                                   \
+    npy_to_##intw(PyArray_Descr *descr,                                     \
+            const Py_UCS4 *str, const Py_UCS4 *end, char *dataptr,      \
+            parser_config *pconfig);
+
+DECLARE_TO_INT_PROTOTYPE(int8)
+DECLARE_TO_INT_PROTOTYPE(int16)
+DECLARE_TO_INT_PROTOTYPE(int32)
+DECLARE_TO_INT_PROTOTYPE(int64)
+
+DECLARE_TO_INT_PROTOTYPE(uint8)
+DECLARE_TO_INT_PROTOTYPE(uint16)
+DECLARE_TO_INT_PROTOTYPE(uint32)
+DECLARE_TO_INT_PROTOTYPE(uint64)
+
+#endif  /* NUMPY_CORE_SRC_MULTIARRAY_TEXTREADING_STR_TO_INT_H_ */
diff --git a/numpy/core/src/multiarray/textreading/stream.h b/numpy/core/src/multiarray/textreading/stream.h
new file mode 100644
index 000000000000..42ca654dbd8e
--- /dev/null
+++ b/numpy/core/src/multiarray/textreading/stream.h
@@ -0,0 +1,49 @@
+#ifndef NUMPY_CORE_SRC_MULTIARRAY_TEXTREADING_STREAM_H_
+#define NUMPY_CORE_SRC_MULTIARRAY_TEXTREADING_STREAM_H_
+
+#include 
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * When getting the next line, we hope that the buffer provider can already
+ * give some information about the newlines, because for Python iterables
+ * we definitely expect to get line-by-line buffers.
+ *
+ * BUFFER_IS_FILEEND must be returned when the end of the file is reached and
+ * must NOT be returned together with a valid (non-empty) buffer.
+ */
+#define BUFFER_MAY_CONTAIN_NEWLINE 0
+#define BUFFER_IS_LINEND 1
+#define BUFFER_IS_FILEEND 2
+
+/*
+ * Base struct for streams.  We currently have two, a chunked reader for
+ * filelikes and a line-by-line for any iterable.
+ * As of writing, the chunked reader was only used for filelikes not already
+ * opened.  That is to preserve the amount read in case of an error exactly.
+ * If we drop this, we could read it more often (but not when `max_rows` is
+ * used).
+ *
+ * The "streams" can extend this struct to store their own data (so it is
+ * a very lightweight "object").
+ */
+typedef struct _stream {
+    int (*stream_nextbuf)(void *sdata, char **start, char **end, int *kind);
+    // Note that the first argument to stream_close is the stream pointer
+    // itself, not the stream_data pointer.
+    int (*stream_close)(struct _stream *strm);
+} stream;
+
+
+#define stream_nextbuf(s, start, end, kind)  \
+        ((s)->stream_nextbuf((s), start, end, kind))
+#define stream_close(s)    ((s)->stream_close((s)))
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  /* NUMPY_CORE_SRC_MULTIARRAY_TEXTREADING_STREAM_H_ */
diff --git a/numpy/core/src/multiarray/textreading/stream_pyobject.c b/numpy/core/src/multiarray/textreading/stream_pyobject.c
new file mode 100644
index 000000000000..6f84ff01ddbb
--- /dev/null
+++ b/numpy/core/src/multiarray/textreading/stream_pyobject.c
@@ -0,0 +1,239 @@
+/*
+ * C side structures to provide capabilities to read Python file like objects
+ * in chunks, or iterate through iterables with each result representing a
+ * single line of a file.
+ */
+
+#include 
+#include 
+
+#define PY_SSIZE_T_CLEAN
+#include 
+#define NPY_NO_DEPRECATED_API NPY_API_VERSION
+#define _MULTIARRAYMODULE
+#include "numpy/arrayobject.h"
+
+#include "textreading/stream.h"
+
+#define READ_CHUNKSIZE 1 << 14
+
+
+typedef struct {
+    stream stream;
+    /* The Python file object being read. */
+    PyObject *file;
+
+    /* The `read` attribute of the file object. */
+    PyObject *read;
+    /* Amount to read each time we call `obj.read()` */
+    PyObject *chunksize;
+
+    /* Python str object holding the line most recently read from the file. */
+    PyObject *chunk;
+
+    /* Encoding compatible with Python's `PyUnicode_Encode` (may be NULL) */
+    const char *encoding;
+} python_chunks_from_file;
+
+
+/*
+ * Helper function to support byte objects as well as unicode strings.
+ *
+ * NOTE: Steals a reference to `str` (although usually returns it unmodified).
+ */
+static NPY_INLINE PyObject *
+process_stringlike(PyObject *str, const char *encoding)
+{
+    if (PyBytes_Check(str)) {
+        PyObject *ustr;
+        ustr = PyUnicode_FromEncodedObject(str, encoding, NULL);
+        if (ustr == NULL) {
+            return NULL;
+        }
+        Py_DECREF(str);
+        return ustr;
+    }
+    else if (!PyUnicode_Check(str)) {
+        PyErr_SetString(PyExc_TypeError,
+                "non-string returned while reading data");
+        Py_DECREF(str);
+        return NULL;
+    }
+    return str;
+}
+
+
+static NPY_INLINE void
+buffer_info_from_unicode(PyObject *str, char **start, char **end, int *kind)
+{
+    Py_ssize_t length = PyUnicode_GET_LENGTH(str);
+    *kind = PyUnicode_KIND(str);
+
+    if (*kind == PyUnicode_1BYTE_KIND) {
+        *start = (char *)PyUnicode_1BYTE_DATA(str);
+    }
+    else if (*kind == PyUnicode_2BYTE_KIND) {
+        *start = (char *)PyUnicode_2BYTE_DATA(str);
+        length *= sizeof(Py_UCS2);
+    }
+    else if (*kind == PyUnicode_4BYTE_KIND) {
+        *start = (char *)PyUnicode_4BYTE_DATA(str);
+        length *= sizeof(Py_UCS4);
+    }
+    *end = *start + length;
+}
+
+
+static int
+fb_nextbuf(python_chunks_from_file *fb, char **start, char **end, int *kind)
+{
+    Py_XDECREF(fb->chunk);
+    fb->chunk = NULL;
+
+    PyObject *chunk = PyObject_CallFunctionObjArgs(fb->read, fb->chunksize, NULL);
+    if (chunk == NULL) {
+        return -1;
+    }
+    fb->chunk = process_stringlike(chunk, fb->encoding);
+    if (fb->chunk == NULL) {
+        return -1;
+    }
+    buffer_info_from_unicode(fb->chunk, start, end, kind);
+    if (*start == *end) {
+        return BUFFER_IS_FILEEND;
+    }
+    return BUFFER_MAY_CONTAIN_NEWLINE;
+}
+
+
+static int
+fb_del(stream *strm)
+{
+    python_chunks_from_file *fb = (python_chunks_from_file *)strm;
+
+    Py_XDECREF(fb->file);
+    Py_XDECREF(fb->read);
+    Py_XDECREF(fb->chunksize);
+    Py_XDECREF(fb->chunk);
+
+    PyMem_FREE(strm);
+
+    return 0;
+}
+
+
+NPY_NO_EXPORT stream *
+stream_python_file(PyObject *obj, const char *encoding)
+{
+    python_chunks_from_file *fb;
+
+    fb = (python_chunks_from_file *)PyMem_Calloc(1, sizeof(python_chunks_from_file));
+    if (fb == NULL) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+
+    fb->stream.stream_nextbuf = (void *)&fb_nextbuf;
+    fb->stream.stream_close = &fb_del;
+
+    fb->encoding = encoding;
+    Py_INCREF(obj);
+    fb->file = obj;
+
+    fb->read = PyObject_GetAttrString(obj, "read");
+    if (fb->read == NULL) {
+        goto fail;
+    }
+    fb->chunksize = PyLong_FromLong(READ_CHUNKSIZE);
+    if (fb->chunksize == NULL) {
+        goto fail;
+    }
+
+    return (stream *)fb;
+
+fail:
+    fb_del((stream *)fb);
+    return NULL;
+}
+
+
+/*
+ * Stream from a Python iterable by interpreting each item as a line in a file
+ */
+typedef struct {
+    stream stream;
+    /* The Python file object being read. */
+    PyObject *iterator;
+
+    /* Python str object holding the line most recently fetched */
+    PyObject *line;
+
+    /* Encoding compatible with Python's `PyUnicode_Encode` (may be NULL) */
+    const char *encoding;
+} python_lines_from_iterator;
+
+
+static int
+it_del(stream *strm)
+{
+    python_lines_from_iterator *it = (python_lines_from_iterator *)strm;
+
+    Py_XDECREF(it->iterator);
+    Py_XDECREF(it->line);
+
+    PyMem_FREE(strm);
+    return 0;
+}
+
+
+static int
+it_nextbuf(python_lines_from_iterator *it, char **start, char **end, int *kind)
+{
+    Py_XDECREF(it->line);
+    it->line = NULL;
+
+    PyObject *line = PyIter_Next(it->iterator);
+    if (line == NULL) {
+        if (PyErr_Occurred()) {
+            return -1;
+        }
+        *start = NULL;
+        *end = NULL;
+        return BUFFER_IS_FILEEND;
+    }
+    it->line = process_stringlike(line, it->encoding);
+    if (it->line == NULL) {
+        return -1;
+    }
+
+    buffer_info_from_unicode(it->line, start, end, kind);
+    return BUFFER_IS_LINEND;
+}
+
+
+NPY_NO_EXPORT stream *
+stream_python_iterable(PyObject *obj, const char *encoding)
+{
+    python_lines_from_iterator *it;
+
+    if (!PyIter_Check(obj)) {
+        PyErr_SetString(PyExc_TypeError,
+                "error reading from object, expected an iterable.");
+        return NULL;
+    }
+
+    it = (python_lines_from_iterator *)PyMem_Calloc(1, sizeof(*it));
+    if (it == NULL) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+
+    it->stream.stream_nextbuf = (void *)&it_nextbuf;
+    it->stream.stream_close = &it_del;
+
+    it->encoding = encoding;
+    Py_INCREF(obj);
+    it->iterator = obj;
+
+    return (stream *)it;
+}
diff --git a/numpy/core/src/multiarray/textreading/stream_pyobject.h b/numpy/core/src/multiarray/textreading/stream_pyobject.h
new file mode 100644
index 000000000000..45c11dd951a7
--- /dev/null
+++ b/numpy/core/src/multiarray/textreading/stream_pyobject.h
@@ -0,0 +1,16 @@
+
+#ifndef NUMPY_CORE_SRC_MULTIARRAY_TEXTREADING_STREAM_PYOBJECT_H_
+#define NUMPY_CORE_SRC_MULTIARRAY_TEXTREADING_STREAM_PYOBJECT_H_
+
+#define PY_SSIZE_T_CLEAN
+#include 
+
+#include "textreading/stream.h"
+
+NPY_NO_EXPORT stream *
+stream_python_file(PyObject *obj, const char *encoding);
+
+NPY_NO_EXPORT stream *
+stream_python_iterable(PyObject *obj, const char *encoding);
+
+#endif  /* NUMPY_CORE_SRC_MULTIARRAY_TEXTREADING_STREAM_PYOBJECT_H_ */
diff --git a/numpy/core/src/multiarray/textreading/tokenize.cpp b/numpy/core/src/multiarray/textreading/tokenize.cpp
new file mode 100644
index 000000000000..5a85fd402dd4
--- /dev/null
+++ b/numpy/core/src/multiarray/textreading/tokenize.cpp
@@ -0,0 +1,457 @@
+
+#include 
+
+#define NPY_NO_DEPRECATED_API NPY_API_VERSION
+#define _MULTIARRAYMODULE
+#include "numpy/ndarraytypes.h"
+
+#include "textreading/stream.h"
+#include "textreading/tokenize.h"
+#include "textreading/parser_config.h"
+#include "textreading/growth.h"
+
+/*
+    How parsing quoted fields works:
+
+    For quoting to be activated, the first character of the field
+    must be the quote character (after taking into account
+    ignore_leading_spaces).  While quoting is active, delimiters
+    are treated as regular characters, not delimiters.  Quoting is
+    deactivated by the second occurrence of the quote character.  An
+    exception is the occurrence of two consecutive quote characters,
+    which is treated as a literal occurrence of a single quote character.
+    E.g. (with delimiter=',' and quote='"'):
+        12.3,"New York, NY","3'2"""
+    The second and third fields are `New York, NY` and `3'2"`.
+
+    If a non-delimiter occurs after the closing quote, the quote is
+    ignored and parsing continues with quoting deactivated.  Quotes
+    that occur while quoting is not activated are not handled specially;
+    they become part of the data.
+    E.g:
+        12.3,"ABC"DEF,XY"Z
+    The second and third fields are `ABCDEF` and `XY"Z`.
+
+    Note that the second field of
+        12.3,"ABC"   ,4.5
+    is `ABC   `.  Currently there is no option to ignore whitespace
+    at the end of a field.
+*/
+
+
+template 
+static inline int
+copy_to_field_buffer(tokenizer_state *ts,
+        const UCS *chunk_start, const UCS *chunk_end)
+{
+    npy_intp chunk_length = chunk_end - chunk_start;
+    /* Space for length +1 termination, +2 additional padding for add_field */
+    npy_intp size = chunk_length + ts->field_buffer_pos + 3;
+
+    if (NPY_UNLIKELY(ts->field_buffer_length < size)) {
+        npy_intp alloc_size = grow_size_and_multiply(&size, 32, sizeof(Py_UCS4));
+        if (alloc_size < 0) {
+            PyErr_Format(PyExc_ValueError,
+                    "line too long to handle while reading file.");
+            return -1;
+        }
+        Py_UCS4 *grown = (Py_UCS4 *)PyMem_Realloc(ts->field_buffer, alloc_size);
+        if (grown == nullptr) {
+            PyErr_NoMemory();
+            return -1;
+        }
+        ts->field_buffer_length = size;
+        ts->field_buffer = grown;
+    }
+
+    Py_UCS4 *write_pos = ts->field_buffer + ts->field_buffer_pos;
+    for (; chunk_start < chunk_end; chunk_start++, write_pos++) {
+        *write_pos = (Py_UCS4)*chunk_start;
+    }
+    *write_pos = '\0';  /* always ensure we end with NUL */
+    ts->field_buffer_pos += chunk_length;
+    return 0;
+}
+
+
+static inline int
+add_field(tokenizer_state *ts)
+{
+    /* The previous field is done, advance to keep a NUL byte at the end */
+    ts->field_buffer_pos += 1;
+
+    if (NPY_UNLIKELY(ts->num_fields + 1 > ts->fields_size)) {
+        npy_intp size = ts->num_fields;
+
+        npy_intp alloc_size = grow_size_and_multiply(
+                &size, 4, sizeof(field_info));
+        if (alloc_size < 0) {
+            /* Check for a size overflow, path should be almost impossible. */
+            PyErr_Format(PyExc_ValueError,
+                    "too many columns found; cannot read file.");
+            return -1;
+        }
+        field_info *fields = (field_info *)PyMem_Realloc(ts->fields, alloc_size);
+        if (fields == nullptr) {
+            PyErr_NoMemory();
+            return -1;
+        }
+        ts->fields = fields;
+        ts->fields_size = size;
+    }
+
+    ts->fields[ts->num_fields].offset = ts->field_buffer_pos;
+    ts->fields[ts->num_fields].quoted = false;
+    ts->num_fields += 1;
+    /* Ensure this (currently empty) word is NUL terminated. */
+    ts->field_buffer[ts->field_buffer_pos] = '\0';
+    assert(ts->field_buffer_length > ts->field_buffer_pos);
+    return 0;
+}
+
+
+template 
+static inline int
+tokenizer_core(tokenizer_state *ts, parser_config *const config)
+{
+    UCS *pos = (UCS *)ts->pos;
+    UCS *stop = (UCS *)ts->end;
+    UCS *chunk_start;
+
+    if (ts->state == TOKENIZE_CHECK_QUOTED) {
+        /* before we can check for quotes, strip leading whitespace */
+        if (config->ignore_leading_whitespace) {
+            while (pos < stop && Py_UNICODE_ISSPACE(*pos) &&
+                        *pos != '\r' && *pos != '\n') {
+                pos++;
+            }
+            if (pos == stop) {
+                ts->pos = (char *)pos;
+                return 0;
+            }
+        }
+
+        /* Setting chunk effectively starts the field */
+        if (*pos == config->quote) {
+            ts->fields[ts->num_fields - 1].quoted = true;
+            ts->state = TOKENIZE_QUOTED;
+            pos++;  /* TOKENIZE_QUOTED is OK with pos == stop */
+        }
+        else {
+            /* Set to TOKENIZE_QUOTED or TOKENIZE_QUOTED_WHITESPACE */
+            ts->state = ts->unquoted_state;
+        }
+    }
+
+    switch (ts->state) {
+        case TOKENIZE_UNQUOTED:
+            chunk_start = pos;
+            for (; pos < stop; pos++) {
+                if (*pos == '\r') {
+                    ts->state = TOKENIZE_EAT_CRLF;
+                    break;
+                }
+                else if (*pos == '\n') {
+                    ts->state = TOKENIZE_LINE_END;
+                    break;
+                }
+                else if (*pos == config->delimiter) {
+                    ts->state = TOKENIZE_INIT;
+                    break;
+                }
+                else if (*pos == config->comment) {
+                    ts->state = TOKENIZE_GOTO_LINE_END;
+                    break;
+                }
+            }
+            if (copy_to_field_buffer(ts, chunk_start, pos) < 0) {
+                return -1;
+            }
+            pos++;
+            break;
+
+        case TOKENIZE_UNQUOTED_WHITESPACE:
+            /* Note, this branch is largely identical to `TOKENIZE_UNQUOTED` */
+            chunk_start = pos;
+            for (; pos < stop; pos++) {
+                if (*pos == '\r') {
+                    ts->state = TOKENIZE_EAT_CRLF;
+                    break;
+                }
+                else if (*pos == '\n') {
+                    ts->state = TOKENIZE_LINE_END;
+                    break;
+                }
+                else if (Py_UNICODE_ISSPACE(*pos)) {
+                    ts->state = TOKENIZE_INIT;
+                    break;
+                }
+                else if (*pos == config->comment) {
+                    ts->state = TOKENIZE_GOTO_LINE_END;
+                    break;
+                }
+            }
+            if (copy_to_field_buffer(ts, chunk_start, pos) < 0) {
+                return -1;
+            }
+            pos++;
+            break;
+
+        case TOKENIZE_QUOTED:
+            chunk_start = pos;
+            for (; pos < stop; pos++) {
+                if (*pos == config->quote) {
+                    ts->state = TOKENIZE_QUOTED_CHECK_DOUBLE_QUOTE;
+                    break;
+                }
+            }
+            if (copy_to_field_buffer(ts, chunk_start, pos) < 0) {
+                return -1;
+            }
+            pos++;
+            break;
+
+        case TOKENIZE_QUOTED_CHECK_DOUBLE_QUOTE:
+            if (*pos == config->quote) {
+                /* Copy the quote character directly from the config: */
+                if (copy_to_field_buffer(ts,
+                        &config->quote, &config->quote+1) < 0) {
+                    return -1;
+                }
+                ts->state = TOKENIZE_QUOTED;
+                pos++;
+            }
+            else {
+                /* continue parsing as if unquoted */
+                /* Set to TOKENIZE_UNQUOTED or TOKENIZE_UNQUOTED_WHITESPACE */
+                ts->state = ts->unquoted_state;
+            }
+            break;
+
+        case TOKENIZE_GOTO_LINE_END:
+            if (ts->buf_state != BUFFER_MAY_CONTAIN_NEWLINE) {
+                pos = stop;  /* advance to next buffer */
+                ts->state = TOKENIZE_LINE_END;
+                break;
+            }
+            for (; pos < stop; pos++) {
+                if (*pos == '\r') {
+                    ts->state = TOKENIZE_EAT_CRLF;
+                    break;
+                }
+                else if (*pos == '\n') {
+                    ts->state = TOKENIZE_LINE_END;
+                    break;
+                }
+            }
+            pos++;
+            break;
+
+        case TOKENIZE_EAT_CRLF:
+            /* "Universal newline" support: remove \n in \r\n. */
+            if (*pos == '\n') {
+                pos++;
+            }
+            ts->state = TOKENIZE_LINE_END;
+            break;
+
+        default:
+            assert(0);
+    }
+
+    ts->pos = (char *)pos;
+    return 0;
+}
+
+
+/*
+ * This tokenizer always copies the full "row" (all tokens).  This makes
+ * two things easier:
+ * 1. It means that every word is guaranteed to be followed by a NUL character
+ *    (although it can include one as well).
+ * 2. If usecols are used we can sniff the first row easier by parsing it
+ *    fully.  Further, usecols can be negative so we may not know which row we
+ *    need up-front.
+ *
+ * The tokenizer could grow the ability to skip fields and check the
+ * maximum number of fields when known, it is unclear that this is worthwhile.
+ *
+ * Unlike some tokenizers, this one tries to work in chunks and copies
+ * data in chunks as well.  The hope is that this makes multiple light-weight
+ * loops rather than a single heavy one, to allow e.g. quickly scanning for the
+ * end of a field.  Copying chunks also means we usually only check once per
+ * field whether the buffer is large enough.
+ * Different choices are possible, this one seems to work well, though.
+ *
+ * The core (main part) of the tokenizer is specialized for the three Python
+ * unicode flavors UCS1, UCS2, and UCS4 as a worthwhile optimization.
+ */
+NPY_NO_EXPORT int
+npy_tokenize(stream *s, tokenizer_state *ts, parser_config *const config)
+{
+    assert(ts->fields_size >= 2);
+    assert(ts->field_buffer_length >= 2*sizeof(Py_UCS4));
+
+    int finished_reading_file = 0;
+
+    /* Reset to start of buffer */
+    ts->field_buffer_pos = 0;
+    ts->num_fields = 0;
+
+    while (true) {
+        /*
+         * This loop adds new fields to the result (to make up a full row)
+         * until the row ends (typically a line end or the file end)
+         */
+        if (ts->state == TOKENIZE_INIT) {
+            /* Start a new field */
+            if (add_field(ts) < 0) {
+                return -1;
+            }
+            ts->state = TOKENIZE_CHECK_QUOTED;
+        }
+
+        if (NPY_UNLIKELY(ts->pos >= ts->end)) {
+            if (ts->buf_state == BUFFER_IS_LINEND &&
+                    ts->state != TOKENIZE_QUOTED) {
+                /*
+                 * Finished line, do not read anymore (also do not eat \n).
+                 * If we are in a quoted field and the "line" does not end with
+                 * a newline, the quoted field will not have it either.
+                 * I.e. `np.loadtxt(['"a', 'b"'], dtype="S2", quotechar='"')`
+                 * reads "ab". This matches `next(csv.reader(['"a', 'b"']))`.
+                 */
+                break;
+            }
+            /* fetch new data */
+            ts->buf_state = stream_nextbuf(s,
+                    &ts->pos, &ts->end, &ts->unicode_kind);
+            if (ts->buf_state < 0) {
+                return -1;
+            }
+            if (ts->buf_state == BUFFER_IS_FILEEND) {
+                finished_reading_file = 1;
+                ts->pos = ts->end;  /* stream should ensure this. */
+                break;
+            }
+            else if (ts->pos == ts->end) {
+                /* This must be an empty line (and it must be indicated!). */
+                assert(ts->buf_state == BUFFER_IS_LINEND);
+                break;
+            }
+        }
+        int status;
+        if (ts->unicode_kind == PyUnicode_1BYTE_KIND) {
+            status = tokenizer_core(ts, config);
+        }
+        else if (ts->unicode_kind == PyUnicode_2BYTE_KIND) {
+            status = tokenizer_core(ts, config);
+        }
+        else {
+            assert(ts->unicode_kind == PyUnicode_4BYTE_KIND);
+            status = tokenizer_core(ts, config);
+        }
+        if (status < 0) {
+            return -1;
+        }
+
+        if (ts->state == TOKENIZE_LINE_END) {
+            break;
+        }
+    }
+
+    /*
+     * We have finished tokenizing a full row into fields, finalize result
+     */
+    if (ts->buf_state == BUFFER_IS_LINEND) {
+        /* This line is "finished", make sure we don't touch it again: */
+        ts->buf_state = BUFFER_MAY_CONTAIN_NEWLINE;
+        if (NPY_UNLIKELY(ts->pos < ts->end)) {
+            PyErr_SetString(PyExc_ValueError,
+                    "Found an unquoted embedded newline within a single line of "
+                    "input.  This is currently not supported.");
+            return -1;
+        }
+    }
+
+    /* Finish the last field (we "append" one to store the last ones length) */
+    if (add_field(ts) < 0) {
+        return -1;
+    }
+    ts->num_fields -= 1;
+
+    /*
+     * We always start a new field (at the very beginning and whenever a
+     * delimiter was found).
+     * This gives us two scenarios where we need to ignore the last field
+     * if it is empty:
+     * 1. If there is exactly one empty (unquoted) field, the whole line is
+     *    empty.
+     * 2. If we are splitting on whitespace we always ignore a last empty
+     *    field to match Python's splitting: `" 1 ".split()`.
+     *    (Zero fields are possible when we are only skipping lines)
+     */
+    if (ts->num_fields == 1 || (ts->num_fields > 0
+                && ts->unquoted_state == TOKENIZE_UNQUOTED_WHITESPACE)) {
+        size_t offset_last = ts->fields[ts->num_fields-1].offset;
+        size_t end_last = ts->fields[ts->num_fields].offset;
+        if (!ts->fields->quoted && end_last - offset_last == 1) {
+            ts->num_fields--;
+        }
+    }
+    ts->state = TOKENIZE_INIT;
+    return finished_reading_file;
+}
+
+
+NPY_NO_EXPORT void
+npy_tokenizer_clear(tokenizer_state *ts)
+{
+    PyMem_FREE(ts->field_buffer);
+    ts->field_buffer = nullptr;
+    ts->field_buffer_length = 0;
+
+    PyMem_FREE(ts->fields);
+    ts->fields = nullptr;
+    ts->fields_size = 0;
+}
+
+
+/*
+ * Initialize the tokenizer.  We may want to copy all important config
+ * variables into the tokenizer.  This would improve the cache locality during
+ * tokenizing.
+ */
+NPY_NO_EXPORT int
+npy_tokenizer_init(tokenizer_state *ts, parser_config *config)
+{
+    /* State and buf_state could be moved into tokenize if we go by row */
+    ts->buf_state = BUFFER_MAY_CONTAIN_NEWLINE;
+    ts->state = TOKENIZE_INIT;
+    if (config->delimiter_is_whitespace) {
+        ts->unquoted_state = TOKENIZE_UNQUOTED_WHITESPACE;
+    }
+    else {
+        ts->unquoted_state = TOKENIZE_UNQUOTED;
+    }
+    ts->num_fields = 0;
+
+    ts->buf_state = 0;
+    ts->pos = nullptr;
+    ts->end = nullptr;
+
+    ts->field_buffer = (Py_UCS4 *)PyMem_Malloc(32 * sizeof(Py_UCS4));
+    if (ts->field_buffer == nullptr) {
+        PyErr_NoMemory();
+        return -1;
+    }
+    ts->field_buffer_length = 32;
+
+    ts->fields = (field_info *)PyMem_Malloc(4 * sizeof(*ts->fields));
+    if (ts->fields == nullptr) {
+        PyErr_NoMemory();
+        return -1;
+    }
+    ts->fields_size = 4;
+    return 0;
+}
diff --git a/numpy/core/src/multiarray/textreading/tokenize.h b/numpy/core/src/multiarray/textreading/tokenize.h
new file mode 100644
index 000000000000..53e97760ff9e
--- /dev/null
+++ b/numpy/core/src/multiarray/textreading/tokenize.h
@@ -0,0 +1,87 @@
+
+#ifndef NUMPY_CORE_SRC_MULTIARRAY_TEXTREADING_TOKENIZE_H_
+#define NUMPY_CORE_SRC_MULTIARRAY_TEXTREADING_TOKENIZE_H_
+
+#include 
+#include "numpy/ndarraytypes.h"
+
+#include "textreading/stream.h"
+#include "textreading/parser_config.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+typedef enum {
+    /* Initialization of fields */
+    TOKENIZE_INIT,
+    TOKENIZE_CHECK_QUOTED,
+    /* Main field parsing states */
+    TOKENIZE_UNQUOTED,
+    TOKENIZE_UNQUOTED_WHITESPACE,
+    TOKENIZE_QUOTED,
+    /* Handling of two character control sequences (except "\r\n") */
+    TOKENIZE_QUOTED_CHECK_DOUBLE_QUOTE,
+    /* Line end handling */
+    TOKENIZE_LINE_END,
+    TOKENIZE_EAT_CRLF,  /* "\r\n" support (carriage return, line feed) */
+    TOKENIZE_GOTO_LINE_END,
+} tokenizer_parsing_state;
+
+
+typedef struct {
+    size_t offset;
+    bool quoted;
+} field_info;
+
+
+typedef struct {
+    tokenizer_parsing_state state;
+    /* Either TOKENIZE_UNQUOTED or TOKENIZE_UNQUOTED_WHITESPACE: */
+    tokenizer_parsing_state unquoted_state;
+    int unicode_kind;
+    int buf_state;
+    /* the buffer we are currently working on */
+    char *pos;
+    char *end;
+    /*
+     * Space to copy words into.  Due to `add_field` not growing the buffer
+     * but writing a \0 termination, the buffer must always be two larger
+     * (add_field can be called twice if a row ends in a delimiter: "123,").
+     * The first byte beyond the current word is always NUL'ed on write, the
+     * second byte is there to allow easy appending of an additional empty
+     * word at the end (this word is also NUL terminated).
+     */
+    npy_intp field_buffer_length;
+    npy_intp field_buffer_pos;
+    Py_UCS4 *field_buffer;
+
+    /*
+     * Fields, including information about the field being quoted.  This
+     * always includes one "additional" empty field.  The length of a field
+     * is equal to `fields[i+1].offset - fields[i].offset - 1`.
+     *
+     * The tokenizer assumes at least one field is allocated.
+     */
+    npy_intp num_fields;
+    npy_intp fields_size;
+    field_info *fields;
+} tokenizer_state;
+
+
+NPY_NO_EXPORT void
+npy_tokenizer_clear(tokenizer_state *ts);
+
+
+NPY_NO_EXPORT int
+npy_tokenizer_init(tokenizer_state *ts, parser_config *config);
+
+NPY_NO_EXPORT int
+npy_tokenize(stream *s, tokenizer_state *ts, parser_config *const config);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  /* NUMPY_CORE_SRC_MULTIARRAY_TEXTREADING_TOKENIZE_H_ */
diff --git a/numpy/core/src/multiarray/typeinfo.c b/numpy/core/src/multiarray/typeinfo.c
index 8cf6bc1e005d..18179f7e7b61 100644
--- a/numpy/core/src/multiarray/typeinfo.c
+++ b/numpy/core/src/multiarray/typeinfo.c
@@ -9,12 +9,6 @@
 #include "npy_pycompat.h"
 #include "typeinfo.h"
 
-#if (defined(PYPY_VERSION_NUM) && (PYPY_VERSION_NUM <= 0x07030000))
-/* PyPy issue 3160 */
-#include 
-#endif
-
-
 
 static PyTypeObject PyArray_typeinfoType;
 static PyTypeObject PyArray_typeinforangedType;
@@ -99,17 +93,6 @@ PyArray_typeinforanged(
     return entry;
 }
 
-/* Python version needed for older PyPy */
-#if (defined(PYPY_VERSION_NUM) && (PYPY_VERSION_NUM < 0x07020000))
-    static int
-    PyStructSequence_InitType2(PyTypeObject *type, PyStructSequence_Desc *desc) {
-        PyStructSequence_InitType(type, desc);
-        if (PyErr_Occurred()) {
-            return -1;
-        }
-        return 0;
-    }
-#endif
 
 NPY_NO_EXPORT int
 typeinfo_init_structsequences(PyObject *multiarray_dict)
diff --git a/numpy/core/src/npymath/arm64_exports.c b/numpy/core/src/npymath/arm64_exports.c
new file mode 100644
index 000000000000..c9f0fbf746eb
--- /dev/null
+++ b/numpy/core/src/npymath/arm64_exports.c
@@ -0,0 +1,26 @@
+#if defined(__arm64__) && defined(__APPLE__)
+
+#include 
+/*
+ * Export these for scipy, since the SciPy build for macos arm64
+ * downloads the macos x86_64 NumPy, and does not error when the
+ * linker fails to use npymathlib.a. Importing numpy will expose
+ * these external functions
+ * See https://github.com/numpy/numpy/issues/22673#issuecomment-1327520055
+ *
+ * This file is actually compiled as part of the main module.
+ */
+
+double npy_asinh(double x) {
+    return asinh(x);
+}
+
+double npy_copysign(double y, double x) {
+    return copysign(y, x);
+}
+
+double npy_log1p(double x) {
+    return log1p(x);
+}
+
+#endif
diff --git a/numpy/core/src/npymath/ieee754.c.src b/numpy/core/src/npymath/ieee754.c.src
index 4e6ddb712ca7..5d8cb06a4de3 100644
--- a/numpy/core/src/npymath/ieee754.c.src
+++ b/numpy/core/src/npymath/ieee754.c.src
@@ -8,17 +8,6 @@
 #include "npy_math_private.h"
 #include "numpy/utils.h"
 
-#ifndef HAVE_COPYSIGN
-double npy_copysign(double x, double y)
-{
-    npy_uint32 hx, hy;
-    GET_HIGH_WORD(hx, x);
-    GET_HIGH_WORD(hy, y);
-    SET_HIGH_WORD(x, (hx & 0x7fffffff) | (hy & 0x80000000));
-    return x;
-}
-#endif
-
 /*
  The below code is provided for compilers which do not yet provide C11 compatibility (gcc 4.5 and older)
  */
@@ -321,201 +310,6 @@ static npy_longdouble _nextl(npy_longdouble x, int p)
 }
 #endif
 
-/*
- * nextafter code taken from BSD math lib, the code contains the following
- * notice:
- *
- * ====================================================
- * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
- *
- * Developed at SunPro, a Sun Microsystems, Inc. business.
- * Permission to use, copy, modify, and distribute this
- * software is freely granted, provided that this notice
- * is preserved.
- * ====================================================
- */
-
-#ifndef HAVE_NEXTAFTER
-double npy_nextafter(double x, double y)
-{
-    volatile double t;
-    npy_int32 hx, hy, ix, iy;
-    npy_uint32 lx, ly;
-
-    EXTRACT_WORDS(hx, lx, x);
-    EXTRACT_WORDS(hy, ly, y);
-    ix = hx & 0x7fffffff;       /* |x| */
-    iy = hy & 0x7fffffff;       /* |y| */
-
-    if (((ix >= 0x7ff00000) && ((ix - 0x7ff00000) | lx) != 0) ||        /* x is nan */
-        ((iy >= 0x7ff00000) && ((iy - 0x7ff00000) | ly) != 0))  /* y is nan */
-        return x + y;
-    if (x == y)
-        return y;               /* x=y, return y */
-    if ((ix | lx) == 0) {       /* x == 0 */
-        INSERT_WORDS(x, hy & 0x80000000, 1);    /* return +-minsubnormal */
-        t = x * x;
-        if (t == x)
-            return t;
-        else
-            return x;           /* raise underflow flag */
-    }
-    if (hx >= 0) {              /* x > 0 */
-        if (hx > hy || ((hx == hy) && (lx > ly))) {     /* x > y, x -= ulp */
-            if (lx == 0)
-                hx -= 1;
-            lx -= 1;
-        } else {                /* x < y, x += ulp */
-            lx += 1;
-            if (lx == 0)
-                hx += 1;
-        }
-    } else {                    /* x < 0 */
-        if (hy >= 0 || hx > hy || ((hx == hy) && (lx > ly))) {  /* x < y, x -= ulp */
-            if (lx == 0)
-                hx -= 1;
-            lx -= 1;
-        } else {                /* x > y, x += ulp */
-            lx += 1;
-            if (lx == 0)
-                hx += 1;
-        }
-    }
-    hy = hx & 0x7ff00000;
-    if (hy >= 0x7ff00000)
-        return x + x;           /* overflow  */
-    if (hy < 0x00100000) {      /* underflow */
-        t = x * x;
-        if (t != x) {           /* raise underflow flag */
-            INSERT_WORDS(y, hx, lx);
-            return y;
-        }
-    }
-    INSERT_WORDS(x, hx, lx);
-    return x;
-}
-#endif
-
-#ifndef HAVE_NEXTAFTERF
-float npy_nextafterf(float x, float y)
-{
-    volatile float t;
-    npy_int32 hx, hy, ix, iy;
-
-    GET_FLOAT_WORD(hx, x);
-    GET_FLOAT_WORD(hy, y);
-    ix = hx & 0x7fffffff;       /* |x| */
-    iy = hy & 0x7fffffff;       /* |y| */
-
-    if ((ix > 0x7f800000) ||    /* x is nan */
-        (iy > 0x7f800000))      /* y is nan */
-        return x + y;
-    if (x == y)
-        return y;               /* x=y, return y */
-    if (ix == 0) {              /* x == 0 */
-        SET_FLOAT_WORD(x, (hy & 0x80000000) | 1); /* return +-minsubnormal */
-        t = x * x;
-        if (t == x)
-            return t;
-        else
-            return x;           /* raise underflow flag */
-    }
-    if (hx >= 0) {              /* x > 0 */
-        if (hx > hy) {          /* x > y, x -= ulp */
-            hx -= 1;
-        } else {                /* x < y, x += ulp */
-            hx += 1;
-        }
-    } else {                    /* x < 0 */
-        if (hy >= 0 || hx > hy) {       /* x < y, x -= ulp */
-            hx -= 1;
-        } else {                /* x > y, x += ulp */
-            hx += 1;
-        }
-    }
-    hy = hx & 0x7f800000;
-    if (hy >= 0x7f800000)
-        return x + x;           /* overflow  */
-    if (hy < 0x00800000) {      /* underflow */
-        t = x * x;
-        if (t != x) {           /* raise underflow flag */
-            SET_FLOAT_WORD(y, hx);
-            return y;
-        }
-    }
-    SET_FLOAT_WORD(x, hx);
-    return x;
-}
-#endif
-
-#ifndef HAVE_NEXTAFTERL
-npy_longdouble npy_nextafterl(npy_longdouble x, npy_longdouble y)
-{
-    volatile npy_longdouble t;
-    union IEEEl2bitsrep ux;
-    union IEEEl2bitsrep uy;
-
-    ux.e = x;
-    uy.e = y;
-
-    if ((GET_LDOUBLE_EXP(ux) == 0x7fff &&
-         ((GET_LDOUBLE_MANH(ux) & ~LDBL_NBIT) | GET_LDOUBLE_MANL(ux)) != 0) ||
-        (GET_LDOUBLE_EXP(uy) == 0x7fff &&
-         ((GET_LDOUBLE_MANH(uy) & ~LDBL_NBIT) | GET_LDOUBLE_MANL(uy)) != 0)) {
-        return ux.e + uy.e;        /* x or y is nan */
-    }
-    if (ux.e == uy.e) {
-        return uy.e;               /* x=y, return y */
-    }
-    if (ux.e == 0.0) {
-        SET_LDOUBLE_MANH(ux, 0);              /* return +-minsubnormal */
-        SET_LDOUBLE_MANL(ux, 1);
-        SET_LDOUBLE_SIGN(ux, GET_LDOUBLE_SIGN(uy));
-        t = ux.e * ux.e;
-        if (t == ux.e) {
-            return t;
-        } else {
-            return ux.e;           /* raise underflow flag */
-        }
-    }
-    if ((ux.e > 0.0) ^ (ux.e < uy.e)) {      /* x -= ulp */
-        if (GET_LDOUBLE_MANL(ux) == 0) {
-            if ((GET_LDOUBLE_MANH(ux) & ~LDBL_NBIT) == 0) {
-                SET_LDOUBLE_EXP(ux, GET_LDOUBLE_EXP(ux) - 1);
-            }
-            SET_LDOUBLE_MANH(ux,
-                             (GET_LDOUBLE_MANH(ux) - 1) |
-                             (GET_LDOUBLE_MANH(ux) & LDBL_NBIT));
-        }
-        SET_LDOUBLE_MANL(ux, GET_LDOUBLE_MANL(ux) - 1);
-    } else {                    /* x += ulp */
-        SET_LDOUBLE_MANL(ux, GET_LDOUBLE_MANL(ux) + 1);
-        if (GET_LDOUBLE_MANL(ux) == 0) {
-            SET_LDOUBLE_MANH(ux,
-                             (GET_LDOUBLE_MANH(ux) + 1) |
-                             (GET_LDOUBLE_MANH(ux) & LDBL_NBIT));
-            if ((GET_LDOUBLE_MANH(ux) & ~LDBL_NBIT) == 0) {
-                SET_LDOUBLE_EXP(ux, GET_LDOUBLE_EXP(ux) + 1);
-            }
-        }
-    }
-    if (GET_LDOUBLE_EXP(ux) == 0x7fff) {
-        return ux.e + ux.e;           /* overflow  */
-    }
-    if (GET_LDOUBLE_EXP(ux) == 0) {            /* underflow */
-        if (LDBL_NBIT) {
-            SET_LDOUBLE_MANH(ux, GET_LDOUBLE_MANH(ux) & ~LDBL_NBIT);
-        }
-        t = ux.e * ux.e;
-        if (t != ux.e) {           /* raise underflow flag */
-            return ux.e;
-        }
-    }
-
-    return ux.e;
-}
-#endif
-
 /**begin repeat
  * #suff = f,,l#
  * #SUFF = F,,L#
@@ -536,26 +330,20 @@ npy_longdouble npy_nextafterl(npy_longdouble x, npy_longdouble y)
  * Decorate all the math functions which are available on the current platform
  */
 
-#ifdef HAVE_NEXTAFTERF
 float npy_nextafterf(float x, float y)
 {
     return nextafterf(x, y);
 }
-#endif
 
-#ifdef HAVE_NEXTAFTER
 double npy_nextafter(double x, double y)
 {
     return nextafter(x, y);
 }
-#endif
 
-#ifdef HAVE_NEXTAFTERL
 npy_longdouble npy_nextafterl(npy_longdouble x, npy_longdouble y)
 {
     return nextafterl(x, y);
 }
-#endif
 
 int npy_clear_floatstatus() {
     char x=0;
@@ -566,228 +354,38 @@ int npy_get_floatstatus() {
     return npy_get_floatstatus_barrier(&x);
 }
 
-/*
- * Functions to set the floating point status word.
- */
-
-#if (defined(__unix__) || defined(unix)) && !defined(USG)
-#include 
-#endif
-
 
 /*
- * Define floating point status functions. We must define
- * npy_get_floatstatus_barrier, npy_clear_floatstatus_barrier,
- * npy_set_floatstatus_{divbyzero, overflow, underflow, invalid}
- * for all supported platforms.
+ * General C99 code for floating point error handling.  These functions mainly
+ * exists, because `fenv.h` was not standardized in C89 so they gave better
+ * portability.  This should be unnecessary with C99/C++11 and further
+ * functionality can be used from `fenv.h` directly.
  */
-
-
-/* Solaris --------------------------------------------------------*/
-/* --------ignoring SunOS ieee_flags approach, someone else can
-**         deal with that! */
-#if defined(sun) || defined(__BSD__) || defined(__OpenBSD__) || \
-    (defined(__FreeBSD__) && (__FreeBSD_version < 502114)) || \
-    defined(__NetBSD__)
-#include 
-
-int npy_get_floatstatus_barrier(char * param)
-{
-    int fpstatus = fpgetsticky();
-    /*
-     * By using a volatile, the compiler cannot reorder this call
-     */
-    if (param != NULL) {
-        volatile char NPY_UNUSED(c) = *(char*)param;
-    }
-    return ((FP_X_DZ  & fpstatus) ? NPY_FPE_DIVIDEBYZERO : 0) |
-           ((FP_X_OFL & fpstatus) ? NPY_FPE_OVERFLOW : 0) |
-           ((FP_X_UFL & fpstatus) ? NPY_FPE_UNDERFLOW : 0) |
-           ((FP_X_INV & fpstatus) ? NPY_FPE_INVALID : 0);
-}
-
-int npy_clear_floatstatus_barrier(char * param)
-{
-    int fpstatus = npy_get_floatstatus_barrier(param);
-    fpsetsticky(0);
-
-    return fpstatus;
-}
-
-void npy_set_floatstatus_divbyzero(void)
-{
-    fpsetsticky(FP_X_DZ);
-}
-
-void npy_set_floatstatus_overflow(void)
-{
-    fpsetsticky(FP_X_OFL);
-}
-
-void npy_set_floatstatus_underflow(void)
-{
-    fpsetsticky(FP_X_UFL);
-}
-
-void npy_set_floatstatus_invalid(void)
-{
-    fpsetsticky(FP_X_INV);
-}
-
-#elif defined(_AIX) && !defined(__GNUC__)
-#include 
-#include 
-
-int npy_get_floatstatus_barrier(char *param)
-{
-    int fpstatus = fp_read_flag();
-    /*
-     * By using a volatile, the compiler cannot reorder this call
-     */
-    if (param != NULL) {
-        volatile char NPY_UNUSED(c) = *(char*)param;
-    }
-    return ((FP_DIV_BY_ZERO & fpstatus) ? NPY_FPE_DIVIDEBYZERO : 0) |
-           ((FP_OVERFLOW & fpstatus) ? NPY_FPE_OVERFLOW : 0) |
-           ((FP_UNDERFLOW & fpstatus) ? NPY_FPE_UNDERFLOW : 0) |
-           ((FP_INVALID & fpstatus) ? NPY_FPE_INVALID : 0);
-}
-
-int npy_clear_floatstatus_barrier(char * param)
-{
-    int fpstatus = npy_get_floatstatus_barrier(param);
-    fp_swap_flag(0);
-
-    return fpstatus;
-}
-
-void npy_set_floatstatus_divbyzero(void)
-{
-    fp_raise_xcp(FP_DIV_BY_ZERO);
-}
-
-void npy_set_floatstatus_overflow(void)
-{
-    fp_raise_xcp(FP_OVERFLOW);
-}
-
-void npy_set_floatstatus_underflow(void)
-{
-    fp_raise_xcp(FP_UNDERFLOW);
-}
-
-void npy_set_floatstatus_invalid(void)
-{
-    fp_raise_xcp(FP_INVALID);
-}
-
-#elif defined(_MSC_VER) || (defined(__osf__) && defined(__alpha)) || \
-      defined (__UCLIBC__) || (defined(__arc__) && defined(__GLIBC__))
+#  include 
 
 /*
- * By using a volatile floating point value,
- * the compiler is forced to actually do the requested
- * operations because of potential concurrency.
- *
- * We shouldn't write multiple values to a single
- * global here, because that would cause
- * a race condition.
+ * According to the C99 standard FE_DIVBYZERO, etc. may not be provided when
+ * unsupported.  In such cases NumPy will not report these correctly, but we
+ * should still allow compiling (whether tests pass or not).
+ * By defining them as 0 locally, we make them no-ops.  Unlike these defines,
+ * for example `musl` still defines all of the functions (as no-ops):
+ *     https://git.musl-libc.org/cgit/musl/tree/src/fenv/fenv.c
+ * and does similar replacement in its tests:
+ * http://nsz.repo.hu/git/?p=libc-test;a=blob;f=src/common/mtest.h;h=706c1ba23ea8989b17a2f72ed1a919e187c06b6a;hb=HEAD#l30
  */
-static volatile double _npy_floatstatus_x,
-    _npy_floatstatus_zero = 0.0, _npy_floatstatus_big = 1e300,
-    _npy_floatstatus_small = 1e-300, _npy_floatstatus_inf;
-
-void npy_set_floatstatus_divbyzero(void)
-{
-    _npy_floatstatus_x = 1.0 / _npy_floatstatus_zero;
-}
-
-void npy_set_floatstatus_overflow(void)
-{
-    _npy_floatstatus_x = _npy_floatstatus_big * 1e300;
-}
-
-void npy_set_floatstatus_underflow(void)
-{
-    _npy_floatstatus_x = _npy_floatstatus_small * 1e-300;
-}
-
-void npy_set_floatstatus_invalid(void)
-{
-    _npy_floatstatus_inf = NPY_INFINITY;
-    _npy_floatstatus_x = _npy_floatstatus_inf - NPY_INFINITY;
-}
-
-/* MS Windows -----------------------------------------------------*/
-#if defined(_MSC_VER)
-
-#include 
-
-int npy_get_floatstatus_barrier(char *param)
-{
-    /*
-     * By using a volatile, the compiler cannot reorder this call
-     */
-#if defined(_WIN64)
-    int fpstatus = _statusfp();
-#else
-    /* windows enables sse on 32 bit, so check both flags */
-    int fpstatus, fpstatus2;
-    _statusfp2(&fpstatus, &fpstatus2);
-    fpstatus |= fpstatus2;
+#ifndef FE_DIVBYZERO
+    #define FE_DIVBYZERO 0
 #endif
-    if (param != NULL) {
-        volatile char NPY_UNUSED(c) = *(char*)param;
-    }
-    return ((SW_ZERODIVIDE & fpstatus) ? NPY_FPE_DIVIDEBYZERO : 0) |
-           ((SW_OVERFLOW & fpstatus) ? NPY_FPE_OVERFLOW : 0) |
-           ((SW_UNDERFLOW & fpstatus) ? NPY_FPE_UNDERFLOW : 0) |
-           ((SW_INVALID & fpstatus) ? NPY_FPE_INVALID : 0);
-}
-
-int npy_clear_floatstatus_barrier(char *param)
-{
-    int fpstatus = npy_get_floatstatus_barrier(param);
-    _clearfp();
-
-    return fpstatus;
-}
-
-/*  OSF/Alpha (Tru64)  ---------------------------------------------*/
-#elif defined(__osf__) && defined(__alpha)
-
-#include 
-
-int npy_get_floatstatus_barrier(char *param)
-{
-    unsigned long fpstatus = ieee_get_fp_control();
-    /*
-     * By using a volatile, the compiler cannot reorder this call
-     */
-    if (param != NULL) {
-        volatile char NPY_UNUSED(c) = *(char*)param;
-    }
-    return  ((IEEE_STATUS_DZE & fpstatus) ? NPY_FPE_DIVIDEBYZERO : 0) |
-            ((IEEE_STATUS_OVF & fpstatus) ? NPY_FPE_OVERFLOW : 0) |
-            ((IEEE_STATUS_UNF & fpstatus) ? NPY_FPE_UNDERFLOW : 0) |
-            ((IEEE_STATUS_INV & fpstatus) ? NPY_FPE_INVALID : 0);
-}
-
-int npy_clear_floatstatus_barrier(char *param)
-{
-    int fpstatus = npy_get_floatstatus_barrier(param);
-    /* clear status bits as well as disable exception mode if on */
-    ieee_set_fp_control(0);
-
-    return fpstatus;
-}
-
+#ifndef FE_OVERFLOW
+    #define FE_OVERFLOW 0
+#endif
+#ifndef FE_UNDERFLOW
+    #define FE_UNDERFLOW 0
+#endif
+#ifndef FE_INVALID
+    #define FE_INVALID 0
 #endif
-/* End of defined(_MSC_VER) || (defined(__osf__) && defined(__alpha)) */
 
-#else
-/* General GCC code, should work on most platforms */
-#  include 
 
 int npy_get_floatstatus_barrier(char* param)
 {
@@ -839,4 +437,3 @@ void npy_set_floatstatus_invalid(void)
     feraiseexcept(FE_INVALID);
 }
 
-#endif
diff --git a/numpy/core/src/npymath/ieee754.cpp b/numpy/core/src/npymath/ieee754.cpp
new file mode 100644
index 000000000000..ebc1dbeba725
--- /dev/null
+++ b/numpy/core/src/npymath/ieee754.cpp
@@ -0,0 +1,511 @@
+/* -*- c -*- */
+/*
+ * vim:syntax=c
+ *
+ * Low-level routines related to IEEE-754 format
+ */
+#include "numpy/utils.h"
+
+#include "npy_math_common.h"
+#include "npy_math_private.h"
+
+/*
+ The below code is provided for compilers which do not yet provide C11
+ compatibility (gcc 4.5 and older)
+ */
+#ifndef LDBL_TRUE_MIN
+#define LDBL_TRUE_MIN __LDBL_DENORM_MIN__
+#endif
+
+#if !defined(HAVE_DECL_SIGNBIT)
+#include "_signbit.c"
+
+int
+_npy_signbit_f(float x)
+{
+    return _npy_signbit_d((double)x);
+}
+
+int
+_npy_signbit_ld(long double x)
+{
+    return _npy_signbit_d((double)x);
+}
+#endif
+
+/*
+ * FIXME: There is a lot of redundancy between _next* and npy_nextafter*.
+ * refactor this at some point
+ *
+ * p >= 0, returnx x + nulp
+ * p < 0, returnx x - nulp
+ */
+static double
+_next(double x, int p)
+{
+    volatile double t;
+    npy_int32 hx, hy, ix;
+    npy_uint32 lx;
+
+    EXTRACT_WORDS(hx, lx, x);
+    ix = hx & 0x7fffffff; /* |x| */
+
+    if (((ix >= 0x7ff00000) && ((ix - 0x7ff00000) | lx) != 0)) /* x is nan */
+        return x;
+    if ((ix | lx) == 0) { /* x == 0 */
+        if (p >= 0) {
+            INSERT_WORDS(x, 0x0, 1); /* return +minsubnormal */
+        }
+        else {
+            INSERT_WORDS(x, 0x80000000, 1); /* return -minsubnormal */
+        }
+        t = x * x;
+        if (t == x)
+            return t;
+        else
+            return x; /* raise underflow flag */
+    }
+    if (p < 0) { /* x -= ulp */
+        if (lx == 0)
+            hx -= 1;
+        lx -= 1;
+    }
+    else { /* x += ulp */
+        lx += 1;
+        if (lx == 0)
+            hx += 1;
+    }
+    hy = hx & 0x7ff00000;
+    if (hy >= 0x7ff00000)
+        return x + x;      /* overflow  */
+    if (hy < 0x00100000) { /* underflow */
+        t = x * x;
+        if (t != x) { /* raise underflow flag */
+            INSERT_WORDS(x, hx, lx);
+            return x;
+        }
+    }
+    INSERT_WORDS(x, hx, lx);
+    return x;
+}
+
+static float
+_next(float x, int p)
+{
+    volatile float t;
+    npy_int32 hx, hy, ix;
+
+    GET_FLOAT_WORD(hx, x);
+    ix = hx & 0x7fffffff; /* |x| */
+
+    if ((ix > 0x7f800000)) /* x is nan */
+        return x;
+    if (ix == 0) { /* x == 0 */
+        if (p >= 0) {
+            SET_FLOAT_WORD(x, 0x0 | 1); /* return +minsubnormal */
+        }
+        else {
+            SET_FLOAT_WORD(x, 0x80000000 | 1); /* return -minsubnormal */
+        }
+        t = x * x;
+        if (t == x)
+            return t;
+        else
+            return x; /* raise underflow flag */
+    }
+    if (p < 0) { /* x -= ulp */
+        hx -= 1;
+    }
+    else { /* x += ulp */
+        hx += 1;
+    }
+    hy = hx & 0x7f800000;
+    if (hy >= 0x7f800000)
+        return x + x;      /* overflow  */
+    if (hy < 0x00800000) { /* underflow */
+        t = x * x;
+        if (t != x) { /* raise underflow flag */
+            SET_FLOAT_WORD(x, hx);
+            return x;
+        }
+    }
+    SET_FLOAT_WORD(x, hx);
+    return x;
+}
+
+#if defined(HAVE_LDOUBLE_DOUBLE_DOUBLE_BE) || \
+        defined(HAVE_LDOUBLE_DOUBLE_DOUBLE_LE)
+
+/*
+ * FIXME: this is ugly and untested. The asm part only works with gcc, and we
+ * should consolidate the GET_LDOUBLE* / SET_LDOUBLE macros
+ */
+#define math_opt_barrier(x)    \
+    ({                         \
+        __typeof(x) __x = x;   \
+        __asm("" : "+m"(__x)); \
+        __x;                   \
+    })
+#define math_force_eval(x) __asm __volatile("" : : "m"(x))
+
+/* only works for big endian */
+typedef union {
+    npy_longdouble value;
+    struct {
+        npy_uint64 msw;
+        npy_uint64 lsw;
+    } parts64;
+    struct {
+        npy_uint32 w0, w1, w2, w3;
+    } parts32;
+} ieee854_long_double_shape_type;
+
+/* Get two 64 bit ints from a long double.  */
+
+#define GET_LDOUBLE_WORDS64(ix0, ix1, d)     \
+    do {                                     \
+        ieee854_long_double_shape_type qw_u; \
+        qw_u.value = (d);                    \
+        (ix0) = qw_u.parts64.msw;            \
+        (ix1) = qw_u.parts64.lsw;            \
+    } while (0)
+
+/* Set a long double from two 64 bit ints.  */
+
+#define SET_LDOUBLE_WORDS64(d, ix0, ix1)     \
+    do {                                     \
+        ieee854_long_double_shape_type qw_u; \
+        qw_u.parts64.msw = (ix0);            \
+        qw_u.parts64.lsw = (ix1);            \
+        (d) = qw_u.value;                    \
+    } while (0)
+
+static long double
+_next(long double x, int p)
+{
+    npy_int64 hx, ihx, ilx;
+    npy_uint64 lx;
+    npy_longdouble u;
+    const npy_longdouble eps = exp2l(-105.); // 0x1.0000000000000p-105L
+
+    GET_LDOUBLE_WORDS64(hx, lx, x);
+    ihx = hx & 0x7fffffffffffffffLL; /* |hx| */
+    ilx = lx & 0x7fffffffffffffffLL; /* |lx| */
+
+    if (((ihx & 0x7ff0000000000000LL) == 0x7ff0000000000000LL) &&
+        ((ihx & 0x000fffffffffffffLL) != 0)) {
+        return x; /* signal the nan */
+    }
+    if (ihx == 0 && ilx == 0) {          /* x == 0 */
+        SET_LDOUBLE_WORDS64(x, p, 0ULL); /* return +-minsubnormal */
+        u = x * x;
+        if (u == x) {
+            return u;
+        }
+        else {
+            return x; /* raise underflow flag */
+        }
+    }
+
+    if (p < 0) { /* p < 0, x -= ulp */
+        if ((hx == 0xffefffffffffffffLL) && (lx == 0xfc8ffffffffffffeLL))
+            return x + x; /* overflow, return -inf */
+        if (hx >= 0x7ff0000000000000LL) {
+            SET_LDOUBLE_WORDS64(u, 0x7fefffffffffffffLL, 0x7c8ffffffffffffeLL);
+            return u;
+        }
+        if (ihx <= 0x0360000000000000LL) { /* x <= LDBL_MIN */
+            u = math_opt_barrier(x);
+            x -= LDBL_TRUE_MIN;
+            if (ihx < 0x0360000000000000LL || (hx > 0 && (npy_int64)lx <= 0) ||
+                (hx < 0 && (npy_int64)lx > 1)) {
+                u = u * u;
+                math_force_eval(u); /* raise underflow flag */
+            }
+            return x;
+        }
+        if (ihx < 0x06a0000000000000LL) { /* ulp will denormal */
+            SET_LDOUBLE_WORDS64(u, (hx & 0x7ff0000000000000LL), 0ULL);
+            u *= eps;
+        }
+        else
+            SET_LDOUBLE_WORDS64(
+                    u, (hx & 0x7ff0000000000000LL) - 0x0690000000000000LL,
+                    0ULL);
+        return x - u;
+    }
+    else { /* p >= 0, x += ulp */
+        if ((hx == 0x7fefffffffffffffLL) && (lx == 0x7c8ffffffffffffeLL))
+            return x + x; /* overflow, return +inf */
+        if ((npy_uint64)hx >= 0xfff0000000000000ULL) {
+            SET_LDOUBLE_WORDS64(u, 0xffefffffffffffffLL, 0xfc8ffffffffffffeLL);
+            return u;
+        }
+        if (ihx <= 0x0360000000000000LL) { /* x <= LDBL_MIN */
+            u = math_opt_barrier(x);
+            x += LDBL_TRUE_MIN;
+            if (ihx < 0x0360000000000000LL ||
+                (hx > 0 && (npy_int64)lx < 0 && lx != 0x8000000000000001LL) ||
+                (hx < 0 && (npy_int64)lx >= 0)) {
+                u = u * u;
+                math_force_eval(u); /* raise underflow flag */
+            }
+            if (x == 0.0L) /* handle negative LDBL_TRUE_MIN case */
+                x = -0.0L;
+            return x;
+        }
+        if (ihx < 0x06a0000000000000LL) { /* ulp will denormal */
+            SET_LDOUBLE_WORDS64(u, (hx & 0x7ff0000000000000LL), 0ULL);
+            u *= eps;
+        }
+        else
+            SET_LDOUBLE_WORDS64(
+                    u, (hx & 0x7ff0000000000000LL) - 0x0690000000000000LL,
+                    0ULL);
+        return x + u;
+    }
+}
+#else
+static long double
+_next(long double x, int p)
+{
+    volatile npy_longdouble t;
+    union IEEEl2bitsrep ux;
+
+    ux.e = x;
+
+    if ((GET_LDOUBLE_EXP(ux) == 0x7fff &&
+         ((GET_LDOUBLE_MANH(ux) & ~LDBL_NBIT) | GET_LDOUBLE_MANL(ux)) != 0)) {
+        return ux.e; /* x is nan */
+    }
+    if (ux.e == 0.0) {
+        SET_LDOUBLE_MANH(ux, 0); /* return +-minsubnormal */
+        SET_LDOUBLE_MANL(ux, 1);
+        if (p >= 0) {
+            SET_LDOUBLE_SIGN(ux, 0);
+        }
+        else {
+            SET_LDOUBLE_SIGN(ux, 1);
+        }
+        t = ux.e * ux.e;
+        if (t == ux.e) {
+            return t;
+        }
+        else {
+            return ux.e; /* raise underflow flag */
+        }
+    }
+    if (p < 0) { /* x -= ulp */
+        if (GET_LDOUBLE_MANL(ux) == 0) {
+            if ((GET_LDOUBLE_MANH(ux) & ~LDBL_NBIT) == 0) {
+                SET_LDOUBLE_EXP(ux, GET_LDOUBLE_EXP(ux) - 1);
+            }
+            SET_LDOUBLE_MANH(ux, (GET_LDOUBLE_MANH(ux) - 1) |
+                                         (GET_LDOUBLE_MANH(ux) & LDBL_NBIT));
+        }
+        SET_LDOUBLE_MANL(ux, GET_LDOUBLE_MANL(ux) - 1);
+    }
+    else { /* x += ulp */
+        SET_LDOUBLE_MANL(ux, GET_LDOUBLE_MANL(ux) + 1);
+        if (GET_LDOUBLE_MANL(ux) == 0) {
+            SET_LDOUBLE_MANH(ux, (GET_LDOUBLE_MANH(ux) + 1) |
+                                         (GET_LDOUBLE_MANH(ux) & LDBL_NBIT));
+            if ((GET_LDOUBLE_MANH(ux) & ~LDBL_NBIT) == 0) {
+                SET_LDOUBLE_EXP(ux, GET_LDOUBLE_EXP(ux) + 1);
+            }
+        }
+    }
+    if (GET_LDOUBLE_EXP(ux) == 0x7fff) {
+        return ux.e + ux.e; /* overflow  */
+    }
+    if (GET_LDOUBLE_EXP(ux) == 0) { /* underflow */
+        if (LDBL_NBIT) {
+            SET_LDOUBLE_MANH(ux, GET_LDOUBLE_MANH(ux) & ~LDBL_NBIT);
+        }
+        t = ux.e * ux.e;
+        if (t != ux.e) { /* raise underflow flag */
+            return ux.e;
+        }
+    }
+
+    return ux.e;
+}
+#endif
+
+namespace {
+template 
+struct numeric_limits;
+
+template <>
+struct numeric_limits {
+    static const npy_float nan;
+};
+const npy_float numeric_limits::nan = NPY_NANF;
+
+template <>
+struct numeric_limits {
+    static const npy_double nan;
+};
+const npy_double numeric_limits::nan = NPY_NAN;
+
+template <>
+struct numeric_limits {
+    static const npy_longdouble nan;
+};
+const npy_longdouble numeric_limits::nan = NPY_NANL;
+}  // namespace
+
+template 
+static type
+_npy_spacing(type x)
+{
+    /* XXX: npy isnan/isinf may be optimized by bit twiddling */
+    if (npy_isinf(x)) {
+        return numeric_limits::nan;
+    }
+
+    return _next(x, 1) - x;
+}
+
+/*
+ * Instantiation of C interface
+ */
+extern "C" {
+npy_float
+npy_spacingf(npy_float x)
+{
+    return _npy_spacing(x);
+}
+npy_double
+npy_spacing(npy_double x)
+{
+    return _npy_spacing(x);
+}
+npy_longdouble
+npy_spacingl(npy_longdouble x)
+{
+    return _npy_spacing(x);
+}
+}
+
+/*
+ * Decorate all the math functions which are available on the current platform
+ */
+
+extern "C" float
+npy_nextafterf(float x, float y)
+{
+    return nextafterf(x, y);
+}
+
+extern "C" double
+npy_nextafter(double x, double y)
+{
+    return nextafter(x, y);
+}
+
+extern "C" npy_longdouble
+npy_nextafterl(npy_longdouble x, npy_longdouble y)
+{
+    return nextafterl(x, y);
+}
+
+extern "C" int
+npy_clear_floatstatus()
+{
+    char x = 0;
+    return npy_clear_floatstatus_barrier(&x);
+}
+extern "C" int
+npy_get_floatstatus()
+{
+    char x = 0;
+    return npy_get_floatstatus_barrier(&x);
+}
+
+
+/* 
+ * General C99 code for floating point error handling.  These functions mainly
+ * exists, because `fenv.h` was not standardized in C89 so they gave better
+ * portability.  This should be unnecessary with C99/C++11 and further
+ * functionality can be used from `fenv.h` directly. 
+ */
+#include 
+
+/*
+ * According to the C99 standard FE_DIVBYZERO, etc. may not be provided when
+ * unsupported.  In such cases NumPy will not report these correctly, but we
+ * should still allow compiling (whether tests pass or not).
+ * By defining them as 0 locally, we make them no-ops.  Unlike these defines,
+ * for example `musl` still defines all of the functions (as no-ops):
+ *     https://git.musl-libc.org/cgit/musl/tree/src/fenv/fenv.c
+ * and does similar replacement in its tests:
+ * http://nsz.repo.hu/git/?p=libc-test;a=blob;f=src/common/mtest.h;h=706c1ba23ea8989b17a2f72ed1a919e187c06b6a;hb=HEAD#l30
+ */
+#ifndef FE_DIVBYZERO
+    #define FE_DIVBYZERO 0
+#endif
+#ifndef FE_OVERFLOW
+    #define FE_OVERFLOW 0
+#endif
+#ifndef FE_UNDERFLOW
+    #define FE_UNDERFLOW 0
+#endif
+#ifndef FE_INVALID
+    #define FE_INVALID 0
+#endif
+
+
+extern "C" int
+npy_get_floatstatus_barrier(char *param)
+{
+    int fpstatus = fetestexcept(FE_DIVBYZERO | FE_OVERFLOW | FE_UNDERFLOW |
+                                FE_INVALID);
+    /*
+     * By using a volatile, the compiler cannot reorder this call
+     */
+    if (param != NULL) {
+        volatile char NPY_UNUSED(c) = *(char *)param;
+    }
+
+    return ((FE_DIVBYZERO & fpstatus) ? NPY_FPE_DIVIDEBYZERO : 0) |
+           ((FE_OVERFLOW & fpstatus) ? NPY_FPE_OVERFLOW : 0) |
+           ((FE_UNDERFLOW & fpstatus) ? NPY_FPE_UNDERFLOW : 0) |
+           ((FE_INVALID & fpstatus) ? NPY_FPE_INVALID : 0);
+}
+
+extern "C" int
+npy_clear_floatstatus_barrier(char *param)
+{
+    /* testing float status is 50-100 times faster than clearing on x86 */
+    int fpstatus = npy_get_floatstatus_barrier(param);
+    if (fpstatus != 0) {
+        feclearexcept(FE_DIVBYZERO | FE_OVERFLOW | FE_UNDERFLOW | FE_INVALID);
+    }
+
+    return fpstatus;
+}
+
+extern "C" void
+npy_set_floatstatus_divbyzero(void)
+{
+    feraiseexcept(FE_DIVBYZERO);
+}
+
+extern "C" void
+npy_set_floatstatus_overflow(void)
+{
+    feraiseexcept(FE_OVERFLOW);
+}
+
+extern "C" void
+npy_set_floatstatus_underflow(void)
+{
+    feraiseexcept(FE_UNDERFLOW);
+}
+
+extern "C" void
+npy_set_floatstatus_invalid(void)
+{
+    feraiseexcept(FE_INVALID);
+}
diff --git a/numpy/core/src/npymath/npy_math_complex.c.src b/numpy/core/src/npymath/npy_math_complex.c.src
index 8c432e483982..fff541ee53af 100644
--- a/numpy/core/src/npymath/npy_math_complex.c.src
+++ b/numpy/core/src/npymath/npy_math_complex.c.src
@@ -158,9 +158,7 @@ npy_carg@c@(@ctype@ z)
 #define SCALED_CEXP_LOWERL 11357.216553474703895L
 #define SCALED_CEXP_UPPERL 22756.021937783004509L
 
-#if !defined(HAVE_CSINH@C@) || \
-    !defined(HAVE_CCOSH@C@) || \
-    !defined(HAVE_CEXP@C@)
+#if !defined(HAVE_CEXP@C@)
 
 static
 @ctype@
@@ -1696,7 +1694,7 @@ npy_catanh@c@(@ctype@ z)
     if (ax < SQRT_3_EPSILON / 2 && ay < SQRT_3_EPSILON / 2) {
         /*
          * z = 0 was filtered out above.  All other cases must raise
-         * inexact, but this is the only only that needs to do it
+         * inexact, but this is the only one that needs to do it
          * explicitly.
          */
         raise_inexact();
diff --git a/numpy/core/src/npymath/npy_math_internal.h.src b/numpy/core/src/npymath/npy_math_internal.h.src
index 5b418342f25e..c7df5e255ca1 100644
--- a/numpy/core/src/npymath/npy_math_internal.h.src
+++ b/numpy/core/src/npymath/npy_math_internal.h.src
@@ -54,6 +54,9 @@
  * ====================================================
  */
 #include "npy_math_private.h"
+#ifdef _MSC_VER
+#  include    // for __popcnt
+#endif
 
 /* Magic binary numbers used by bit_count
  * For type T, the magic numbers are computed as follows:
@@ -80,49 +83,50 @@ static const npy_uint64 MAGIC64[] = {0x5555555555555555ull, 0x3333333333333333ul
 
 /*
  *****************************************************************************
- **                     BASIC MATH FUNCTIONS                                **
+ **                    BLOCKLIST-ABLE BASIC MATH FUNCTIONS                  **
  *****************************************************************************
  */
 
+/* The following functions can be blocked, even for doubles */
+
 /* Original code by Konrad Hinsen.  */
-#ifndef HAVE_EXPM1
-NPY_INPLACE double npy_expm1(double x)
+/* Taken from FreeBSD mlib, adapted for numpy
+ *
+ * XXX: we could be a bit faster by reusing high/low words for inf/nan
+ * classification instead of calling npy_isinf/npy_isnan: we should have some
+ * macros for this, though, instead of doing it manually
+ */
+NPY_INPLACE double npy_log2(double x)
 {
-    if (npy_isinf(x) && x > 0) {
-        return x;
+#ifndef NPY_BLOCK_LOG2
+    return log2(x);
+#else
+    if (!npy_isfinite(x) || x <= 0.) {
+        /* special value result */
+        return npy_log(x);
     }
     else {
-        const double u = npy_exp(x);
-
-        if (u == 1.0) {
-            return x;
-        } else if (u - 1.0 == -1.0) {
-            return -1;
-        } else {
-            return (u - 1.0) * x/npy_log(u);
+        /*
+         * fallback implementation copied from python3.4 math.log2
+         * provides int(log(2**i)) == i for i 1-64 in default rounding mode.
+         *
+         * We want log2(m * 2**e) == log(m) / log(2) + e.  Care is needed when
+         * x is just greater than 1.0: in that case e is 1, log(m) is negative,
+         * and we get significant cancellation error from the addition of
+         * log(m) / log(2) to e.  The slight rewrite of the expression below
+         * avoids this problem.
+         */
+        int e;
+        double m = frexp(x, &e);
+        if (x >= 1.0) {
+            return log(2.0 * m) / log(2.0) + (e - 1);
         }
-    }
-}
-#endif
-
-#ifndef HAVE_LOG1P
-NPY_INPLACE double npy_log1p(double x)
-{
-    if (npy_isinf(x) && x > 0) {
-        return x;
-    }
-    else {
-        const double u = 1. + x;
-        const double d = u - 1.;
-
-        if (d == 0) {
-            return x;
-        } else {
-            return npy_log(u) * x / d;
+        else {
+            return log(m) / log(2.0) + e;
         }
     }
-}
 #endif
+}
 
 /* Taken from FreeBSD mlib, adapted for numpy
  *
@@ -130,11 +134,13 @@ NPY_INPLACE double npy_log1p(double x)
  * classification instead of calling npy_isinf/npy_isnan: we should have some
  * macros for this, though, instead of doing it manually
  */
-#ifndef HAVE_ATAN2
 /* XXX: we should have this in npy_math.h */
 #define NPY_DBL_EPSILON 1.2246467991473531772E-16
 NPY_INPLACE double npy_atan2(double y, double x)
 {
+#ifndef NPY_BLOCK_ATAN2
+    return atan2(y, x);
+#else
     npy_int32 k, m, iy, ix, hx, hy;
     npy_uint32 lx,ly;
     double z;
@@ -207,13 +213,18 @@ NPY_INPLACE double npy_atan2(double y, double x)
         default: /* case 3 */
             return  (z - NPY_DBL_EPSILON) - NPY_PI;/* atan(-,-) */
     }
+#endif
 }
 
-#endif
 
-#ifndef HAVE_HYPOT
+
+
+
 NPY_INPLACE double npy_hypot(double x, double y)
 {
+#ifndef NPY_BLOCK_HYPOT
+    return hypot(x, y);
+#else
     double yx;
 
     if (npy_isinf(x) || npy_isinf(y)) {
@@ -238,144 +249,10 @@ NPY_INPLACE double npy_hypot(double x, double y)
         yx = y/x;
         return x*npy_sqrt(1.+yx*yx);
     }
-}
-#endif
-
-#ifndef HAVE_ACOSH
-NPY_INPLACE double npy_acosh(double x)
-{
-    if (x < 1.0) {
-        return NPY_NAN;
-    }
-
-    if (npy_isfinite(x)) {
-        if (x > 1e8) {
-             return npy_log(x) + NPY_LOGE2;
-        }
-        else {
-            double u = x - 1.0;
-            return npy_log1p(u + npy_sqrt(2*u + u*u));
-        }
-    }
-    return x;
-}
-#endif
-
-#ifndef HAVE_ASINH
-NPY_INPLACE double npy_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 = npy_sqrt(x*x + 1);
-    }
-    return sign*npy_log1p(x*(1.0 + x/(d+1)));
-}
-#endif
-
-#ifndef HAVE_ATANH
-NPY_INPLACE double npy_atanh(double x)
-{
-    if (x > 0) {
-        return -0.5*npy_log1p(-2.0*x/(1.0 + x));
-    }
-    else {
-        return 0.5*npy_log1p(2.0*x/(1.0 - x));
-    }
-}
-#endif
-
-#ifndef HAVE_RINT
-#if defined(_MSC_VER) && (_MSC_VER == 1500) && !defined(_WIN64)
-#pragma optimize("", off)
-#endif
-NPY_INPLACE double npy_rint(double x)
-{
-    double y, r;
-
-    y = npy_floor(x);
-    r = x - y;
-
-    if (r > 0.5) {
-        y += 1.0;
-    }
-
-    /* Round to nearest even */
-    if (r == 0.5) {
-        r = y - 2.0*npy_floor(0.5*y);
-        if (r == 1.0) {
-            y += 1.0;
-        }
-    }
-    return y;
-}
-#if defined(_MSC_VER) && (_MSC_VER == 1500) && !defined(_WIN64)
-#pragma optimize("", on)
-#endif
-#endif
-
-#ifndef HAVE_TRUNC
-NPY_INPLACE double npy_trunc(double x)
-{
-    return x < 0 ? npy_ceil(x) : npy_floor(x);
-}
 #endif
-
-#ifndef HAVE_EXP2
-NPY_INPLACE double npy_exp2(double x)
-{
-    return npy_exp(NPY_LOGE2*x);
 }
-#endif
-
-#ifndef HAVE_LOG2
-NPY_INPLACE double npy_log2(double x)
-{
-#ifdef HAVE_FREXP
-    if (!npy_isfinite(x) || x <= 0.) {
-        /* special value result */
-        return npy_log(x);
-    }
-    else {
-        /*
-         * fallback implementation copied from python3.4 math.log2
-         * provides int(log(2**i)) == i for i 1-64 in default rounding mode.
-         *
-         * We want log2(m * 2**e) == log(m) / log(2) + e.  Care is needed when
-         * x is just greater than 1.0: in that case e is 1, log(m) is negative,
-         * and we get significant cancellation error from the addition of
-         * log(m) / log(2) to e.  The slight rewrite of the expression below
-         * avoids this problem.
-         */
-        int e;
-        double m = frexp(x, &e);
-        if (x >= 1.0) {
-            return log(2.0 * m) / log(2.0) + (e - 1);
-        }
-        else {
-            return log(m) / log(2.0) + e;
-        }
-    }
-#else
-    /* does not provide int(log(2**i)) == i */
-    return NPY_LOG2E * npy_log(x);
-#endif
-}
-#endif
 
 /*
- * if C99 extensions not available then define dummy functions that use the
- * double versions for
  *
  * sin, cos, tan
  * sinh, cosh, tanh,
@@ -385,7 +262,7 @@ NPY_INPLACE double npy_log2(double x)
  * asinh, acosh, atanh
  *
  * hypot, atan2, pow, fmod, modf
- * ldexp, frexp
+ * ldexp, frexp, cbrt
  *
  * We assume the above are always available in their double versions.
  *
@@ -394,82 +271,6 @@ NPY_INPLACE double npy_log2(double x)
  * instead test for the macro, but I am lazy to do that for now.
  */
 
-/**begin repeat
- * #type = npy_longdouble, npy_float#
- * #TYPE = NPY_LONGDOUBLE, FLOAT#
- * #c = l,f#
- * #C = L,F#
- */
-
-/**begin repeat1
- * #kind = sin,cos,tan,sinh,cosh,tanh,fabs,floor,ceil,rint,trunc,sqrt,log10,
- *         log,exp,expm1,asin,acos,atan,asinh,acosh,atanh,log1p,exp2,log2#
- * #KIND = SIN,COS,TAN,SINH,COSH,TANH,FABS,FLOOR,CEIL,RINT,TRUNC,SQRT,LOG10,
- *         LOG,EXP,EXPM1,ASIN,ACOS,ATAN,ASINH,ACOSH,ATANH,LOG1P,EXP2,LOG2#
- */
-
-#ifdef @kind@@c@
-#undef @kind@@c@
-#endif
-#ifndef HAVE_@KIND@@C@
-NPY_INPLACE @type@ npy_@kind@@c@(@type@ x)
-{
-    return (@type@) npy_@kind@((double)x);
-}
-#endif
-
-/**end repeat1**/
-
-/**begin repeat1
- * #kind = atan2,hypot,pow,fmod,copysign#
- * #KIND = ATAN2,HYPOT,POW,FMOD,COPYSIGN#
- */
-#ifdef @kind@@c@
-#undef @kind@@c@
-#endif
-#ifndef HAVE_@KIND@@C@
-NPY_INPLACE @type@ npy_@kind@@c@(@type@ x, @type@ y)
-{
-    return (@type@) npy_@kind@((double)x, (double) y);
-}
-#endif
-/**end repeat1**/
-
-#ifdef modf@c@
-#undef modf@c@
-#endif
-#ifndef HAVE_MODF@C@
-NPY_INPLACE @type@ npy_modf@c@(@type@ x, @type@ *iptr)
-{
-    double niptr;
-    double y = npy_modf((double)x, &niptr);
-    *iptr = (@type@) niptr;
-    return (@type@) y;
-}
-#endif
-
-#ifdef ldexp@c@
-#undef ldexp@c@
-#endif
-#ifndef HAVE_LDEXP@C@
-NPY_INPLACE @type@ npy_ldexp@c@(@type@ x, int exp)
-{
-    return (@type@) npy_ldexp((double)x, exp);
-}
-#endif
-
-#ifdef frexp@c@
-#undef frexp@c@
-#endif
-#ifndef HAVE_FREXP@C@
-NPY_INPLACE @type@ npy_frexp@c@(@type@ x, int* exp)
-{
-    return (@type@) npy_frexp(x, exp);
-}
-#endif
-
-/**end repeat**/
-
 
 /*
  * Decorate all the math functions which are available on the current platform
@@ -498,13 +299,9 @@ NPY_INPLACE @type@ npy_frexp@c@(@type@ x, int* exp)
 #endif
 
 /**begin repeat1
- * #kind = sin,cos,tan,sinh,cosh,tanh,fabs,floor,ceil,rint,trunc,sqrt,log10,
- *         log,exp,expm1,asin,acos,atan,asinh,acosh,atanh,log1p,exp2,log2#
- * #KIND = SIN,COS,TAN,SINH,COSH,TANH,FABS,FLOOR,CEIL,RINT,TRUNC,SQRT,LOG10,
- *         LOG,EXP,EXPM1,ASIN,ACOS,ATAN,ASINH,ACOSH,ATANH,LOG1P,EXP2,LOG2#
- * #TRIG_WORKAROUND = WORKAROUND_APPLE_TRIG_BUG*3, 0*22#
+ * #kind = sin,cos,tan#
+ * #TRIG_WORKAROUND = WORKAROUND_APPLE_TRIG_BUG*3#
  */
-#ifdef HAVE_@KIND@@C@
 NPY_INPLACE @type@ npy_@kind@@c@(@type@ x)
 {
 #if @TRIG_WORKAROUND@
@@ -514,71 +311,102 @@ NPY_INPLACE @type@ npy_@kind@@c@(@type@ x)
 #endif
     return NPY__FP_SFX(@kind@)(x);
 }
-#endif
 
 /**end repeat1**/
 
 #undef WORKAROUND_APPLE_TRIG_BUG
 
+/**end repeat**/
+
+/* Blocklist-able C99 functions */
+
+/**begin repeat
+ * #type = npy_float,npy_longdouble#
+ * #TYPE = FLOAT,LONGDOUBLE#
+ * #c = f,l#
+ * #C = F,L#
+ */
+#undef NPY__FP_SFX
+#if NPY_SIZEOF_@TYPE@ == NPY_SIZEOF_DOUBLE
+    #define NPY__FP_SFX(X) X
+#else
+    #define NPY__FP_SFX(X) NPY_CAT(X, @c@)
+#endif
+
 /**begin repeat1
- * #kind = atan2,hypot,pow,fmod,copysign#
- * #KIND = ATAN2,HYPOT,POW,FMOD,COPYSIGN#
+ * #kind = exp,log2,sqrt#
+ * #KIND = EXP,LOG2,SQRT#
  */
-#ifdef HAVE_@KIND@@C@
-NPY_INPLACE @type@ npy_@kind@@c@(@type@ x, @type@ y)
+
+#ifdef @kind@@c@
+#undef @kind@@c@
+#endif
+#ifdef NPY_BLOCK_@KIND@@C@
+NPY_INPLACE @type@ npy_@kind@@c@(@type@ x)
 {
-    return NPY__FP_SFX(@kind@)(x, y);
+    return (@type@) npy_@kind@((double)x);
 }
 #endif
-/**end repeat1**/
 
-#ifdef HAVE_MODF@C@
-NPY_INPLACE @type@ npy_modf@c@(@type@ x, @type@ *iptr)
+#ifndef NPY_BLOCK_@KIND@@C@
+NPY_INPLACE @type@ npy_@kind@@c@(@type@ x)
 {
-    return NPY__FP_SFX(modf)(x, iptr);
+    return NPY__FP_SFX(@kind@)(x);
 }
 #endif
 
-#ifdef HAVE_LDEXP@C@
-NPY_INPLACE @type@ npy_ldexp@c@(@type@ x, int exp)
+/**end repeat1**/
+
+
+/**begin repeat1
+ * #kind = atan2,hypot,pow#
+ * #KIND = ATAN2,HYPOT,POW#
+ */
+#ifdef @kind@@c@
+#undef @kind@@c@
+#endif
+#ifdef NPY_BLOCK_@KIND@@C@
+NPY_INPLACE @type@ npy_@kind@@c@(@type@ x, @type@ y)
 {
-    return NPY__FP_SFX(ldexp)(x, exp);
+    return (@type@) npy_@kind@((double)x, (double) y);
 }
 #endif
 
-#ifdef HAVE_FREXP@C@
-NPY_INPLACE @type@ npy_frexp@c@(@type@ x, int* exp)
+#ifndef NPY_BLOCK_@KIND@@C@
+NPY_INPLACE @type@ npy_@kind@@c@(@type@ x, @type@ y)
 {
-    return NPY__FP_SFX(frexp)(x, exp);
+    return NPY__FP_SFX(@kind@)(x, y);
 }
 #endif
+/**end repeat1**/
 
-/* C99 but not mandatory */
-
-#ifndef HAVE_CBRT@C@
-NPY_INPLACE @type@ npy_cbrt@c@(@type@ x)
+#ifdef modf@c@
+#undef modf@c@
+#endif
+#ifdef NPY_BLOCK_MODF@C@
+NPY_INPLACE @type@ npy_modf@c@(@type@ x, @type@ *iptr)
 {
-    /* don't set invalid flag */
-    if (npy_isnan(x)) {
-        return NPY_NAN;
-    }
-    else if (x < 0) {
-        return -npy_pow@c@(-x, 1. / 3.);
-    }
-    else {
-        return npy_pow@c@(x, 1. / 3.);
-    }
+    double niptr;
+    double y = npy_modf((double)x, &niptr);
+    *iptr = (@type@) niptr;
+    return (@type@) y;
 }
-#else
-NPY_INPLACE @type@ npy_cbrt@c@(@type@ x)
+#endif
+
+#ifndef NPY_BLOCK_MODF@C@
+NPY_INPLACE @type@ npy_modf@c@(@type@ x, @type@ *iptr)
 {
-    return NPY__FP_SFX(cbrt)(x);
+    return NPY__FP_SFX(modf)(x, iptr);
 }
 #endif
-#undef NPY__FP_SFX
+
+
 /**end repeat**/
 
 
+#undef NPY__FP_SFX
+
+
 /*
  * Non standard functions
  */
@@ -739,7 +567,7 @@ npy_divmod@c@(@type@ a, @type@ b, @type@ *modulus)
 
     /* adjust fmod result to conform to Python convention of remainder */
     if (mod) {
-        if (isless(b, 0) != isless(mod, 0)) {
+        if (isless(b, (@type@)0) != isless(mod, (@type@)0)) {
             mod += b;
             div -= 1.0@c@;
         }
@@ -884,7 +712,7 @@ npy_popcountu@c@(npy_@type@ a)
 /* use built-in popcount if present, else use our implementation */
 #if (defined(__clang__) || defined(__GNUC__)) && NPY_BITSOF_@STYPE@ >= 32
     return __builtin_popcount@c@(a);
-#elif defined(_MSC_VER) && NPY_BITSOF_@STYPE@ >= 16
+#elif defined(_MSC_VER) && NPY_BITSOF_@STYPE@ >= 16 && !defined(_M_ARM64) && !defined(_M_ARM)
     /* no builtin __popcnt64 for 32 bits */
     #if defined(_WIN64) || (defined(_WIN32) && NPY_BITSOF_@STYPE@ != 64)
         return TO_BITS_LEN(__popcnt)(a);
@@ -912,3 +740,4 @@ npy_popcount@c@(npy_@type@ a)
     return npy_popcountu@c@(a < 0 ? -a : a);
 }
 /**end repeat**/
+
diff --git a/numpy/core/src/npymath/npy_math_private.h b/numpy/core/src/npymath/npy_math_private.h
index 7ca0c5ba0f83..a474b3de3864 100644
--- a/numpy/core/src/npymath/npy_math_private.h
+++ b/numpy/core/src/npymath/npy_math_private.h
@@ -514,7 +514,7 @@ typedef union {
 typedef union {
         npy_cdouble npy_z;
 #ifdef __cplusplus
-        std::complex c99z;
+        std::complex c99_z;
 #else
         complex double c99_z;
 #endif
@@ -523,7 +523,7 @@ typedef union {
 typedef union {
         npy_cfloat npy_z;
 #ifdef __cplusplus
-        std::complex c99z;
+        std::complex c99_z;
 #else
         complex float c99_z;
 #endif
diff --git a/numpy/core/src/npysort/binsearch.c.src b/numpy/core/src/npysort/binsearch.c.src
deleted file mode 100644
index 41165897b4cf..000000000000
--- a/numpy/core/src/npysort/binsearch.c.src
+++ /dev/null
@@ -1,250 +0,0 @@
-/* -*- c -*- */
-#define NPY_NO_DEPRECATED_API NPY_API_VERSION
-
-#include "npy_sort.h"
-#include "npysort_common.h"
-#include "npy_binsearch.h"
-
-#define NOT_USED NPY_UNUSED(unused)
-
-/*
- *****************************************************************************
- **                            NUMERIC SEARCHES                             **
- *****************************************************************************
- */
-
-/**begin repeat
- *
- * #TYPE = BOOL, BYTE, UBYTE, SHORT, USHORT, INT, UINT, LONG, ULONG,
- *         LONGLONG, ULONGLONG, HALF, FLOAT, DOUBLE, LONGDOUBLE,
- *         CFLOAT, CDOUBLE, CLONGDOUBLE, DATETIME, TIMEDELTA#
- * #suff = bool, byte, ubyte, short, ushort, int, uint, long, ulong,
- *         longlong, ulonglong, half, float, double, longdouble,
- *         cfloat, cdouble, clongdouble, datetime, timedelta#
- * #type = npy_bool, npy_byte, npy_ubyte, npy_short, npy_ushort, npy_int,
- *         npy_uint, npy_long, npy_ulong, npy_longlong, npy_ulonglong,
- *         npy_ushort, npy_float, npy_double, npy_longdouble, npy_cfloat,
- *         npy_cdouble, npy_clongdouble, npy_datetime, npy_timedelta#
- */
-
-#define @TYPE@_LTE(a, b) (!@TYPE@_LT((b), (a)))
-
-/**begin repeat1
- *
- * #side = left, right#
- * #CMP  = LT, LTE#
- */
-
-NPY_NO_EXPORT void
-binsearch_@side@_@suff@(const char *arr, const char *key, char *ret,
-                        npy_intp arr_len, npy_intp key_len,
-                        npy_intp arr_str, npy_intp key_str, npy_intp ret_str,
-                        PyArrayObject *NOT_USED)
-{
-    npy_intp min_idx = 0;
-    npy_intp max_idx = arr_len;
-    @type@ last_key_val;
-
-    if (key_len == 0) {
-        return;
-    }
-    last_key_val = *(const @type@ *)key;
-
-    for (; key_len > 0; key_len--, key += key_str, ret += ret_str) {
-        const @type@ key_val = *(const @type@ *)key;
-        /*
-         * Updating only one of the indices based on the previous key
-         * gives the search a big boost when keys are sorted, but slightly
-         * slows down things for purely random ones.
-         */
-        if (@TYPE@_LT(last_key_val, key_val)) {
-            max_idx = arr_len;
-        }
-        else {
-            min_idx = 0;
-            max_idx = (max_idx < arr_len) ? (max_idx + 1) : arr_len;
-        }
-
-        last_key_val = key_val;
-
-        while (min_idx < max_idx) {
-            const npy_intp mid_idx = min_idx + ((max_idx - min_idx) >> 1);
-            const @type@ mid_val = *(const @type@ *)(arr + mid_idx*arr_str);
-            if (@TYPE@_@CMP@(mid_val, key_val)) {
-                min_idx = mid_idx + 1;
-            }
-            else {
-                max_idx = mid_idx;
-            }
-        }
-        *(npy_intp *)ret = min_idx;
-    }
-}
-
-NPY_NO_EXPORT int
-argbinsearch_@side@_@suff@(const char *arr, const char *key,
-                           const char *sort, char *ret,
-                           npy_intp arr_len, npy_intp key_len,
-                           npy_intp arr_str, npy_intp key_str,
-                           npy_intp sort_str, npy_intp ret_str,
-                           PyArrayObject *NOT_USED)
-{
-    npy_intp min_idx = 0;
-    npy_intp max_idx = arr_len;
-    @type@ last_key_val;
-
-    if (key_len == 0) {
-        return 0;
-    }
-    last_key_val = *(const @type@ *)key;
-
-    for (; key_len > 0; key_len--, key += key_str, ret += ret_str) {
-        const @type@ key_val = *(const @type@ *)key;
-        /*
-         * Updating only one of the indices based on the previous key
-         * gives the search a big boost when keys are sorted, but slightly
-         * slows down things for purely random ones.
-         */
-        if (@TYPE@_LT(last_key_val, key_val)) {
-            max_idx = arr_len;
-        }
-        else {
-            min_idx = 0;
-            max_idx = (max_idx < arr_len) ? (max_idx + 1) : arr_len;
-        }
-
-        last_key_val = key_val;
-
-        while (min_idx < max_idx) {
-            const npy_intp mid_idx = min_idx + ((max_idx - min_idx) >> 1);
-            const npy_intp sort_idx = *(npy_intp *)(sort + mid_idx*sort_str);
-            @type@ mid_val;
-
-            if (sort_idx < 0 || sort_idx >= arr_len) {
-                return -1;
-            }
-
-            mid_val = *(const @type@ *)(arr + sort_idx*arr_str);
-
-            if (@TYPE@_@CMP@(mid_val, key_val)) {
-                min_idx = mid_idx + 1;
-            }
-            else {
-                max_idx = mid_idx;
-            }
-        }
-        *(npy_intp *)ret = min_idx;
-    }
-    return 0;
-}
-
-/**end repeat1**/
-/**end repeat**/
-
-/*
- *****************************************************************************
- **                             GENERIC SEARCH                              **
- *****************************************************************************
- */
-
- /**begin repeat
- *
- * #side = left, right#
- * #CMP  = <, <=#
- */
-
-NPY_NO_EXPORT void
-npy_binsearch_@side@(const char *arr, const char *key, char *ret,
-                     npy_intp arr_len, npy_intp key_len,
-                     npy_intp arr_str, npy_intp key_str, npy_intp ret_str,
-                     PyArrayObject *cmp)
-{
-    PyArray_CompareFunc *compare = PyArray_DESCR(cmp)->f->compare;
-    npy_intp min_idx = 0;
-    npy_intp max_idx = arr_len;
-    const char *last_key = key;
-
-    for (; key_len > 0; key_len--, key += key_str, ret += ret_str) {
-        /*
-         * Updating only one of the indices based on the previous key
-         * gives the search a big boost when keys are sorted, but slightly
-         * slows down things for purely random ones.
-         */
-        if (compare(last_key, key, cmp) @CMP@ 0) {
-            max_idx = arr_len;
-        }
-        else {
-            min_idx = 0;
-            max_idx = (max_idx < arr_len) ? (max_idx + 1) : arr_len;
-        }
-
-        last_key = key;
-
-        while (min_idx < max_idx) {
-            const npy_intp mid_idx = min_idx + ((max_idx - min_idx) >> 1);
-            const char *arr_ptr = arr + mid_idx*arr_str;
-
-            if (compare(arr_ptr, key, cmp) @CMP@ 0) {
-                min_idx = mid_idx + 1;
-            }
-            else {
-                max_idx = mid_idx;
-            }
-        }
-        *(npy_intp *)ret = min_idx;
-    }
-}
-
-NPY_NO_EXPORT int
-npy_argbinsearch_@side@(const char *arr, const char *key,
-                        const char *sort, char *ret,
-                        npy_intp arr_len, npy_intp key_len,
-                        npy_intp arr_str, npy_intp key_str,
-                        npy_intp sort_str, npy_intp ret_str,
-                        PyArrayObject *cmp)
-{
-    PyArray_CompareFunc *compare = PyArray_DESCR(cmp)->f->compare;
-    npy_intp min_idx = 0;
-    npy_intp max_idx = arr_len;
-    const char *last_key = key;
-
-    for (; key_len > 0; key_len--, key += key_str, ret += ret_str) {
-        /*
-         * Updating only one of the indices based on the previous key
-         * gives the search a big boost when keys are sorted, but slightly
-         * slows down things for purely random ones.
-         */
-        if (compare(last_key, key, cmp) @CMP@ 0) {
-            max_idx = arr_len;
-        }
-        else {
-            min_idx = 0;
-            max_idx = (max_idx < arr_len) ? (max_idx + 1) : arr_len;
-        }
-
-        last_key = key;
-
-        while (min_idx < max_idx) {
-            const npy_intp mid_idx = min_idx + ((max_idx - min_idx) >> 1);
-            const npy_intp sort_idx = *(npy_intp *)(sort + mid_idx*sort_str);
-            const char *arr_ptr;
-
-            if (sort_idx < 0 || sort_idx >= arr_len) {
-                return -1;
-            }
-
-            arr_ptr = arr + sort_idx*arr_str;
-
-            if (compare(arr_ptr, key, cmp) @CMP@ 0) {
-                min_idx = mid_idx + 1;
-            }
-            else {
-                max_idx = mid_idx;
-            }
-        }
-        *(npy_intp *)ret = min_idx;
-    }
-    return 0;
-}
-
-/**end repeat**/
diff --git a/numpy/core/src/npysort/binsearch.cpp b/numpy/core/src/npysort/binsearch.cpp
new file mode 100644
index 000000000000..ea07bbb0cd75
--- /dev/null
+++ b/numpy/core/src/npysort/binsearch.cpp
@@ -0,0 +1,403 @@
+/* -*- c -*- */
+
+#define NPY_NO_DEPRECATED_API NPY_API_VERSION
+
+#include "numpy/ndarraytypes.h"
+#include "numpy/npy_common.h"
+
+#include "npy_binsearch.h"
+#include "npy_sort.h"
+#include "numpy_tag.h"
+
+#include 
+#include   // for std::less and std::less_equal
+
+// Enumerators for the variant of binsearch
+enum arg_t
+{
+    noarg,
+    arg
+};
+enum side_t
+{
+    left,
+    right
+};
+
+// Mapping from enumerators to comparators
+template 
+struct side_to_cmp;
+
+template 
+struct side_to_cmp {
+    static constexpr auto value = Tag::less;
+};
+
+template 
+struct side_to_cmp {
+    static constexpr auto value = Tag::less_equal;
+};
+
+template 
+struct side_to_generic_cmp;
+
+template <>
+struct side_to_generic_cmp {
+    using type = std::less;
+};
+
+template <>
+struct side_to_generic_cmp {
+    using type = std::less_equal;
+};
+
+/*
+ *****************************************************************************
+ **                            NUMERIC SEARCHES                             **
+ *****************************************************************************
+ */
+template 
+static void
+binsearch(const char *arr, const char *key, char *ret, npy_intp arr_len,
+          npy_intp key_len, npy_intp arr_str, npy_intp key_str,
+          npy_intp ret_str, PyArrayObject *)
+{
+    using T = typename Tag::type;
+    auto cmp = side_to_cmp::value;
+    npy_intp min_idx = 0;
+    npy_intp max_idx = arr_len;
+    T last_key_val;
+
+    if (key_len == 0) {
+        return;
+    }
+    last_key_val = *(const T *)key;
+
+    for (; key_len > 0; key_len--, key += key_str, ret += ret_str) {
+        const T key_val = *(const T *)key;
+        /*
+         * Updating only one of the indices based on the previous key
+         * gives the search a big boost when keys are sorted, but slightly
+         * slows down things for purely random ones.
+         */
+        if (cmp(last_key_val, key_val)) {
+            max_idx = arr_len;
+        }
+        else {
+            min_idx = 0;
+            max_idx = (max_idx < arr_len) ? (max_idx + 1) : arr_len;
+        }
+
+        last_key_val = key_val;
+
+        while (min_idx < max_idx) {
+            const npy_intp mid_idx = min_idx + ((max_idx - min_idx) >> 1);
+            const T mid_val = *(const T *)(arr + mid_idx * arr_str);
+            if (cmp(mid_val, key_val)) {
+                min_idx = mid_idx + 1;
+            }
+            else {
+                max_idx = mid_idx;
+            }
+        }
+        *(npy_intp *)ret = min_idx;
+    }
+}
+
+template 
+static int
+argbinsearch(const char *arr, const char *key, const char *sort, char *ret,
+             npy_intp arr_len, npy_intp key_len, npy_intp arr_str,
+             npy_intp key_str, npy_intp sort_str, npy_intp ret_str,
+             PyArrayObject *)
+{
+    using T = typename Tag::type;
+    auto cmp = side_to_cmp::value;
+    npy_intp min_idx = 0;
+    npy_intp max_idx = arr_len;
+    T last_key_val;
+
+    if (key_len == 0) {
+        return 0;
+    }
+    last_key_val = *(const T *)key;
+
+    for (; key_len > 0; key_len--, key += key_str, ret += ret_str) {
+        const T key_val = *(const T *)key;
+        /*
+         * Updating only one of the indices based on the previous key
+         * gives the search a big boost when keys are sorted, but slightly
+         * slows down things for purely random ones.
+         */
+        if (cmp(last_key_val, key_val)) {
+            max_idx = arr_len;
+        }
+        else {
+            min_idx = 0;
+            max_idx = (max_idx < arr_len) ? (max_idx + 1) : arr_len;
+        }
+
+        last_key_val = key_val;
+
+        while (min_idx < max_idx) {
+            const npy_intp mid_idx = min_idx + ((max_idx - min_idx) >> 1);
+            const npy_intp sort_idx = *(npy_intp *)(sort + mid_idx * sort_str);
+            T mid_val;
+
+            if (sort_idx < 0 || sort_idx >= arr_len) {
+                return -1;
+            }
+
+            mid_val = *(const T *)(arr + sort_idx * arr_str);
+
+            if (cmp(mid_val, key_val)) {
+                min_idx = mid_idx + 1;
+            }
+            else {
+                max_idx = mid_idx;
+            }
+        }
+        *(npy_intp *)ret = min_idx;
+    }
+    return 0;
+}
+
+/*
+ *****************************************************************************
+ **                             GENERIC SEARCH                              **
+ *****************************************************************************
+ */
+
+template 
+static void
+npy_binsearch(const char *arr, const char *key, char *ret, npy_intp arr_len,
+              npy_intp key_len, npy_intp arr_str, npy_intp key_str,
+              npy_intp ret_str, PyArrayObject *cmp)
+{
+    using Cmp = typename side_to_generic_cmp::type;
+    PyArray_CompareFunc *compare = PyArray_DESCR(cmp)->f->compare;
+    npy_intp min_idx = 0;
+    npy_intp max_idx = arr_len;
+    const char *last_key = key;
+
+    for (; key_len > 0; key_len--, key += key_str, ret += ret_str) {
+        /*
+         * Updating only one of the indices based on the previous key
+         * gives the search a big boost when keys are sorted, but slightly
+         * slows down things for purely random ones.
+         */
+        if (Cmp{}(compare(last_key, key, cmp), 0)) {
+            max_idx = arr_len;
+        }
+        else {
+            min_idx = 0;
+            max_idx = (max_idx < arr_len) ? (max_idx + 1) : arr_len;
+        }
+
+        last_key = key;
+
+        while (min_idx < max_idx) {
+            const npy_intp mid_idx = min_idx + ((max_idx - min_idx) >> 1);
+            const char *arr_ptr = arr + mid_idx * arr_str;
+
+            if (Cmp{}(compare(arr_ptr, key, cmp), 0)) {
+                min_idx = mid_idx + 1;
+            }
+            else {
+                max_idx = mid_idx;
+            }
+        }
+        *(npy_intp *)ret = min_idx;
+    }
+}
+
+template 
+static int
+npy_argbinsearch(const char *arr, const char *key, const char *sort, char *ret,
+                 npy_intp arr_len, npy_intp key_len, npy_intp arr_str,
+                 npy_intp key_str, npy_intp sort_str, npy_intp ret_str,
+                 PyArrayObject *cmp)
+{
+    using Cmp = typename side_to_generic_cmp::type;
+    PyArray_CompareFunc *compare = PyArray_DESCR(cmp)->f->compare;
+    npy_intp min_idx = 0;
+    npy_intp max_idx = arr_len;
+    const char *last_key = key;
+
+    for (; key_len > 0; key_len--, key += key_str, ret += ret_str) {
+        /*
+         * Updating only one of the indices based on the previous key
+         * gives the search a big boost when keys are sorted, but slightly
+         * slows down things for purely random ones.
+         */
+        if (Cmp{}(compare(last_key, key, cmp), 0)) {
+            max_idx = arr_len;
+        }
+        else {
+            min_idx = 0;
+            max_idx = (max_idx < arr_len) ? (max_idx + 1) : arr_len;
+        }
+
+        last_key = key;
+
+        while (min_idx < max_idx) {
+            const npy_intp mid_idx = min_idx + ((max_idx - min_idx) >> 1);
+            const npy_intp sort_idx = *(npy_intp *)(sort + mid_idx * sort_str);
+            const char *arr_ptr;
+
+            if (sort_idx < 0 || sort_idx >= arr_len) {
+                return -1;
+            }
+
+            arr_ptr = arr + sort_idx * arr_str;
+
+            if (Cmp{}(compare(arr_ptr, key, cmp), 0)) {
+                min_idx = mid_idx + 1;
+            }
+            else {
+                max_idx = mid_idx;
+            }
+        }
+        *(npy_intp *)ret = min_idx;
+    }
+    return 0;
+}
+
+/*
+ *****************************************************************************
+ **                             GENERATOR                                   **
+ *****************************************************************************
+ */
+
+template 
+struct binsearch_base;
+
+template <>
+struct binsearch_base {
+    using function_type = PyArray_ArgBinSearchFunc *;
+    struct value_type {
+        int typenum;
+        function_type binsearch[NPY_NSEARCHSIDES];
+    };
+    template 
+    static constexpr std::array
+    make_binsearch_map(npy::taglist)
+    {
+        return std::array{
+                value_type{Tags::type_value,
+                           {(function_type)&argbinsearch,
+                            (function_type)argbinsearch}}...};
+    }
+    static constexpr std::array npy_map = {
+            (function_type)&npy_argbinsearch,
+            (function_type)&npy_argbinsearch};
+};
+constexpr std::array::function_type, 2>
+        binsearch_base::npy_map;
+
+template <>
+struct binsearch_base {
+    using function_type = PyArray_BinSearchFunc *;
+    struct value_type {
+        int typenum;
+        function_type binsearch[NPY_NSEARCHSIDES];
+    };
+    template 
+    static constexpr std::array
+    make_binsearch_map(npy::taglist)
+    {
+        return std::array{
+                value_type{Tags::type_value,
+                           {(function_type)&binsearch,
+                            (function_type)binsearch}}...};
+    }
+    static constexpr std::array npy_map = {
+            (function_type)&npy_binsearch,
+            (function_type)&npy_binsearch};
+};
+constexpr std::array::function_type, 2>
+        binsearch_base::npy_map;
+
+// Handle generation of all binsearch variants
+template 
+struct binsearch_t : binsearch_base {
+    using binsearch_base::make_binsearch_map;
+    using value_type = typename binsearch_base::value_type;
+
+    using taglist = npy::taglist<
+            /* If adding new types, make sure to keep them ordered by type num
+             */
+            npy::bool_tag, npy::byte_tag, npy::ubyte_tag, npy::short_tag,
+            npy::ushort_tag, npy::int_tag, npy::uint_tag, npy::long_tag,
+            npy::ulong_tag, npy::longlong_tag, npy::ulonglong_tag,
+            npy::float_tag, npy::double_tag, npy::longdouble_tag, 
+            npy::cfloat_tag, npy::cdouble_tag, npy::clongdouble_tag, 
+            npy::datetime_tag, npy::timedelta_tag, npy::half_tag>;
+
+    static constexpr std::array map =
+            make_binsearch_map(taglist());
+};
+
+template 
+constexpr std::array::value_type,
+                     binsearch_t::taglist::size>
+        binsearch_t::map;
+
+template 
+static inline typename binsearch_t::function_type
+_get_binsearch_func(PyArray_Descr *dtype, NPY_SEARCHSIDE side)
+{
+    using binsearch = binsearch_t;
+    npy_intp nfuncs = binsearch::map.size();
+    npy_intp min_idx = 0;
+    npy_intp max_idx = nfuncs;
+    int type = dtype->type_num;
+
+    if ((int)side >= (int)NPY_NSEARCHSIDES) {
+        return NULL;
+    }
+
+    /*
+     * It seems only fair that a binary search function be searched for
+     * using a binary search...
+     */
+    while (min_idx < max_idx) {
+        npy_intp mid_idx = min_idx + ((max_idx - min_idx) >> 1);
+
+        if (binsearch::map[mid_idx].typenum < type) {
+            min_idx = mid_idx + 1;
+        }
+        else {
+            max_idx = mid_idx;
+        }
+    }
+
+    if (min_idx < nfuncs && binsearch::map[min_idx].typenum == type) {
+        return binsearch::map[min_idx].binsearch[side];
+    }
+
+    if (dtype->f->compare) {
+        return binsearch::npy_map[side];
+    }
+
+    return NULL;
+}
+
+/*
+ *****************************************************************************
+ **                            C INTERFACE                                  **
+ *****************************************************************************
+ */
+extern "C" {
+NPY_NO_EXPORT PyArray_BinSearchFunc *
+get_binsearch_func(PyArray_Descr *dtype, NPY_SEARCHSIDE side)
+{
+    return _get_binsearch_func(dtype, side);
+}
+
+NPY_NO_EXPORT PyArray_ArgBinSearchFunc *
+get_argbinsearch_func(PyArray_Descr *dtype, NPY_SEARCHSIDE side)
+{
+    return _get_binsearch_func(dtype, side);
+}
+}
diff --git a/numpy/core/src/npysort/heapsort.c.src b/numpy/core/src/npysort/heapsort.c.src
deleted file mode 100644
index 4bfea1388442..000000000000
--- a/numpy/core/src/npysort/heapsort.c.src
+++ /dev/null
@@ -1,402 +0,0 @@
-/* -*- c -*- */
-
-/*
- * The purpose of this module is to add faster sort functions
- * that are type-specific.  This is done by altering the
- * function table for the builtin descriptors.
- *
- * These sorting functions are copied almost directly from numarray
- * with a few modifications (complex comparisons compare the imaginary
- * part if the real parts are equal, for example), and the names
- * are changed.
- *
- * The original sorting code is due to Charles R. Harris who wrote
- * it for numarray.
- */
-
-/*
- * Quick sort is usually the fastest, but the worst case scenario can
- * be slower than the merge and heap sorts.  The merge sort requires
- * extra memory and so for large arrays may not be useful.
- *
- * The merge sort is *stable*, meaning that equal components
- * are unmoved from their entry versions, so it can be used to
- * implement lexigraphic sorting on multiple keys.
- *
- * The heap sort is included for completeness.
- */
-
-#define NPY_NO_DEPRECATED_API NPY_API_VERSION
-
-#include "npy_sort.h"
-#include "npysort_common.h"
-#include 
-
-#define NOT_USED NPY_UNUSED(unused)
-#define PYA_QS_STACK 100
-#define SMALL_QUICKSORT 15
-#define SMALL_MERGESORT 20
-#define SMALL_STRING 16
-
-
-/*
- *****************************************************************************
- **                            NUMERIC SORTS                                **
- *****************************************************************************
- */
-
-
-/**begin repeat
- *
- * #TYPE = BOOL, BYTE, UBYTE, SHORT, USHORT, INT, UINT, LONG, ULONG,
- *         LONGLONG, ULONGLONG, HALF, FLOAT, DOUBLE, LONGDOUBLE,
- *         CFLOAT, CDOUBLE, CLONGDOUBLE, DATETIME, TIMEDELTA#
- * #suff = bool, byte, ubyte, short, ushort, int, uint, long, ulong,
- *         longlong, ulonglong, half, float, double, longdouble,
- *         cfloat, cdouble, clongdouble, datetime, timedelta#
- * #type = npy_bool, npy_byte, npy_ubyte, npy_short, npy_ushort, npy_int,
- *         npy_uint, npy_long, npy_ulong, npy_longlong, npy_ulonglong,
- *         npy_ushort, npy_float, npy_double, npy_longdouble, npy_cfloat,
- *         npy_cdouble, npy_clongdouble, npy_datetime, npy_timedelta#
- */
-
-NPY_NO_EXPORT int
-heapsort_@suff@(void *start, npy_intp n, void *NOT_USED)
-{
-    @type@ tmp, *a;
-    npy_intp i,j,l;
-
-    /* The array needs to be offset by one for heapsort indexing */
-    a = (@type@ *)start - 1;
-
-    for (l = n>>1; l > 0; --l) {
-        tmp = a[l];
-        for (i = l, j = l<<1; j <= n;) {
-            if (j < n && @TYPE@_LT(a[j], a[j+1])) {
-                j += 1;
-            }
-            if (@TYPE@_LT(tmp, a[j])) {
-                a[i] = a[j];
-                i = j;
-                j += j;
-            }
-            else {
-                break;
-            }
-        }
-        a[i] = tmp;
-    }
-
-    for (; n > 1;) {
-        tmp = a[n];
-        a[n] = a[1];
-        n -= 1;
-        for (i = 1, j = 2; j <= n;) {
-            if (j < n && @TYPE@_LT(a[j], a[j+1])) {
-                j++;
-            }
-            if (@TYPE@_LT(tmp, a[j])) {
-                a[i] = a[j];
-                i = j;
-                j += j;
-            }
-            else {
-                break;
-            }
-        }
-        a[i] = tmp;
-    }
-
-    return 0;
-}
-
-
-NPY_NO_EXPORT int
-aheapsort_@suff@(void *vv, npy_intp *tosort, npy_intp n, void *NOT_USED)
-{
-    @type@ *v = vv;
-    npy_intp *a, i,j,l, tmp;
-    /* The arrays need to be offset by one for heapsort indexing */
-    a = tosort - 1;
-
-    for (l = n>>1; l > 0; --l) {
-        tmp = a[l];
-        for (i = l, j = l<<1; j <= n;) {
-            if (j < n && @TYPE@_LT(v[a[j]], v[a[j+1]])) {
-                j += 1;
-            }
-            if (@TYPE@_LT(v[tmp], v[a[j]])) {
-                a[i] = a[j];
-                i = j;
-                j += j;
-            }
-            else {
-                break;
-            }
-        }
-        a[i] = tmp;
-    }
-
-    for (; n > 1;) {
-        tmp = a[n];
-        a[n] = a[1];
-        n -= 1;
-        for (i = 1, j = 2; j <= n;) {
-            if (j < n && @TYPE@_LT(v[a[j]], v[a[j+1]])) {
-                j++;
-            }
-            if (@TYPE@_LT(v[tmp], v[a[j]])) {
-                a[i] = a[j];
-                i = j;
-                j += j;
-            }
-            else {
-                break;
-            }
-        }
-        a[i] = tmp;
-    }
-
-    return 0;
-}
-
-/**end repeat**/
-
-
-/*
- *****************************************************************************
- **                             STRING SORTS                                **
- *****************************************************************************
- */
-
-
-/**begin repeat
- *
- * #TYPE = STRING, UNICODE#
- * #suff = string, unicode#
- * #type = npy_char, npy_ucs4#
- */
-
-NPY_NO_EXPORT int
-heapsort_@suff@(void *start, npy_intp n, void *varr)
-{
-    PyArrayObject *arr = varr;
-    size_t len = PyArray_ITEMSIZE(arr)/sizeof(@type@);
-    @type@ *tmp = malloc(PyArray_ITEMSIZE(arr));
-    @type@ *a = (@type@ *)start - len;
-    npy_intp i, j, l;
-
-    if (tmp == NULL) {
-        return -NPY_ENOMEM;
-    }
-
-    for (l = n>>1; l > 0; --l) {
-        @TYPE@_COPY(tmp, a + l*len, len);
-        for (i = l, j = l<<1; j <= n;) {
-            if (j < n && @TYPE@_LT(a + j*len, a + (j+1)*len, len))
-                j += 1;
-            if (@TYPE@_LT(tmp, a + j*len, len)) {
-                @TYPE@_COPY(a + i*len, a + j*len, len);
-                i = j;
-                j += j;
-            }
-            else {
-                break;
-            }
-        }
-        @TYPE@_COPY(a + i*len, tmp, len);
-    }
-
-    for (; n > 1;) {
-        @TYPE@_COPY(tmp, a + n*len, len);
-        @TYPE@_COPY(a + n*len, a + len, len);
-        n -= 1;
-        for (i = 1, j = 2; j <= n;) {
-            if (j < n && @TYPE@_LT(a + j*len, a + (j+1)*len, len))
-                j++;
-            if (@TYPE@_LT(tmp, a + j*len, len)) {
-                @TYPE@_COPY(a + i*len, a + j*len, len);
-                i = j;
-                j += j;
-            }
-            else {
-                break;
-            }
-        }
-        @TYPE@_COPY(a + i*len, tmp, len);
-    }
-
-    free(tmp);
-    return 0;
-}
-
-
-NPY_NO_EXPORT int
-aheapsort_@suff@(void *vv, npy_intp *tosort, npy_intp n, void *varr)
-{
-    @type@ *v = vv;
-    PyArrayObject *arr = varr;
-    size_t len = PyArray_ITEMSIZE(arr)/sizeof(@type@);
-    npy_intp *a, i,j,l, tmp;
-
-    /* The array needs to be offset by one for heapsort indexing */
-    a = tosort - 1;
-
-    for (l = n>>1; l > 0; --l) {
-        tmp = a[l];
-        for (i = l, j = l<<1; j <= n;) {
-            if (j < n && @TYPE@_LT(v + a[j]*len, v + a[j+1]*len, len))
-                j += 1;
-            if (@TYPE@_LT(v + tmp*len, v + a[j]*len, len)) {
-                a[i] = a[j];
-                i = j;
-                j += j;
-            }
-            else {
-                break;
-            }
-        }
-        a[i] = tmp;
-    }
-
-    for (; n > 1;) {
-        tmp = a[n];
-        a[n] = a[1];
-        n -= 1;
-        for (i = 1, j = 2; j <= n;) {
-            if (j < n && @TYPE@_LT(v + a[j]*len, v + a[j+1]*len, len))
-                j++;
-            if (@TYPE@_LT(v + tmp*len, v + a[j]*len, len)) {
-                a[i] = a[j];
-                i = j;
-                j += j;
-            }
-            else {
-                break;
-            }
-        }
-        a[i] = tmp;
-    }
-
-    return 0;
-}
-
-/**end repeat**/
-
-
-/*
- *****************************************************************************
- **                             GENERIC SORT                                **
- *****************************************************************************
- */
-
-
-NPY_NO_EXPORT int
-npy_heapsort(void *start, npy_intp num, void *varr)
-{
-    PyArrayObject *arr = varr;
-    npy_intp elsize = PyArray_ITEMSIZE(arr);
-    PyArray_CompareFunc *cmp = PyArray_DESCR(arr)->f->compare;
-    char *tmp = malloc(elsize);
-    char *a = (char *)start - elsize;
-    npy_intp i, j, l;
-
-    if (tmp == NULL) {
-        return -NPY_ENOMEM;
-    }
-
-    for (l = num >> 1; l > 0; --l) {
-        GENERIC_COPY(tmp, a + l*elsize, elsize);
-        for (i = l, j = l << 1; j <= num;) {
-            if (j < num && cmp(a + j*elsize, a + (j+1)*elsize, arr) < 0) {
-                ++j;
-            }
-            if (cmp(tmp, a + j*elsize, arr) < 0) {
-                GENERIC_COPY(a + i*elsize, a + j*elsize, elsize);
-                i = j;
-                j += j;
-            }
-            else {
-                break;
-            }
-        }
-        GENERIC_COPY(a + i*elsize, tmp, elsize);
-    }
-
-    for (; num > 1;) {
-        GENERIC_COPY(tmp, a + num*elsize, elsize);
-        GENERIC_COPY(a + num*elsize, a + elsize, elsize);
-        num -= 1;
-        for (i = 1, j = 2; j <= num;) {
-            if (j < num && cmp(a + j*elsize, a + (j+1)*elsize, arr) < 0) {
-                ++j;
-            }
-            if (cmp(tmp, a + j*elsize, arr) < 0) {
-                GENERIC_COPY(a + i*elsize, a + j*elsize, elsize);
-                i = j;
-                j += j;
-            }
-            else {
-                break;
-            }
-        }
-        GENERIC_COPY(a + i*elsize, tmp, elsize);
-    }
-
-    free(tmp);
-    return 0;
-}
-
-
-NPY_NO_EXPORT int
-npy_aheapsort(void *vv, npy_intp *tosort, npy_intp n, void *varr)
-{
-    char *v = vv;
-    PyArrayObject *arr = varr;
-    npy_intp elsize = PyArray_ITEMSIZE(arr);
-    PyArray_CompareFunc *cmp = PyArray_DESCR(arr)->f->compare;
-    npy_intp *a, i, j, l, tmp;
-
-    /* The array needs to be offset by one for heapsort indexing */
-    a = tosort - 1;
-
-    for (l = n >> 1; l > 0; --l) {
-        tmp = a[l];
-        for (i = l, j = l<<1; j <= n;) {
-            if (j < n && cmp(v + a[j]*elsize, v + a[j+1]*elsize, arr) < 0) {
-                ++j;
-            }
-            if (cmp(v + tmp*elsize, v + a[j]*elsize, arr) < 0) {
-                a[i] = a[j];
-                i = j;
-                j += j;
-            }
-            else {
-                break;
-            }
-        }
-        a[i] = tmp;
-    }
-
-    for (; n > 1;) {
-        tmp = a[n];
-        a[n] = a[1];
-        n -= 1;
-        for (i = 1, j = 2; j <= n;) {
-            if (j < n && cmp(v + a[j]*elsize, v + a[j+1]*elsize, arr) < 0) {
-                ++j;
-            }
-            if (cmp(v + tmp*elsize, v + a[j]*elsize, arr) < 0) {
-                a[i] = a[j];
-                i = j;
-                j += j;
-            }
-            else {
-                break;
-            }
-        }
-        a[i] = tmp;
-    }
-
-    return 0;
-}
diff --git a/numpy/core/src/npysort/heapsort.cpp b/numpy/core/src/npysort/heapsort.cpp
new file mode 100644
index 000000000000..de39367c22f8
--- /dev/null
+++ b/numpy/core/src/npysort/heapsort.cpp
@@ -0,0 +1,539 @@
+/* -*- c -*- */
+
+/*
+ * The purpose of this module is to add faster sort functions
+ * that are type-specific.  This is done by altering the
+ * function table for the builtin descriptors.
+ *
+ * These sorting functions are copied almost directly from numarray
+ * with a few modifications (complex comparisons compare the imaginary
+ * part if the real parts are equal, for example), and the names
+ * are changed.
+ *
+ * The original sorting code is due to Charles R. Harris who wrote
+ * it for numarray.
+ */
+
+/*
+ * Quick sort is usually the fastest, but the worst case scenario can
+ * be slower than the merge and heap sorts.  The merge sort requires
+ * extra memory and so for large arrays may not be useful.
+ *
+ * The merge sort is *stable*, meaning that equal components
+ * are unmoved from their entry versions, so it can be used to
+ * implement lexigraphic sorting on multiple keys.
+ *
+ * The heap sort is included for completeness.
+ */
+
+#define NPY_NO_DEPRECATED_API NPY_API_VERSION
+
+#include "npy_sort.h"
+#include "npysort_common.h"
+#include "numpy_tag.h"
+
+#include "npysort_heapsort.h"
+
+#include 
+
+#define NOT_USED NPY_UNUSED(unused)
+#define PYA_QS_STACK 100
+#define SMALL_QUICKSORT 15
+#define SMALL_MERGESORT 20
+#define SMALL_STRING 16
+
+
+/*
+ *****************************************************************************
+ **                             GENERIC SORT                                **
+ *****************************************************************************
+ */
+
+NPY_NO_EXPORT int
+npy_heapsort(void *start, npy_intp num, void *varr)
+{
+    PyArrayObject *arr = (PyArrayObject *)varr;
+    npy_intp elsize = PyArray_ITEMSIZE(arr);
+    PyArray_CompareFunc *cmp = PyArray_DESCR(arr)->f->compare;
+    char *tmp = (char *)malloc(elsize);
+    char *a = (char *)start - elsize;
+    npy_intp i, j, l;
+
+    if (tmp == NULL) {
+        return -NPY_ENOMEM;
+    }
+
+    for (l = num >> 1; l > 0; --l) {
+        GENERIC_COPY(tmp, a + l * elsize, elsize);
+        for (i = l, j = l << 1; j <= num;) {
+            if (j < num &&
+                cmp(a + j * elsize, a + (j + 1) * elsize, arr) < 0) {
+                ++j;
+            }
+            if (cmp(tmp, a + j * elsize, arr) < 0) {
+                GENERIC_COPY(a + i * elsize, a + j * elsize, elsize);
+                i = j;
+                j += j;
+            }
+            else {
+                break;
+            }
+        }
+        GENERIC_COPY(a + i * elsize, tmp, elsize);
+    }
+
+    for (; num > 1;) {
+        GENERIC_COPY(tmp, a + num * elsize, elsize);
+        GENERIC_COPY(a + num * elsize, a + elsize, elsize);
+        num -= 1;
+        for (i = 1, j = 2; j <= num;) {
+            if (j < num &&
+                cmp(a + j * elsize, a + (j + 1) * elsize, arr) < 0) {
+                ++j;
+            }
+            if (cmp(tmp, a + j * elsize, arr) < 0) {
+                GENERIC_COPY(a + i * elsize, a + j * elsize, elsize);
+                i = j;
+                j += j;
+            }
+            else {
+                break;
+            }
+        }
+        GENERIC_COPY(a + i * elsize, tmp, elsize);
+    }
+
+    free(tmp);
+    return 0;
+}
+
+NPY_NO_EXPORT int
+npy_aheapsort(void *vv, npy_intp *tosort, npy_intp n, void *varr)
+{
+    char *v = (char *)vv;
+    PyArrayObject *arr = (PyArrayObject *)varr;
+    npy_intp elsize = PyArray_ITEMSIZE(arr);
+    PyArray_CompareFunc *cmp = PyArray_DESCR(arr)->f->compare;
+    npy_intp *a, i, j, l, tmp;
+
+    /* The array needs to be offset by one for heapsort indexing */
+    a = tosort - 1;
+
+    for (l = n >> 1; l > 0; --l) {
+        tmp = a[l];
+        for (i = l, j = l << 1; j <= n;) {
+            if (j < n &&
+                cmp(v + a[j] * elsize, v + a[j + 1] * elsize, arr) < 0) {
+                ++j;
+            }
+            if (cmp(v + tmp * elsize, v + a[j] * elsize, arr) < 0) {
+                a[i] = a[j];
+                i = j;
+                j += j;
+            }
+            else {
+                break;
+            }
+        }
+        a[i] = tmp;
+    }
+
+    for (; n > 1;) {
+        tmp = a[n];
+        a[n] = a[1];
+        n -= 1;
+        for (i = 1, j = 2; j <= n;) {
+            if (j < n &&
+                cmp(v + a[j] * elsize, v + a[j + 1] * elsize, arr) < 0) {
+                ++j;
+            }
+            if (cmp(v + tmp * elsize, v + a[j] * elsize, arr) < 0) {
+                a[i] = a[j];
+                i = j;
+                j += j;
+            }
+            else {
+                break;
+            }
+        }
+        a[i] = tmp;
+    }
+
+    return 0;
+}
+
+/***************************************
+ * C > C++ dispatch
+ ***************************************/
+template NPY_NO_EXPORT int
+heapsort_(npy_bool *, npy_intp);
+NPY_NO_EXPORT int
+heapsort_bool(void *start, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return heapsort_((npy_bool *)start, n);
+}
+
+template NPY_NO_EXPORT int
+heapsort_(npy_byte *, npy_intp);
+NPY_NO_EXPORT int
+heapsort_byte(void *start, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return heapsort_((npy_byte *)start, n);
+}
+
+template NPY_NO_EXPORT int
+heapsort_(npy_ubyte *, npy_intp);
+NPY_NO_EXPORT int
+heapsort_ubyte(void *start, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return heapsort_((npy_ubyte *)start, n);
+}
+
+template NPY_NO_EXPORT int
+heapsort_(npy_short *, npy_intp);
+NPY_NO_EXPORT int
+heapsort_short(void *start, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return heapsort_((npy_short *)start, n);
+}
+
+template NPY_NO_EXPORT int
+heapsort_(npy_ushort *, npy_intp);
+NPY_NO_EXPORT int
+heapsort_ushort(void *start, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return heapsort_((npy_ushort *)start, n);
+}
+
+template NPY_NO_EXPORT int
+heapsort_(npy_int *, npy_intp);
+NPY_NO_EXPORT int
+heapsort_int(void *start, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return heapsort_((npy_int *)start, n);
+}
+
+template NPY_NO_EXPORT int
+heapsort_(npy_uint *, npy_intp);
+NPY_NO_EXPORT int
+heapsort_uint(void *start, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return heapsort_((npy_uint *)start, n);
+}
+
+template NPY_NO_EXPORT int
+heapsort_(npy_long *, npy_intp);
+NPY_NO_EXPORT int
+heapsort_long(void *start, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return heapsort_((npy_long *)start, n);
+}
+
+template NPY_NO_EXPORT int
+heapsort_(npy_ulong *, npy_intp);
+NPY_NO_EXPORT int
+heapsort_ulong(void *start, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return heapsort_((npy_ulong *)start, n);
+}
+
+template NPY_NO_EXPORT int
+heapsort_(npy_longlong *, npy_intp);
+NPY_NO_EXPORT int
+heapsort_longlong(void *start, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return heapsort_((npy_longlong *)start, n);
+}
+
+template NPY_NO_EXPORT int
+heapsort_(npy_ulonglong *, npy_intp);
+NPY_NO_EXPORT int
+heapsort_ulonglong(void *start, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return heapsort_((npy_ulonglong *)start, n);
+}
+
+template NPY_NO_EXPORT int
+heapsort_(npy_half *, npy_intp);
+NPY_NO_EXPORT int
+heapsort_half(void *start, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return heapsort_((npy_half *)start, n);
+}
+
+template NPY_NO_EXPORT int
+heapsort_(npy_float *, npy_intp);
+NPY_NO_EXPORT int
+heapsort_float(void *start, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return heapsort_((npy_float *)start, n);
+}
+
+template NPY_NO_EXPORT int
+heapsort_(npy_double *, npy_intp);
+NPY_NO_EXPORT int
+heapsort_double(void *start, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return heapsort_((npy_double *)start, n);
+}
+
+template NPY_NO_EXPORT int
+heapsort_(npy_longdouble *, npy_intp);
+NPY_NO_EXPORT int
+heapsort_longdouble(void *start, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return heapsort_((npy_longdouble *)start, n);
+}
+
+template NPY_NO_EXPORT int
+heapsort_(npy_cfloat *, npy_intp);
+NPY_NO_EXPORT int
+heapsort_cfloat(void *start, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return heapsort_((npy_cfloat *)start, n);
+}
+
+template NPY_NO_EXPORT int
+heapsort_(npy_cdouble *, npy_intp);
+NPY_NO_EXPORT int
+heapsort_cdouble(void *start, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return heapsort_((npy_cdouble *)start, n);
+}
+
+template NPY_NO_EXPORT int
+heapsort_(npy_clongdouble *, npy_intp);
+NPY_NO_EXPORT int
+heapsort_clongdouble(void *start, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return heapsort_((npy_clongdouble *)start, n);
+}
+
+template NPY_NO_EXPORT int
+heapsort_(npy_datetime *, npy_intp);
+NPY_NO_EXPORT int
+heapsort_datetime(void *start, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return heapsort_((npy_datetime *)start, n);
+}
+
+template NPY_NO_EXPORT int
+heapsort_(npy_timedelta *, npy_intp);
+NPY_NO_EXPORT int
+heapsort_timedelta(void *start, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return heapsort_((npy_timedelta *)start, n);
+}
+
+template NPY_NO_EXPORT int
+aheapsort_(npy_bool *vv, npy_intp *tosort,
+                                    npy_intp n);
+NPY_NO_EXPORT int
+aheapsort_bool(void *vv, npy_intp *tosort, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return aheapsort_((npy_bool *)vv, tosort, n);
+}
+
+template NPY_NO_EXPORT int
+aheapsort_(npy_byte *vv, npy_intp *tosort,
+                                    npy_intp n);
+NPY_NO_EXPORT int
+aheapsort_byte(void *vv, npy_intp *tosort, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return aheapsort_((npy_byte *)vv, tosort, n);
+}
+
+template NPY_NO_EXPORT int
+aheapsort_(npy_ubyte *vv, npy_intp *tosort,
+                                      npy_intp n);
+NPY_NO_EXPORT int
+aheapsort_ubyte(void *vv, npy_intp *tosort, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return aheapsort_((npy_ubyte *)vv, tosort, n);
+}
+
+template NPY_NO_EXPORT int
+aheapsort_(npy_short *vv, npy_intp *tosort,
+                                      npy_intp n);
+NPY_NO_EXPORT int
+aheapsort_short(void *vv, npy_intp *tosort, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return aheapsort_((npy_short *)vv, tosort, n);
+}
+
+template NPY_NO_EXPORT int
+aheapsort_(npy_ushort *vv, npy_intp *tosort,
+                                        npy_intp n);
+NPY_NO_EXPORT int
+aheapsort_ushort(void *vv, npy_intp *tosort, npy_intp n,
+                 void *NPY_UNUSED(varr))
+{
+    return aheapsort_((npy_ushort *)vv, tosort, n);
+}
+
+template NPY_NO_EXPORT int
+aheapsort_(npy_int *vv, npy_intp *tosort, npy_intp n);
+NPY_NO_EXPORT int
+aheapsort_int(void *vv, npy_intp *tosort, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return aheapsort_((npy_int *)vv, tosort, n);
+}
+
+template NPY_NO_EXPORT int
+aheapsort_(npy_uint *vv, npy_intp *tosort,
+                                    npy_intp n);
+NPY_NO_EXPORT int
+aheapsort_uint(void *vv, npy_intp *tosort, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return aheapsort_((npy_uint *)vv, tosort, n);
+}
+
+template NPY_NO_EXPORT int
+aheapsort_(npy_long *vv, npy_intp *tosort,
+                                    npy_intp n);
+NPY_NO_EXPORT int
+aheapsort_long(void *vv, npy_intp *tosort, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return aheapsort_((npy_long *)vv, tosort, n);
+}
+
+template NPY_NO_EXPORT int
+aheapsort_(npy_ulong *vv, npy_intp *tosort,
+                                      npy_intp n);
+NPY_NO_EXPORT int
+aheapsort_ulong(void *vv, npy_intp *tosort, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return aheapsort_((npy_ulong *)vv, tosort, n);
+}
+
+template NPY_NO_EXPORT int
+aheapsort_(npy_longlong *vv, npy_intp *tosort,
+                                            npy_intp n);
+NPY_NO_EXPORT int
+aheapsort_longlong(void *vv, npy_intp *tosort, npy_intp n,
+                   void *NPY_UNUSED(varr))
+{
+    return aheapsort_((npy_longlong *)vv, tosort, n);
+}
+
+template NPY_NO_EXPORT int
+aheapsort_(npy_ulonglong *vv,
+                                              npy_intp *tosort, npy_intp n);
+NPY_NO_EXPORT int
+aheapsort_ulonglong(void *vv, npy_intp *tosort, npy_intp n,
+                    void *NPY_UNUSED(varr))
+{
+    return aheapsort_((npy_ulonglong *)vv, tosort, n);
+}
+
+template NPY_NO_EXPORT int
+aheapsort_(npy_half *vv, npy_intp *tosort,
+                                    npy_intp n);
+NPY_NO_EXPORT int
+aheapsort_half(void *vv, npy_intp *tosort, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return aheapsort_((npy_half *)vv, tosort, n);
+}
+
+template NPY_NO_EXPORT int
+aheapsort_(npy_float *vv, npy_intp *tosort,
+                                      npy_intp n);
+NPY_NO_EXPORT int
+aheapsort_float(void *vv, npy_intp *tosort, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return aheapsort_((npy_float *)vv, tosort, n);
+}
+
+template NPY_NO_EXPORT int
+aheapsort_(npy_double *vv, npy_intp *tosort,
+                                        npy_intp n);
+NPY_NO_EXPORT int
+aheapsort_double(void *vv, npy_intp *tosort, npy_intp n,
+                 void *NPY_UNUSED(varr))
+{
+    return aheapsort_((npy_double *)vv, tosort, n);
+}
+
+template NPY_NO_EXPORT int
+aheapsort_(npy_longdouble *vv,
+                                                npy_intp *tosort, npy_intp n);
+NPY_NO_EXPORT int
+aheapsort_longdouble(void *vv, npy_intp *tosort, npy_intp n,
+                     void *NPY_UNUSED(varr))
+{
+    return aheapsort_((npy_longdouble *)vv, tosort, n);
+}
+
+template NPY_NO_EXPORT int
+aheapsort_(npy_cfloat *vv, npy_intp *tosort,
+                                        npy_intp n);
+NPY_NO_EXPORT int
+aheapsort_cfloat(void *vv, npy_intp *tosort, npy_intp n,
+                 void *NPY_UNUSED(varr))
+{
+    return aheapsort_((npy_cfloat *)vv, tosort, n);
+}
+
+template NPY_NO_EXPORT int
+aheapsort_(npy_cdouble *vv, npy_intp *tosort,
+                                          npy_intp n);
+NPY_NO_EXPORT int
+aheapsort_cdouble(void *vv, npy_intp *tosort, npy_intp n,
+                  void *NPY_UNUSED(varr))
+{
+    return aheapsort_((npy_cdouble *)vv, tosort, n);
+}
+
+template NPY_NO_EXPORT int
+aheapsort_(npy_clongdouble *vv,
+                                                  npy_intp *tosort,
+                                                  npy_intp n);
+NPY_NO_EXPORT int
+aheapsort_clongdouble(void *vv, npy_intp *tosort, npy_intp n,
+                      void *NPY_UNUSED(varr))
+{
+    return aheapsort_((npy_clongdouble *)vv, tosort, n);
+}
+
+template NPY_NO_EXPORT int
+aheapsort_(npy_datetime *vv, npy_intp *tosort,
+                                            npy_intp n);
+NPY_NO_EXPORT int
+aheapsort_datetime(void *vv, npy_intp *tosort, npy_intp n,
+                   void *NPY_UNUSED(varr))
+{
+    return aheapsort_((npy_datetime *)vv, tosort, n);
+}
+
+template NPY_NO_EXPORT int
+aheapsort_(npy_timedelta *vv,
+                                              npy_intp *tosort, npy_intp n);
+NPY_NO_EXPORT int
+aheapsort_timedelta(void *vv, npy_intp *tosort, npy_intp n,
+                    void *NPY_UNUSED(varr))
+{
+    return aheapsort_((npy_timedelta *)vv, tosort, n);
+}
+
+NPY_NO_EXPORT int
+heapsort_string(void *start, npy_intp n, void *varr)
+{
+    return string_heapsort_((npy_char *)start, n, varr);
+}
+NPY_NO_EXPORT int
+heapsort_unicode(void *start, npy_intp n, void *varr)
+{
+    return string_heapsort_((npy_ucs4 *)start, n, varr);
+}
+
+NPY_NO_EXPORT int
+aheapsort_string(void *vv, npy_intp *tosort, npy_intp n, void *varr)
+{
+    return string_aheapsort_((npy_char *)vv, tosort, n, varr);
+}
+NPY_NO_EXPORT int
+aheapsort_unicode(void *vv, npy_intp *tosort, npy_intp n, void *varr)
+{
+    return string_aheapsort_((npy_ucs4 *)vv, tosort, n,
+                                               varr);
+}
diff --git a/numpy/core/src/npysort/mergesort.c.src b/numpy/core/src/npysort/mergesort.c.src
deleted file mode 100644
index f83fbf758140..000000000000
--- a/numpy/core/src/npysort/mergesort.c.src
+++ /dev/null
@@ -1,511 +0,0 @@
-/* -*- c -*- */
-
-/*
- * The purpose of this module is to add faster sort functions
- * that are type-specific.  This is done by altering the
- * function table for the builtin descriptors.
- *
- * These sorting functions are copied almost directly from numarray
- * with a few modifications (complex comparisons compare the imaginary
- * part if the real parts are equal, for example), and the names
- * are changed.
- *
- * The original sorting code is due to Charles R. Harris who wrote
- * it for numarray.
- */
-
-/*
- * Quick sort is usually the fastest, but the worst case scenario can
- * be slower than the merge and heap sorts.  The merge sort requires
- * extra memory and so for large arrays may not be useful.
- *
- * The merge sort is *stable*, meaning that equal components
- * are unmoved from their entry versions, so it can be used to
- * implement lexigraphic sorting on multiple keys.
- *
- * The heap sort is included for completeness.
- */
-
-#define NPY_NO_DEPRECATED_API NPY_API_VERSION
-
-#include "npy_sort.h"
-#include "npysort_common.h"
-#include 
-
-#define NOT_USED NPY_UNUSED(unused)
-#define PYA_QS_STACK 100
-#define SMALL_QUICKSORT 15
-#define SMALL_MERGESORT 20
-#define SMALL_STRING 16
-
-
-/*
- *****************************************************************************
- **                            NUMERIC SORTS                                **
- *****************************************************************************
- */
-
-
-/**begin repeat
- *
- * #TYPE = BOOL, BYTE, UBYTE, SHORT, USHORT, INT, UINT, LONG, ULONG,
- *         LONGLONG, ULONGLONG, HALF, FLOAT, DOUBLE, LONGDOUBLE,
- *         CFLOAT, CDOUBLE, CLONGDOUBLE, DATETIME, TIMEDELTA#
- * #suff = bool, byte, ubyte, short, ushort, int, uint, long, ulong,
- *         longlong, ulonglong, half, float, double, longdouble,
- *         cfloat, cdouble, clongdouble, datetime, timedelta#
- * #type = npy_bool, npy_byte, npy_ubyte, npy_short, npy_ushort, npy_int,
- *         npy_uint, npy_long, npy_ulong, npy_longlong, npy_ulonglong,
- *         npy_ushort, npy_float, npy_double, npy_longdouble, npy_cfloat,
- *         npy_cdouble, npy_clongdouble, npy_datetime, npy_timedelta#
- */
-
-static void
-mergesort0_@suff@(@type@ *pl, @type@ *pr, @type@ *pw)
-{
-    @type@ vp, *pi, *pj, *pk, *pm;
-
-    if (pr - pl > SMALL_MERGESORT) {
-        /* merge sort */
-        pm = pl + ((pr - pl) >> 1);
-        mergesort0_@suff@(pl, pm, pw);
-        mergesort0_@suff@(pm, pr, pw);
-        for (pi = pw, pj = pl; pj < pm;) {
-            *pi++ = *pj++;
-        }
-        pi = pw + (pm - pl);
-        pj = pw;
-        pk = pl;
-        while (pj < pi && pm < pr) {
-            if (@TYPE@_LT(*pm, *pj)) {
-                *pk++ = *pm++;
-            }
-            else {
-                *pk++ = *pj++;
-            }
-        }
-        while(pj < pi) {
-            *pk++ = *pj++;
-        }
-    }
-    else {
-        /* insertion sort */
-        for (pi = pl + 1; pi < pr; ++pi) {
-            vp = *pi;
-            pj = pi;
-            pk = pi - 1;
-            while (pj > pl && @TYPE@_LT(vp, *pk)) {
-                *pj-- = *pk--;
-            }
-            *pj = vp;
-        }
-    }
-}
-
-
-NPY_NO_EXPORT int
-mergesort_@suff@(void *start, npy_intp num, void *NOT_USED)
-{
-    @type@ *pl, *pr, *pw;
-
-    pl = start;
-    pr = pl + num;
-    pw = malloc((num/2) * sizeof(@type@));
-    if (pw == NULL) {
-        return -NPY_ENOMEM;
-    }
-    mergesort0_@suff@(pl, pr, pw);
-
-    free(pw);
-    return 0;
-}
-
-
-static void
-amergesort0_@suff@(npy_intp *pl, npy_intp *pr, @type@ *v, npy_intp *pw)
-{
-    @type@ vp;
-    npy_intp vi, *pi, *pj, *pk, *pm;
-
-    if (pr - pl > SMALL_MERGESORT) {
-        /* merge sort */
-        pm = pl + ((pr - pl) >> 1);
-        amergesort0_@suff@(pl, pm, v, pw);
-        amergesort0_@suff@(pm, pr, v, pw);
-        for (pi = pw, pj = pl; pj < pm;) {
-            *pi++ = *pj++;
-        }
-        pi = pw + (pm - pl);
-        pj = pw;
-        pk = pl;
-        while (pj < pi && pm < pr) {
-            if (@TYPE@_LT(v[*pm], v[*pj])) {
-                *pk++ = *pm++;
-            }
-            else {
-                *pk++ = *pj++;
-            }
-        }
-        while(pj < pi) {
-            *pk++ = *pj++;
-        }
-    }
-    else {
-        /* insertion sort */
-        for (pi = pl + 1; pi < pr; ++pi) {
-            vi = *pi;
-            vp = v[vi];
-            pj = pi;
-            pk = pi - 1;
-            while (pj > pl && @TYPE@_LT(vp, v[*pk])) {
-                *pj-- = *pk--;
-            }
-            *pj = vi;
-        }
-    }
-}
-
-
-NPY_NO_EXPORT int
-amergesort_@suff@(void *v, npy_intp *tosort, npy_intp num, void *NOT_USED)
-{
-    npy_intp *pl, *pr, *pw;
-
-    pl = tosort;
-    pr = pl + num;
-    pw = malloc((num/2) * sizeof(npy_intp));
-    if (pw == NULL) {
-        return -NPY_ENOMEM;
-    }
-    amergesort0_@suff@(pl, pr, v, pw);
-    free(pw);
-
-    return 0;
-}
-
-/**end repeat**/
-
-
-/*
- *****************************************************************************
- **                             STRING SORTS                                **
- *****************************************************************************
- */
-
-
-/**begin repeat
- *
- * #TYPE = STRING, UNICODE#
- * #suff = string, unicode#
- * #type = npy_char, npy_ucs4#
- */
-
-static void
-mergesort0_@suff@(@type@ *pl, @type@ *pr, @type@ *pw, @type@ *vp, size_t len)
-{
-    @type@ *pi, *pj, *pk, *pm;
-
-    if ((size_t)(pr - pl) > SMALL_MERGESORT*len) {
-        /* merge sort */
-        pm = pl + (((pr - pl)/len) >> 1)*len;
-        mergesort0_@suff@(pl, pm, pw, vp, len);
-        mergesort0_@suff@(pm, pr, pw, vp, len);
-        @TYPE@_COPY(pw, pl, pm - pl);
-        pi = pw + (pm - pl);
-        pj = pw;
-        pk = pl;
-        while (pj < pi && pm < pr) {
-            if (@TYPE@_LT(pm, pj, len)) {
-                @TYPE@_COPY(pk, pm, len);
-                pm += len;
-                pk += len;
-            }
-            else {
-                @TYPE@_COPY(pk, pj, len);
-                pj += len;
-                pk += len;
-            }
-        }
-        @TYPE@_COPY(pk, pj, pi - pj);
-    }
-    else {
-        /* insertion sort */
-        for (pi = pl + len; pi < pr; pi += len) {
-            @TYPE@_COPY(vp, pi, len);
-            pj = pi;
-            pk = pi - len;
-            while (pj > pl && @TYPE@_LT(vp, pk, len)) {
-                @TYPE@_COPY(pj, pk, len);
-                pj -= len;
-                pk -= len;
-            }
-            @TYPE@_COPY(pj, vp, len);
-        }
-    }
-}
-
-
-NPY_NO_EXPORT int
-mergesort_@suff@(void *start, npy_intp num, void *varr)
-{
-    PyArrayObject *arr = varr;
-    size_t elsize = PyArray_ITEMSIZE(arr);
-    size_t len = elsize / sizeof(@type@);
-    @type@ *pl, *pr, *pw, *vp;
-    int err = 0;
-
-    /* Items that have zero size don't make sense to sort */
-    if (elsize == 0) {
-        return 0;
-    }
-
-    pl = start;
-    pr = pl + num*len;
-    pw = malloc((num/2) * elsize);
-    if (pw == NULL) {
-        err = -NPY_ENOMEM;
-        goto fail_0;
-    }
-    vp = malloc(elsize);
-    if (vp == NULL) {
-        err = -NPY_ENOMEM;
-        goto fail_1;
-    }
-    mergesort0_@suff@(pl, pr, pw, vp, len);
-
-    free(vp);
-fail_1:
-    free(pw);
-fail_0:
-    return err;
-}
-
-
-static void
-amergesort0_@suff@(npy_intp *pl, npy_intp *pr, @type@ *v, npy_intp *pw, size_t len)
-{
-    @type@ *vp;
-    npy_intp vi, *pi, *pj, *pk, *pm;
-
-    if (pr - pl > SMALL_MERGESORT) {
-        /* merge sort */
-        pm = pl + ((pr - pl) >> 1);
-        amergesort0_@suff@(pl, pm, v, pw, len);
-        amergesort0_@suff@(pm, pr, v, pw, len);
-        for (pi = pw, pj = pl; pj < pm;) {
-            *pi++ = *pj++;
-        }
-        pi = pw + (pm - pl);
-        pj = pw;
-        pk = pl;
-        while (pj < pi && pm < pr) {
-            if (@TYPE@_LT(v + (*pm)*len, v + (*pj)*len, len)) {
-                *pk++ = *pm++;
-            }
-            else {
-                *pk++ = *pj++;
-            }
-        }
-        while (pj < pi) {
-            *pk++ = *pj++;
-        }
-    }
-    else {
-        /* insertion sort */
-        for (pi = pl + 1; pi < pr; ++pi) {
-            vi = *pi;
-            vp = v + vi*len;
-            pj = pi;
-            pk = pi - 1;
-            while (pj > pl && @TYPE@_LT(vp, v + (*pk)*len, len)) {
-                *pj-- = *pk--;
-            }
-            *pj = vi;
-        }
-    }
-}
-
-
-NPY_NO_EXPORT int
-amergesort_@suff@(void *v, npy_intp *tosort, npy_intp num, void *varr)
-{
-    PyArrayObject *arr = varr;
-    size_t elsize = PyArray_ITEMSIZE(arr);
-    size_t len = elsize / sizeof(@type@);
-    npy_intp *pl, *pr, *pw;
-
-    /* Items that have zero size don't make sense to sort */
-    if (elsize == 0) {
-        return 0;
-    }
-
-    pl = tosort;
-    pr = pl + num;
-    pw = malloc((num/2) * sizeof(npy_intp));
-    if (pw == NULL) {
-        return -NPY_ENOMEM;
-    }
-    amergesort0_@suff@(pl, pr, v, pw, len);
-    free(pw);
-
-    return 0;
-}
-
-/**end repeat**/
-
-
-/*
- *****************************************************************************
- **                             GENERIC SORT                                **
- *****************************************************************************
- */
-
-
-static void
-npy_mergesort0(char *pl, char *pr, char *pw, char *vp, npy_intp elsize,
-               PyArray_CompareFunc *cmp, PyArrayObject *arr)
-{
-    char *pi, *pj, *pk, *pm;
-
-    if (pr - pl > SMALL_MERGESORT*elsize) {
-        /* merge sort */
-        pm = pl + (((pr - pl)/elsize) >> 1)*elsize;
-        npy_mergesort0(pl, pm, pw, vp, elsize, cmp, arr);
-        npy_mergesort0(pm, pr, pw, vp, elsize, cmp, arr);
-        GENERIC_COPY(pw, pl, pm - pl);
-        pi = pw + (pm - pl);
-        pj = pw;
-        pk = pl;
-        while (pj < pi && pm < pr) {
-            if (cmp(pm, pj, arr) < 0) {
-                GENERIC_COPY(pk, pm, elsize);
-                pm += elsize;
-                pk += elsize;
-            }
-            else {
-                GENERIC_COPY(pk, pj, elsize);
-                pj += elsize;
-                pk += elsize;
-            }
-        }
-        GENERIC_COPY(pk, pj, pi - pj);
-    }
-    else {
-        /* insertion sort */
-        for (pi = pl + elsize; pi < pr; pi += elsize) {
-            GENERIC_COPY(vp, pi, elsize);
-            pj = pi;
-            pk = pi - elsize;
-            while (pj > pl && cmp(vp, pk, arr) < 0) {
-                GENERIC_COPY(pj, pk, elsize);
-                pj -= elsize;
-                pk -= elsize;
-            }
-            GENERIC_COPY(pj, vp, elsize);
-        }
-    }
-}
-
-
-NPY_NO_EXPORT int
-npy_mergesort(void *start, npy_intp num, void *varr)
-{
-    PyArrayObject *arr = varr;
-    npy_intp elsize = PyArray_ITEMSIZE(arr);
-    PyArray_CompareFunc *cmp = PyArray_DESCR(arr)->f->compare;
-    char *pl = start;
-    char *pr = pl + num*elsize;
-    char *pw;
-    char *vp;
-    int err = -NPY_ENOMEM;
-
-    /* Items that have zero size don't make sense to sort */
-    if (elsize == 0) {
-        return 0;
-    }
-
-    pw = malloc((num >> 1) *elsize);
-    vp = malloc(elsize);
-
-    if (pw != NULL && vp != NULL) {
-        npy_mergesort0(pl, pr, pw, vp, elsize, cmp, arr);
-        err = 0;
-    }
-
-    free(vp);
-    free(pw);
-
-    return err;
-}
-
-
-static void
-npy_amergesort0(npy_intp *pl, npy_intp *pr, char *v, npy_intp *pw,
-                npy_intp elsize, PyArray_CompareFunc *cmp, PyArrayObject *arr)
-{
-    char *vp;
-    npy_intp vi, *pi, *pj, *pk, *pm;
-
-    if (pr - pl > SMALL_MERGESORT) {
-        /* merge sort */
-        pm = pl + ((pr - pl) >> 1);
-        npy_amergesort0(pl, pm, v, pw, elsize, cmp, arr);
-        npy_amergesort0(pm, pr, v, pw, elsize, cmp, arr);
-        for (pi = pw, pj = pl; pj < pm;) {
-            *pi++ = *pj++;
-        }
-        pi = pw + (pm - pl);
-        pj = pw;
-        pk = pl;
-        while (pj < pi && pm < pr) {
-            if (cmp(v + (*pm)*elsize, v + (*pj)*elsize, arr) < 0) {
-                *pk++ = *pm++;
-            }
-            else {
-                *pk++ = *pj++;
-            }
-        }
-        while (pj < pi) {
-            *pk++ = *pj++;
-        }
-    }
-    else {
-        /* insertion sort */
-        for (pi = pl + 1; pi < pr; ++pi) {
-            vi = *pi;
-            vp = v + vi*elsize;
-            pj = pi;
-            pk = pi - 1;
-            while (pj > pl && cmp(vp, v + (*pk)*elsize, arr) < 0) {
-                *pj-- = *pk--;
-            }
-            *pj = vi;
-        }
-    }
-}
-
-
-NPY_NO_EXPORT int
-npy_amergesort(void *v, npy_intp *tosort, npy_intp num, void *varr)
-{
-    PyArrayObject *arr = varr;
-    npy_intp elsize = PyArray_ITEMSIZE(arr);
-    PyArray_CompareFunc *cmp = PyArray_DESCR(arr)->f->compare;
-    npy_intp *pl, *pr, *pw;
-
-    /* Items that have zero size don't make sense to sort */
-    if (elsize == 0) {
-        return 0;
-    }
-
-    pl = tosort;
-    pr = pl + num;
-    pw = malloc((num >> 1) * sizeof(npy_intp));
-    if (pw == NULL) {
-        return -NPY_ENOMEM;
-    }
-    npy_amergesort0(pl, pr, v, pw, elsize, cmp, arr);
-    free(pw);
-
-    return 0;
-}
diff --git a/numpy/core/src/npysort/mergesort.cpp b/numpy/core/src/npysort/mergesort.cpp
new file mode 100644
index 000000000000..f892dd185b88
--- /dev/null
+++ b/numpy/core/src/npysort/mergesort.cpp
@@ -0,0 +1,733 @@
+/* -*- c -*- */
+
+/*
+ * The purpose of this module is to add faster sort functions
+ * that are type-specific.  This is done by altering the
+ * function table for the builtin descriptors.
+ *
+ * These sorting functions are copied almost directly from numarray
+ * with a few modifications (complex comparisons compare the imaginary
+ * part if the real parts are equal, for example), and the names
+ * are changed.
+ *
+ * The original sorting code is due to Charles R. Harris who wrote
+ * it for numarray.
+ */
+
+/*
+ * Quick sort is usually the fastest, but the worst case scenario can
+ * be slower than the merge and heap sorts.  The merge sort requires
+ * extra memory and so for large arrays may not be useful.
+ *
+ * The merge sort is *stable*, meaning that equal components
+ * are unmoved from their entry versions, so it can be used to
+ * implement lexigraphic sorting on multiple keys.
+ *
+ * The heap sort is included for completeness.
+ */
+
+#define NPY_NO_DEPRECATED_API NPY_API_VERSION
+
+#include "npy_sort.h"
+#include "npysort_common.h"
+#include "numpy_tag.h"
+
+#include 
+
+#define NOT_USED NPY_UNUSED(unused)
+#define PYA_QS_STACK 100
+#define SMALL_QUICKSORT 15
+#define SMALL_MERGESORT 20
+#define SMALL_STRING 16
+
+/*
+ *****************************************************************************
+ **                            NUMERIC SORTS                                **
+ *****************************************************************************
+ */
+
+template 
+static void
+mergesort0_(type *pl, type *pr, type *pw)
+{
+    type vp, *pi, *pj, *pk, *pm;
+
+    if (pr - pl > SMALL_MERGESORT) {
+        /* merge sort */
+        pm = pl + ((pr - pl) >> 1);
+        mergesort0_(pl, pm, pw);
+        mergesort0_(pm, pr, pw);
+        for (pi = pw, pj = pl; pj < pm;) {
+            *pi++ = *pj++;
+        }
+        pi = pw + (pm - pl);
+        pj = pw;
+        pk = pl;
+        while (pj < pi && pm < pr) {
+            if (Tag::less(*pm, *pj)) {
+                *pk++ = *pm++;
+            }
+            else {
+                *pk++ = *pj++;
+            }
+        }
+        while (pj < pi) {
+            *pk++ = *pj++;
+        }
+    }
+    else {
+        /* insertion sort */
+        for (pi = pl + 1; pi < pr; ++pi) {
+            vp = *pi;
+            pj = pi;
+            pk = pi - 1;
+            while (pj > pl && Tag::less(vp, *pk)) {
+                *pj-- = *pk--;
+            }
+            *pj = vp;
+        }
+    }
+}
+
+template 
+NPY_NO_EXPORT int
+mergesort_(type *start, npy_intp num)
+{
+    type *pl, *pr, *pw;
+
+    pl = start;
+    pr = pl + num;
+    pw = (type *)malloc((num / 2) * sizeof(type));
+    if (pw == NULL) {
+        return -NPY_ENOMEM;
+    }
+    mergesort0_(pl, pr, pw);
+
+    free(pw);
+    return 0;
+}
+
+template 
+static void
+amergesort0_(npy_intp *pl, npy_intp *pr, type *v, npy_intp *pw)
+{
+    type vp;
+    npy_intp vi, *pi, *pj, *pk, *pm;
+
+    if (pr - pl > SMALL_MERGESORT) {
+        /* merge sort */
+        pm = pl + ((pr - pl) >> 1);
+        amergesort0_(pl, pm, v, pw);
+        amergesort0_(pm, pr, v, pw);
+        for (pi = pw, pj = pl; pj < pm;) {
+            *pi++ = *pj++;
+        }
+        pi = pw + (pm - pl);
+        pj = pw;
+        pk = pl;
+        while (pj < pi && pm < pr) {
+            if (Tag::less(v[*pm], v[*pj])) {
+                *pk++ = *pm++;
+            }
+            else {
+                *pk++ = *pj++;
+            }
+        }
+        while (pj < pi) {
+            *pk++ = *pj++;
+        }
+    }
+    else {
+        /* insertion sort */
+        for (pi = pl + 1; pi < pr; ++pi) {
+            vi = *pi;
+            vp = v[vi];
+            pj = pi;
+            pk = pi - 1;
+            while (pj > pl && Tag::less(vp, v[*pk])) {
+                *pj-- = *pk--;
+            }
+            *pj = vi;
+        }
+    }
+}
+
+template 
+NPY_NO_EXPORT int
+amergesort_(type *v, npy_intp *tosort, npy_intp num)
+{
+    npy_intp *pl, *pr, *pw;
+
+    pl = tosort;
+    pr = pl + num;
+    pw = (npy_intp *)malloc((num / 2) * sizeof(npy_intp));
+    if (pw == NULL) {
+        return -NPY_ENOMEM;
+    }
+    amergesort0_(pl, pr, v, pw);
+    free(pw);
+
+    return 0;
+}
+
+/*
+ *****************************************************************************
+ **                             STRING SORTS                                **
+ *****************************************************************************
+ */
+
+template 
+static void
+mergesort0_(type *pl, type *pr, type *pw, type *vp, size_t len)
+{
+    type *pi, *pj, *pk, *pm;
+
+    if ((size_t)(pr - pl) > SMALL_MERGESORT * len) {
+        /* merge sort */
+        pm = pl + (((pr - pl) / len) >> 1) * len;
+        mergesort0_(pl, pm, pw, vp, len);
+        mergesort0_(pm, pr, pw, vp, len);
+        Tag::copy(pw, pl, pm - pl);
+        pi = pw + (pm - pl);
+        pj = pw;
+        pk = pl;
+        while (pj < pi && pm < pr) {
+            if (Tag::less(pm, pj, len)) {
+                Tag::copy(pk, pm, len);
+                pm += len;
+                pk += len;
+            }
+            else {
+                Tag::copy(pk, pj, len);
+                pj += len;
+                pk += len;
+            }
+        }
+        Tag::copy(pk, pj, pi - pj);
+    }
+    else {
+        /* insertion sort */
+        for (pi = pl + len; pi < pr; pi += len) {
+            Tag::copy(vp, pi, len);
+            pj = pi;
+            pk = pi - len;
+            while (pj > pl && Tag::less(vp, pk, len)) {
+                Tag::copy(pj, pk, len);
+                pj -= len;
+                pk -= len;
+            }
+            Tag::copy(pj, vp, len);
+        }
+    }
+}
+
+template 
+static int
+string_mergesort_(type *start, npy_intp num, void *varr)
+{
+    PyArrayObject *arr = (PyArrayObject *)varr;
+    size_t elsize = PyArray_ITEMSIZE(arr);
+    size_t len = elsize / sizeof(type);
+    type *pl, *pr, *pw, *vp;
+    int err = 0;
+
+    /* Items that have zero size don't make sense to sort */
+    if (elsize == 0) {
+        return 0;
+    }
+
+    pl = start;
+    pr = pl + num * len;
+    pw = (type *)malloc((num / 2) * elsize);
+    if (pw == NULL) {
+        err = -NPY_ENOMEM;
+        goto fail_0;
+    }
+    vp = (type *)malloc(elsize);
+    if (vp == NULL) {
+        err = -NPY_ENOMEM;
+        goto fail_1;
+    }
+    mergesort0_(pl, pr, pw, vp, len);
+
+    free(vp);
+fail_1:
+    free(pw);
+fail_0:
+    return err;
+}
+
+template 
+static void
+amergesort0_(npy_intp *pl, npy_intp *pr, type *v, npy_intp *pw, size_t len)
+{
+    type *vp;
+    npy_intp vi, *pi, *pj, *pk, *pm;
+
+    if (pr - pl > SMALL_MERGESORT) {
+        /* merge sort */
+        pm = pl + ((pr - pl) >> 1);
+        amergesort0_(pl, pm, v, pw, len);
+        amergesort0_(pm, pr, v, pw, len);
+        for (pi = pw, pj = pl; pj < pm;) {
+            *pi++ = *pj++;
+        }
+        pi = pw + (pm - pl);
+        pj = pw;
+        pk = pl;
+        while (pj < pi && pm < pr) {
+            if (Tag::less(v + (*pm) * len, v + (*pj) * len, len)) {
+                *pk++ = *pm++;
+            }
+            else {
+                *pk++ = *pj++;
+            }
+        }
+        while (pj < pi) {
+            *pk++ = *pj++;
+        }
+    }
+    else {
+        /* insertion sort */
+        for (pi = pl + 1; pi < pr; ++pi) {
+            vi = *pi;
+            vp = v + vi * len;
+            pj = pi;
+            pk = pi - 1;
+            while (pj > pl && Tag::less(vp, v + (*pk) * len, len)) {
+                *pj-- = *pk--;
+            }
+            *pj = vi;
+        }
+    }
+}
+
+template 
+static int
+string_amergesort_(type *v, npy_intp *tosort, npy_intp num, void *varr)
+{
+    PyArrayObject *arr = (PyArrayObject *)varr;
+    size_t elsize = PyArray_ITEMSIZE(arr);
+    size_t len = elsize / sizeof(type);
+    npy_intp *pl, *pr, *pw;
+
+    /* Items that have zero size don't make sense to sort */
+    if (elsize == 0) {
+        return 0;
+    }
+
+    pl = tosort;
+    pr = pl + num;
+    pw = (npy_intp *)malloc((num / 2) * sizeof(npy_intp));
+    if (pw == NULL) {
+        return -NPY_ENOMEM;
+    }
+    amergesort0_(pl, pr, v, pw, len);
+    free(pw);
+
+    return 0;
+}
+
+/*
+ *****************************************************************************
+ **                             GENERIC SORT                                **
+ *****************************************************************************
+ */
+
+static void
+npy_mergesort0(char *pl, char *pr, char *pw, char *vp, npy_intp elsize,
+               PyArray_CompareFunc *cmp, PyArrayObject *arr)
+{
+    char *pi, *pj, *pk, *pm;
+
+    if (pr - pl > SMALL_MERGESORT * elsize) {
+        /* merge sort */
+        pm = pl + (((pr - pl) / elsize) >> 1) * elsize;
+        npy_mergesort0(pl, pm, pw, vp, elsize, cmp, arr);
+        npy_mergesort0(pm, pr, pw, vp, elsize, cmp, arr);
+        GENERIC_COPY(pw, pl, pm - pl);
+        pi = pw + (pm - pl);
+        pj = pw;
+        pk = pl;
+        while (pj < pi && pm < pr) {
+            if (cmp(pm, pj, arr) < 0) {
+                GENERIC_COPY(pk, pm, elsize);
+                pm += elsize;
+                pk += elsize;
+            }
+            else {
+                GENERIC_COPY(pk, pj, elsize);
+                pj += elsize;
+                pk += elsize;
+            }
+        }
+        GENERIC_COPY(pk, pj, pi - pj);
+    }
+    else {
+        /* insertion sort */
+        for (pi = pl + elsize; pi < pr; pi += elsize) {
+            GENERIC_COPY(vp, pi, elsize);
+            pj = pi;
+            pk = pi - elsize;
+            while (pj > pl && cmp(vp, pk, arr) < 0) {
+                GENERIC_COPY(pj, pk, elsize);
+                pj -= elsize;
+                pk -= elsize;
+            }
+            GENERIC_COPY(pj, vp, elsize);
+        }
+    }
+}
+
+NPY_NO_EXPORT int
+npy_mergesort(void *start, npy_intp num, void *varr)
+{
+    PyArrayObject *arr = (PyArrayObject *)varr;
+    npy_intp elsize = PyArray_ITEMSIZE(arr);
+    PyArray_CompareFunc *cmp = PyArray_DESCR(arr)->f->compare;
+    char *pl = (char *)start;
+    char *pr = pl + num * elsize;
+    char *pw;
+    char *vp;
+    int err = -NPY_ENOMEM;
+
+    /* Items that have zero size don't make sense to sort */
+    if (elsize == 0) {
+        return 0;
+    }
+
+    pw = (char *)malloc((num >> 1) * elsize);
+    vp = (char *)malloc(elsize);
+
+    if (pw != NULL && vp != NULL) {
+        npy_mergesort0(pl, pr, pw, vp, elsize, cmp, arr);
+        err = 0;
+    }
+
+    free(vp);
+    free(pw);
+
+    return err;
+}
+
+static void
+npy_amergesort0(npy_intp *pl, npy_intp *pr, char *v, npy_intp *pw,
+                npy_intp elsize, PyArray_CompareFunc *cmp, PyArrayObject *arr)
+{
+    char *vp;
+    npy_intp vi, *pi, *pj, *pk, *pm;
+
+    if (pr - pl > SMALL_MERGESORT) {
+        /* merge sort */
+        pm = pl + ((pr - pl) >> 1);
+        npy_amergesort0(pl, pm, v, pw, elsize, cmp, arr);
+        npy_amergesort0(pm, pr, v, pw, elsize, cmp, arr);
+        for (pi = pw, pj = pl; pj < pm;) {
+            *pi++ = *pj++;
+        }
+        pi = pw + (pm - pl);
+        pj = pw;
+        pk = pl;
+        while (pj < pi && pm < pr) {
+            if (cmp(v + (*pm) * elsize, v + (*pj) * elsize, arr) < 0) {
+                *pk++ = *pm++;
+            }
+            else {
+                *pk++ = *pj++;
+            }
+        }
+        while (pj < pi) {
+            *pk++ = *pj++;
+        }
+    }
+    else {
+        /* insertion sort */
+        for (pi = pl + 1; pi < pr; ++pi) {
+            vi = *pi;
+            vp = v + vi * elsize;
+            pj = pi;
+            pk = pi - 1;
+            while (pj > pl && cmp(vp, v + (*pk) * elsize, arr) < 0) {
+                *pj-- = *pk--;
+            }
+            *pj = vi;
+        }
+    }
+}
+
+NPY_NO_EXPORT int
+npy_amergesort(void *v, npy_intp *tosort, npy_intp num, void *varr)
+{
+    PyArrayObject *arr = (PyArrayObject *)varr;
+    npy_intp elsize = PyArray_ITEMSIZE(arr);
+    PyArray_CompareFunc *cmp = PyArray_DESCR(arr)->f->compare;
+    npy_intp *pl, *pr, *pw;
+
+    /* Items that have zero size don't make sense to sort */
+    if (elsize == 0) {
+        return 0;
+    }
+
+    pl = tosort;
+    pr = pl + num;
+    pw = (npy_intp *)malloc((num >> 1) * sizeof(npy_intp));
+    if (pw == NULL) {
+        return -NPY_ENOMEM;
+    }
+    npy_amergesort0(pl, pr, (char *)v, pw, elsize, cmp, arr);
+    free(pw);
+
+    return 0;
+}
+
+/***************************************
+ * C > C++ dispatch
+ ***************************************/
+NPY_NO_EXPORT int
+mergesort_bool(void *start, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return mergesort_((npy_bool *)start, num);
+}
+NPY_NO_EXPORT int
+mergesort_byte(void *start, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return mergesort_((npy_byte *)start, num);
+}
+NPY_NO_EXPORT int
+mergesort_ubyte(void *start, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return mergesort_((npy_ubyte *)start, num);
+}
+NPY_NO_EXPORT int
+mergesort_short(void *start, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return mergesort_((npy_short *)start, num);
+}
+NPY_NO_EXPORT int
+mergesort_ushort(void *start, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return mergesort_((npy_ushort *)start, num);
+}
+NPY_NO_EXPORT int
+mergesort_int(void *start, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return mergesort_((npy_int *)start, num);
+}
+NPY_NO_EXPORT int
+mergesort_uint(void *start, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return mergesort_((npy_uint *)start, num);
+}
+NPY_NO_EXPORT int
+mergesort_long(void *start, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return mergesort_((npy_long *)start, num);
+}
+NPY_NO_EXPORT int
+mergesort_ulong(void *start, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return mergesort_((npy_ulong *)start, num);
+}
+NPY_NO_EXPORT int
+mergesort_longlong(void *start, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return mergesort_((npy_longlong *)start, num);
+}
+NPY_NO_EXPORT int
+mergesort_ulonglong(void *start, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return mergesort_((npy_ulonglong *)start, num);
+}
+NPY_NO_EXPORT int
+mergesort_half(void *start, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return mergesort_((npy_half *)start, num);
+}
+NPY_NO_EXPORT int
+mergesort_float(void *start, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return mergesort_((npy_float *)start, num);
+}
+NPY_NO_EXPORT int
+mergesort_double(void *start, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return mergesort_((npy_double *)start, num);
+}
+NPY_NO_EXPORT int
+mergesort_longdouble(void *start, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return mergesort_((npy_longdouble *)start, num);
+}
+NPY_NO_EXPORT int
+mergesort_cfloat(void *start, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return mergesort_((npy_cfloat *)start, num);
+}
+NPY_NO_EXPORT int
+mergesort_cdouble(void *start, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return mergesort_((npy_cdouble *)start, num);
+}
+NPY_NO_EXPORT int
+mergesort_clongdouble(void *start, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return mergesort_((npy_clongdouble *)start, num);
+}
+NPY_NO_EXPORT int
+mergesort_datetime(void *start, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return mergesort_((npy_datetime *)start, num);
+}
+NPY_NO_EXPORT int
+mergesort_timedelta(void *start, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return mergesort_((npy_timedelta *)start, num);
+}
+
+NPY_NO_EXPORT int
+amergesort_bool(void *start, npy_intp *tosort, npy_intp num,
+                void *NPY_UNUSED(varr))
+{
+    return amergesort_((npy_bool *)start, tosort, num);
+}
+NPY_NO_EXPORT int
+amergesort_byte(void *start, npy_intp *tosort, npy_intp num,
+                void *NPY_UNUSED(varr))
+{
+    return amergesort_((npy_byte *)start, tosort, num);
+}
+NPY_NO_EXPORT int
+amergesort_ubyte(void *start, npy_intp *tosort, npy_intp num,
+                 void *NPY_UNUSED(varr))
+{
+    return amergesort_((npy_ubyte *)start, tosort, num);
+}
+NPY_NO_EXPORT int
+amergesort_short(void *start, npy_intp *tosort, npy_intp num,
+                 void *NPY_UNUSED(varr))
+{
+    return amergesort_((npy_short *)start, tosort, num);
+}
+NPY_NO_EXPORT int
+amergesort_ushort(void *start, npy_intp *tosort, npy_intp num,
+                  void *NPY_UNUSED(varr))
+{
+    return amergesort_((npy_ushort *)start, tosort, num);
+}
+NPY_NO_EXPORT int
+amergesort_int(void *start, npy_intp *tosort, npy_intp num,
+               void *NPY_UNUSED(varr))
+{
+    return amergesort_((npy_int *)start, tosort, num);
+}
+NPY_NO_EXPORT int
+amergesort_uint(void *start, npy_intp *tosort, npy_intp num,
+                void *NPY_UNUSED(varr))
+{
+    return amergesort_((npy_uint *)start, tosort, num);
+}
+NPY_NO_EXPORT int
+amergesort_long(void *start, npy_intp *tosort, npy_intp num,
+                void *NPY_UNUSED(varr))
+{
+    return amergesort_((npy_long *)start, tosort, num);
+}
+NPY_NO_EXPORT int
+amergesort_ulong(void *start, npy_intp *tosort, npy_intp num,
+                 void *NPY_UNUSED(varr))
+{
+    return amergesort_((npy_ulong *)start, tosort, num);
+}
+NPY_NO_EXPORT int
+amergesort_longlong(void *start, npy_intp *tosort, npy_intp num,
+                    void *NPY_UNUSED(varr))
+{
+    return amergesort_((npy_longlong *)start, tosort, num);
+}
+NPY_NO_EXPORT int
+amergesort_ulonglong(void *start, npy_intp *tosort, npy_intp num,
+                     void *NPY_UNUSED(varr))
+{
+    return amergesort_((npy_ulonglong *)start, tosort,
+                                           num);
+}
+NPY_NO_EXPORT int
+amergesort_half(void *start, npy_intp *tosort, npy_intp num,
+                void *NPY_UNUSED(varr))
+{
+    return amergesort_((npy_half *)start, tosort, num);
+}
+NPY_NO_EXPORT int
+amergesort_float(void *start, npy_intp *tosort, npy_intp num,
+                 void *NPY_UNUSED(varr))
+{
+    return amergesort_((npy_float *)start, tosort, num);
+}
+NPY_NO_EXPORT int
+amergesort_double(void *start, npy_intp *tosort, npy_intp num,
+                  void *NPY_UNUSED(varr))
+{
+    return amergesort_((npy_double *)start, tosort, num);
+}
+NPY_NO_EXPORT int
+amergesort_longdouble(void *start, npy_intp *tosort, npy_intp num,
+                      void *NPY_UNUSED(varr))
+{
+    return amergesort_((npy_longdouble *)start, tosort,
+                                            num);
+}
+NPY_NO_EXPORT int
+amergesort_cfloat(void *start, npy_intp *tosort, npy_intp num,
+                  void *NPY_UNUSED(varr))
+{
+    return amergesort_((npy_cfloat *)start, tosort, num);
+}
+NPY_NO_EXPORT int
+amergesort_cdouble(void *start, npy_intp *tosort, npy_intp num,
+                   void *NPY_UNUSED(varr))
+{
+    return amergesort_((npy_cdouble *)start, tosort, num);
+}
+NPY_NO_EXPORT int
+amergesort_clongdouble(void *start, npy_intp *tosort, npy_intp num,
+                       void *NPY_UNUSED(varr))
+{
+    return amergesort_((npy_clongdouble *)start, tosort,
+                                             num);
+}
+NPY_NO_EXPORT int
+amergesort_datetime(void *start, npy_intp *tosort, npy_intp num,
+                    void *NPY_UNUSED(varr))
+{
+    return amergesort_((npy_datetime *)start, tosort, num);
+}
+NPY_NO_EXPORT int
+amergesort_timedelta(void *start, npy_intp *tosort, npy_intp num,
+                     void *NPY_UNUSED(varr))
+{
+    return amergesort_((npy_timedelta *)start, tosort,
+                                           num);
+}
+
+NPY_NO_EXPORT int
+mergesort_string(void *start, npy_intp num, void *varr)
+{
+    return string_mergesort_((npy_char *)start, num, varr);
+}
+NPY_NO_EXPORT int
+mergesort_unicode(void *start, npy_intp num, void *varr)
+{
+    return string_mergesort_((npy_ucs4 *)start, num, varr);
+}
+NPY_NO_EXPORT int
+amergesort_string(void *v, npy_intp *tosort, npy_intp num, void *varr)
+{
+    return string_amergesort_((npy_char *)v, tosort, num,
+                                               varr);
+}
+NPY_NO_EXPORT int
+amergesort_unicode(void *v, npy_intp *tosort, npy_intp num, void *varr)
+{
+    return string_amergesort_((npy_ucs4 *)v, tosort, num,
+                                                varr);
+}
diff --git a/numpy/core/src/npysort/npysort_common.h b/numpy/core/src/npysort/npysort_common.h
index 2a6e4d421234..ab9f456b65d1 100644
--- a/numpy/core/src/npysort/npysort_common.h
+++ b/numpy/core/src/npysort/npysort_common.h
@@ -4,6 +4,10 @@
 #include 
 #include 
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
  *****************************************************************************
  **                        SWAP MACROS                                      **
@@ -139,14 +143,14 @@ LONGDOUBLE_LT(npy_longdouble a, npy_longdouble b)
 
 
 NPY_INLINE static int
-npy_half_isnan(npy_half h)
+_npy_half_isnan(npy_half h)
 {
     return ((h&0x7c00u) == 0x7c00u) && ((h&0x03ffu) != 0x0000u);
 }
 
 
 NPY_INLINE static int
-npy_half_lt_nonan(npy_half h1, npy_half h2)
+_npy_half_lt_nonan(npy_half h1, npy_half h2)
 {
     if (h1&0x8000u) {
         if (h2&0x8000u) {
@@ -173,11 +177,11 @@ HALF_LT(npy_half a, npy_half b)
 {
     int ret;
 
-    if (npy_half_isnan(b)) {
-        ret = !npy_half_isnan(a);
+    if (_npy_half_isnan(b)) {
+        ret = !_npy_half_isnan(a);
     }
     else {
-        ret = !npy_half_isnan(a) && npy_half_lt_nonan(a, b);
+        ret = !_npy_half_isnan(a) && _npy_half_lt_nonan(a, b);
     }
 
     return ret;
@@ -255,7 +259,7 @@ CLONGDOUBLE_LT(npy_clongdouble a, npy_clongdouble b)
 
 
 NPY_INLINE static void
-STRING_COPY(char *s1, char *s2, size_t len)
+STRING_COPY(char *s1, char const*s2, size_t len)
 {
     memcpy(s1, s2, len);
 }
@@ -291,7 +295,7 @@ STRING_LT(const char *s1, const char *s2, size_t len)
 
 
 NPY_INLINE static void
-UNICODE_COPY(npy_ucs4 *s1, npy_ucs4 *s2, size_t len)
+UNICODE_COPY(npy_ucs4 *s1, npy_ucs4 const *s2, size_t len)
 {
     while(len--) {
         *s1++ = *s2++;
@@ -373,4 +377,8 @@ GENERIC_SWAP(char *a, char *b, size_t len)
     }
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif
diff --git a/numpy/core/src/npysort/npysort_heapsort.h b/numpy/core/src/npysort/npysort_heapsort.h
new file mode 100644
index 000000000000..762d89b7be78
--- /dev/null
+++ b/numpy/core/src/npysort/npysort_heapsort.h
@@ -0,0 +1,230 @@
+#ifndef __NPY_SORT_HEAPSORT_H__
+#define __NPY_SORT_HEAPSORT_H__
+
+#define NPY_NO_DEPRECATED_API NPY_API_VERSION
+
+#include "npy_sort.h"
+#include "npysort_common.h"
+#include "numpy_tag.h"
+
+#include 
+
+/*
+ *****************************************************************************
+ **                            NUMERIC SORTS                                **
+ *****************************************************************************
+ */
+
+template 
+NPY_INLINE NPY_NO_EXPORT
+int heapsort_(type *start, npy_intp n)
+{
+    type tmp, *a;
+    npy_intp i, j, l;
+
+    /* The array needs to be offset by one for heapsort indexing */
+    a = start - 1;
+
+    for (l = n >> 1; l > 0; --l) {
+        tmp = a[l];
+        for (i = l, j = l << 1; j <= n;) {
+            if (j < n && Tag::less(a[j], a[j + 1])) {
+                j += 1;
+            }
+            if (Tag::less(tmp, a[j])) {
+                a[i] = a[j];
+                i = j;
+                j += j;
+            }
+            else {
+                break;
+            }
+        }
+        a[i] = tmp;
+    }
+
+    for (; n > 1;) {
+        tmp = a[n];
+        a[n] = a[1];
+        n -= 1;
+        for (i = 1, j = 2; j <= n;) {
+            if (j < n && Tag::less(a[j], a[j + 1])) {
+                j++;
+            }
+            if (Tag::less(tmp, a[j])) {
+                a[i] = a[j];
+                i = j;
+                j += j;
+            }
+            else {
+                break;
+            }
+        }
+        a[i] = tmp;
+    }
+
+    return 0;
+}
+
+template 
+NPY_INLINE NPY_NO_EXPORT
+int aheapsort_(type *vv, npy_intp *tosort, npy_intp n)
+{
+    type *v = vv;
+    npy_intp *a, i, j, l, tmp;
+    /* The arrays need to be offset by one for heapsort indexing */
+    a = tosort - 1;
+
+    for (l = n >> 1; l > 0; --l) {
+        tmp = a[l];
+        for (i = l, j = l << 1; j <= n;) {
+            if (j < n && Tag::less(v[a[j]], v[a[j + 1]])) {
+                j += 1;
+            }
+            if (Tag::less(v[tmp], v[a[j]])) {
+                a[i] = a[j];
+                i = j;
+                j += j;
+            }
+            else {
+                break;
+            }
+        }
+        a[i] = tmp;
+    }
+
+    for (; n > 1;) {
+        tmp = a[n];
+        a[n] = a[1];
+        n -= 1;
+        for (i = 1, j = 2; j <= n;) {
+            if (j < n && Tag::less(v[a[j]], v[a[j + 1]])) {
+                j++;
+            }
+            if (Tag::less(v[tmp], v[a[j]])) {
+                a[i] = a[j];
+                i = j;
+                j += j;
+            }
+            else {
+                break;
+            }
+        }
+        a[i] = tmp;
+    }
+
+    return 0;
+}
+
+/*
+ *****************************************************************************
+ **                            STRING SORTS                                 **
+ *****************************************************************************
+ */
+
+template 
+NPY_INLINE NPY_NO_EXPORT
+int string_heapsort_(type *start, npy_intp n, void *varr)
+{
+    PyArrayObject *arr = (PyArrayObject *)varr;
+    size_t len = PyArray_ITEMSIZE(arr) / sizeof(type);
+    type *tmp = (type *)malloc(PyArray_ITEMSIZE(arr));
+    type *a = (type *)start - len;
+    npy_intp i, j, l;
+
+    if (tmp == NULL) {
+        return -NPY_ENOMEM;
+    }
+
+    for (l = n >> 1; l > 0; --l) {
+        Tag::copy(tmp, a + l * len, len);
+        for (i = l, j = l << 1; j <= n;) {
+            if (j < n && Tag::less(a + j * len, a + (j + 1) * len, len))
+                j += 1;
+            if (Tag::less(tmp, a + j * len, len)) {
+                Tag::copy(a + i * len, a + j * len, len);
+                i = j;
+                j += j;
+            }
+            else {
+                break;
+            }
+        }
+        Tag::copy(a + i * len, tmp, len);
+    }
+
+    for (; n > 1;) {
+        Tag::copy(tmp, a + n * len, len);
+        Tag::copy(a + n * len, a + len, len);
+        n -= 1;
+        for (i = 1, j = 2; j <= n;) {
+            if (j < n && Tag::less(a + j * len, a + (j + 1) * len, len))
+                j++;
+            if (Tag::less(tmp, a + j * len, len)) {
+                Tag::copy(a + i * len, a + j * len, len);
+                i = j;
+                j += j;
+            }
+            else {
+                break;
+            }
+        }
+        Tag::copy(a + i * len, tmp, len);
+    }
+
+    free(tmp);
+    return 0;
+}
+
+template 
+NPY_INLINE NPY_NO_EXPORT
+int string_aheapsort_(type *vv, npy_intp *tosort, npy_intp n, void *varr)
+{
+    type *v = vv;
+    PyArrayObject *arr = (PyArrayObject *)varr;
+    size_t len = PyArray_ITEMSIZE(arr) / sizeof(type);
+    npy_intp *a, i, j, l, tmp;
+
+    /* The array needs to be offset by one for heapsort indexing */
+    a = tosort - 1;
+
+    for (l = n >> 1; l > 0; --l) {
+        tmp = a[l];
+        for (i = l, j = l << 1; j <= n;) {
+            if (j < n && Tag::less(v + a[j] * len, v + a[j + 1] * len, len))
+                j += 1;
+            if (Tag::less(v + tmp * len, v + a[j] * len, len)) {
+                a[i] = a[j];
+                i = j;
+                j += j;
+            }
+            else {
+                break;
+            }
+        }
+        a[i] = tmp;
+    }
+
+    for (; n > 1;) {
+        tmp = a[n];
+        a[n] = a[1];
+        n -= 1;
+        for (i = 1, j = 2; j <= n;) {
+            if (j < n && Tag::less(v + a[j] * len, v + a[j + 1] * len, len))
+                j++;
+            if (Tag::less(v + tmp * len, v + a[j] * len, len)) {
+                a[i] = a[j];
+                i = j;
+                j += j;
+            }
+            else {
+                break;
+            }
+        }
+        a[i] = tmp;
+    }
+
+    return 0;
+}
+
+#endif
diff --git a/numpy/core/src/npysort/quicksort.c.src b/numpy/core/src/npysort/quicksort.c.src
deleted file mode 100644
index 933f75808b69..000000000000
--- a/numpy/core/src/npysort/quicksort.c.src
+++ /dev/null
@@ -1,634 +0,0 @@
-/* -*- c -*- */
-
-/*
- * The purpose of this module is to add faster sort functions
- * that are type-specific.  This is done by altering the
- * function table for the builtin descriptors.
- *
- * These sorting functions are copied almost directly from numarray
- * with a few modifications (complex comparisons compare the imaginary
- * part if the real parts are equal, for example), and the names
- * are changed.
- *
- * The original sorting code is due to Charles R. Harris who wrote
- * it for numarray.
- */
-
-/*
- * Quick sort is usually the fastest, but the worst case scenario is O(N^2) so
- * the code switches to the O(NlogN) worst case heapsort if not enough progress
- * is made on the large side of the two quicksort partitions. This improves the
- * worst case while still retaining the speed of quicksort for the common case.
- * This is variant known as introsort.
- *
- *
- * def introsort(lower, higher, recursion_limit=log2(higher - lower + 1) * 2):
- *   # sort remainder with heapsort if we are not making enough progress
- *   # we arbitrarily choose 2 * log(n) as the cutoff point
- *   if recursion_limit < 0:
- *       heapsort(lower, higher)
- *       return
- *
- *   if lower < higher:
- *      pivot_pos = partition(lower, higher)
- *      # recurse into smaller first and leave larger on stack
- *      # this limits the required stack space
- *      if (pivot_pos - lower > higher - pivot_pos):
- *          quicksort(pivot_pos + 1, higher, recursion_limit - 1)
- *          quicksort(lower, pivot_pos, recursion_limit - 1)
- *      else:
- *          quicksort(lower, pivot_pos, recursion_limit - 1)
- *          quicksort(pivot_pos + 1, higher, recursion_limit - 1)
- *
- *
- * the below code implements this converted to an iteration and as an
- * additional minor optimization skips the recursion depth checking on the
- * smaller partition as it is always less than half of the remaining data and
- * will thus terminate fast enough
- */
-
-#define NPY_NO_DEPRECATED_API NPY_API_VERSION
-
-#include "npy_sort.h"
-#include "npysort_common.h"
-#include 
-
-#define NOT_USED NPY_UNUSED(unused)
-/*
- * pushing largest partition has upper bound of log2(n) space
- * we store two pointers each time
- */
-#define PYA_QS_STACK (NPY_BITSOF_INTP * 2)
-#define SMALL_QUICKSORT 15
-#define SMALL_MERGESORT 20
-#define SMALL_STRING 16
-
-
-/*
- *****************************************************************************
- **                            NUMERIC SORTS                                **
- *****************************************************************************
- */
-
-
-/**begin repeat
- *
- * #TYPE = BOOL, BYTE, UBYTE, SHORT, USHORT, INT, UINT, LONG, ULONG,
- *         LONGLONG, ULONGLONG, HALF, FLOAT, DOUBLE, LONGDOUBLE,
- *         CFLOAT, CDOUBLE, CLONGDOUBLE, DATETIME, TIMEDELTA#
- * #suff = bool, byte, ubyte, short, ushort, int, uint, long, ulong,
- *         longlong, ulonglong, half, float, double, longdouble,
- *         cfloat, cdouble, clongdouble, datetime, timedelta#
- * #type = npy_bool, npy_byte, npy_ubyte, npy_short, npy_ushort, npy_int,
- *         npy_uint, npy_long, npy_ulong, npy_longlong, npy_ulonglong,
- *         npy_ushort, npy_float, npy_double, npy_longdouble, npy_cfloat,
- *         npy_cdouble, npy_clongdouble, npy_datetime, npy_timedelta#
- */
-
-NPY_NO_EXPORT int
-quicksort_@suff@(void *start, npy_intp num, void *NOT_USED)
-{
-    @type@ vp;
-    @type@ *pl = start;
-    @type@ *pr = pl + num - 1;
-    @type@ *stack[PYA_QS_STACK];
-    @type@ **sptr = stack;
-    @type@ *pm, *pi, *pj, *pk;
-    int depth[PYA_QS_STACK];
-    int * psdepth = depth;
-    int cdepth = npy_get_msb(num) * 2;
-
-    for (;;) {
-        if (NPY_UNLIKELY(cdepth < 0)) {
-            heapsort_@suff@(pl, pr - pl + 1, NULL);
-            goto stack_pop;
-        }
-        while ((pr - pl) > SMALL_QUICKSORT) {
-            /* quicksort partition */
-            pm = pl + ((pr - pl) >> 1);
-            if (@TYPE@_LT(*pm, *pl)) @TYPE@_SWAP(*pm, *pl);
-            if (@TYPE@_LT(*pr, *pm)) @TYPE@_SWAP(*pr, *pm);
-            if (@TYPE@_LT(*pm, *pl)) @TYPE@_SWAP(*pm, *pl);
-            vp = *pm;
-            pi = pl;
-            pj = pr - 1;
-            @TYPE@_SWAP(*pm, *pj);
-            for (;;) {
-                do ++pi; while (@TYPE@_LT(*pi, vp));
-                do --pj; while (@TYPE@_LT(vp, *pj));
-                if (pi >= pj) {
-                    break;
-                }
-                @TYPE@_SWAP(*pi,*pj);
-            }
-            pk = pr - 1;
-            @TYPE@_SWAP(*pi, *pk);
-            /* push largest partition on stack */
-            if (pi - pl < pr - pi) {
-                *sptr++ = pi + 1;
-                *sptr++ = pr;
-                pr = pi - 1;
-            }
-            else {
-                *sptr++ = pl;
-                *sptr++ = pi - 1;
-                pl = pi + 1;
-            }
-            *psdepth++ = --cdepth;
-        }
-
-        /* insertion sort */
-        for (pi = pl + 1; pi <= pr; ++pi) {
-            vp = *pi;
-            pj = pi;
-            pk = pi - 1;
-            while (pj > pl && @TYPE@_LT(vp, *pk)) {
-                *pj-- = *pk--;
-            }
-            *pj = vp;
-        }
-stack_pop:
-        if (sptr == stack) {
-            break;
-        }
-        pr = *(--sptr);
-        pl = *(--sptr);
-        cdepth = *(--psdepth);
-    }
-
-    return 0;
-}
-
-
-NPY_NO_EXPORT int
-aquicksort_@suff@(void *vv, npy_intp* tosort, npy_intp num, void *NOT_USED)
-{
-    @type@ *v = vv;
-    @type@ vp;
-    npy_intp *pl = tosort;
-    npy_intp *pr = tosort + num - 1;
-    npy_intp *stack[PYA_QS_STACK];
-    npy_intp **sptr = stack;
-    npy_intp *pm, *pi, *pj, *pk, vi;
-    int depth[PYA_QS_STACK];
-    int * psdepth = depth;
-    int cdepth = npy_get_msb(num) * 2;
-
-    for (;;) {
-        if (NPY_UNLIKELY(cdepth < 0)) {
-            aheapsort_@suff@(vv, pl, pr - pl + 1, NULL);
-            goto stack_pop;
-        }
-        while ((pr - pl) > SMALL_QUICKSORT) {
-            /* quicksort partition */
-            pm = pl + ((pr - pl) >> 1);
-            if (@TYPE@_LT(v[*pm],v[*pl])) INTP_SWAP(*pm, *pl);
-            if (@TYPE@_LT(v[*pr],v[*pm])) INTP_SWAP(*pr, *pm);
-            if (@TYPE@_LT(v[*pm],v[*pl])) INTP_SWAP(*pm, *pl);
-            vp = v[*pm];
-            pi = pl;
-            pj = pr - 1;
-            INTP_SWAP(*pm, *pj);
-            for (;;) {
-                do ++pi; while (@TYPE@_LT(v[*pi], vp));
-                do --pj; while (@TYPE@_LT(vp, v[*pj]));
-                if (pi >= pj) {
-                    break;
-                }
-                INTP_SWAP(*pi, *pj);
-            }
-            pk = pr - 1;
-            INTP_SWAP(*pi,*pk);
-            /* push largest partition on stack */
-            if (pi - pl < pr - pi) {
-                *sptr++ = pi + 1;
-                *sptr++ = pr;
-                pr = pi - 1;
-            }
-            else {
-                *sptr++ = pl;
-                *sptr++ = pi - 1;
-                pl = pi + 1;
-            }
-            *psdepth++ = --cdepth;
-        }
-
-        /* insertion sort */
-        for (pi = pl + 1; pi <= pr; ++pi) {
-            vi = *pi;
-            vp = v[vi];
-            pj = pi;
-            pk = pi - 1;
-            while (pj > pl && @TYPE@_LT(vp, v[*pk])) {
-                *pj-- = *pk--;
-            }
-            *pj = vi;
-        }
-stack_pop:
-        if (sptr == stack) {
-            break;
-        }
-        pr = *(--sptr);
-        pl = *(--sptr);
-        cdepth = *(--psdepth);
-    }
-
-    return 0;
-}
-
-/**end repeat**/
-
-
-/*
- *****************************************************************************
- **                             STRING SORTS                                **
- *****************************************************************************
- */
-
-
-/**begin repeat
- *
- * #TYPE = STRING, UNICODE#
- * #suff = string, unicode#
- * #type = npy_char, npy_ucs4#
- */
-
-NPY_NO_EXPORT int
-quicksort_@suff@(void *start, npy_intp num, void *varr)
-{
-    PyArrayObject *arr = varr;
-    const size_t len = PyArray_ITEMSIZE(arr)/sizeof(@type@);
-    @type@ *vp;
-    @type@ *pl = start;
-    @type@ *pr = pl + (num - 1)*len;
-    @type@ *stack[PYA_QS_STACK], **sptr = stack, *pm, *pi, *pj, *pk;
-    int depth[PYA_QS_STACK];
-    int * psdepth = depth;
-    int cdepth = npy_get_msb(num) * 2;
-
-    /* Items that have zero size don't make sense to sort */
-    if (len == 0) {
-        return 0;
-    }
-
-    vp = malloc(PyArray_ITEMSIZE(arr));
-    if (vp == NULL) {
-        return -NPY_ENOMEM;
-    }
-
-    for (;;) {
-        if (NPY_UNLIKELY(cdepth < 0)) {
-            heapsort_@suff@(pl, (pr - pl) / len + 1, varr);
-            goto stack_pop;
-        }
-        while ((size_t)(pr - pl) > SMALL_QUICKSORT*len) {
-            /* quicksort partition */
-            pm = pl + (((pr - pl)/len) >> 1)*len;
-            if (@TYPE@_LT(pm, pl, len)) @TYPE@_SWAP(pm, pl, len);
-            if (@TYPE@_LT(pr, pm, len)) @TYPE@_SWAP(pr, pm, len);
-            if (@TYPE@_LT(pm, pl, len)) @TYPE@_SWAP(pm, pl, len);
-            @TYPE@_COPY(vp, pm, len);
-            pi = pl;
-            pj = pr - len;
-            @TYPE@_SWAP(pm, pj, len);
-            for (;;) {
-                do pi += len; while (@TYPE@_LT(pi, vp, len));
-                do pj -= len; while (@TYPE@_LT(vp, pj, len));
-                if (pi >= pj) {
-                    break;
-                }
-                @TYPE@_SWAP(pi, pj, len);
-            }
-            pk = pr - len;
-            @TYPE@_SWAP(pi, pk, len);
-            /* push largest partition on stack */
-            if (pi - pl < pr - pi) {
-                *sptr++ = pi + len;
-                *sptr++ = pr;
-                pr = pi - len;
-            }
-            else {
-                *sptr++ = pl;
-                *sptr++ = pi - len;
-                pl = pi + len;
-            }
-            *psdepth++ = --cdepth;
-        }
-
-        /* insertion sort */
-        for (pi = pl + len; pi <= pr; pi += len) {
-            @TYPE@_COPY(vp, pi, len);
-            pj = pi;
-            pk = pi - len;
-            while (pj > pl && @TYPE@_LT(vp, pk, len)) {
-                @TYPE@_COPY(pj, pk, len);
-                pj -= len;
-                pk -= len;
-            }
-            @TYPE@_COPY(pj, vp, len);
-        }
-stack_pop:
-        if (sptr == stack) {
-            break;
-        }
-        pr = *(--sptr);
-        pl = *(--sptr);
-        cdepth = *(--psdepth);
-    }
-
-    free(vp);
-    return 0;
-}
-
-
-NPY_NO_EXPORT int
-aquicksort_@suff@(void *vv, npy_intp* tosort, npy_intp num, void *varr)
-{
-    @type@ *v = vv;
-    PyArrayObject *arr = varr;
-    size_t len = PyArray_ITEMSIZE(arr)/sizeof(@type@);
-    @type@ *vp;
-    npy_intp *pl = tosort;
-    npy_intp *pr = tosort + num - 1;
-    npy_intp *stack[PYA_QS_STACK];
-    npy_intp **sptr=stack;
-    npy_intp *pm, *pi, *pj, *pk, vi;
-    int depth[PYA_QS_STACK];
-    int * psdepth = depth;
-    int cdepth = npy_get_msb(num) * 2;
-
-    /* Items that have zero size don't make sense to sort */
-    if (len == 0) {
-        return 0;
-    }
-
-    for (;;) {
-        if (NPY_UNLIKELY(cdepth < 0)) {
-            aheapsort_@suff@(vv, pl, pr - pl + 1, varr);
-            goto stack_pop;
-        }
-        while ((pr - pl) > SMALL_QUICKSORT) {
-            /* quicksort partition */
-            pm = pl + ((pr - pl) >> 1);
-            if (@TYPE@_LT(v + (*pm)*len, v + (*pl)*len, len)) INTP_SWAP(*pm, *pl);
-            if (@TYPE@_LT(v + (*pr)*len, v + (*pm)*len, len)) INTP_SWAP(*pr, *pm);
-            if (@TYPE@_LT(v + (*pm)*len, v + (*pl)*len, len)) INTP_SWAP(*pm, *pl);
-            vp = v + (*pm)*len;
-            pi = pl;
-            pj = pr - 1;
-            INTP_SWAP(*pm,*pj);
-            for (;;) {
-                do ++pi; while (@TYPE@_LT(v + (*pi)*len, vp, len));
-                do --pj; while (@TYPE@_LT(vp, v + (*pj)*len, len));
-                if (pi >= pj) {
-                    break;
-                }
-                INTP_SWAP(*pi,*pj);
-            }
-            pk = pr - 1;
-            INTP_SWAP(*pi,*pk);
-            /* push largest partition on stack */
-            if (pi - pl < pr - pi) {
-                *sptr++ = pi + 1;
-                *sptr++ = pr;
-                pr = pi - 1;
-            }
-            else {
-                *sptr++ = pl;
-                *sptr++ = pi - 1;
-                pl = pi + 1;
-            }
-            *psdepth++ = --cdepth;
-        }
-
-        /* insertion sort */
-        for (pi = pl + 1; pi <= pr; ++pi) {
-            vi = *pi;
-            vp = v + vi*len;
-            pj = pi;
-            pk = pi - 1;
-            while (pj > pl && @TYPE@_LT(vp, v + (*pk)*len, len)) {
-                *pj-- = *pk--;
-            }
-            *pj = vi;
-        }
-stack_pop:
-        if (sptr == stack) {
-            break;
-        }
-        pr = *(--sptr);
-        pl = *(--sptr);
-        cdepth = *(--psdepth);
-    }
-
-    return 0;
-}
-
-/**end repeat**/
-
-
-/*
- *****************************************************************************
- **                             GENERIC SORT                                **
- *****************************************************************************
- */
-
-
-NPY_NO_EXPORT int
-npy_quicksort(void *start, npy_intp num, void *varr)
-{
-    PyArrayObject *arr = varr;
-    npy_intp elsize = PyArray_ITEMSIZE(arr);
-    PyArray_CompareFunc *cmp = PyArray_DESCR(arr)->f->compare;
-    char *vp;
-    char *pl = start;
-    char *pr = pl + (num - 1)*elsize;
-    char *stack[PYA_QS_STACK];
-    char **sptr = stack;
-    char *pm, *pi, *pj, *pk;
-    int depth[PYA_QS_STACK];
-    int * psdepth = depth;
-    int cdepth = npy_get_msb(num) * 2;
-
-    /* Items that have zero size don't make sense to sort */
-    if (elsize == 0) {
-        return 0;
-    }
-
-    vp = malloc(elsize);
-    if (vp == NULL) {
-        return -NPY_ENOMEM;
-    }
-
-    for (;;) {
-        if (NPY_UNLIKELY(cdepth < 0)) {
-            npy_heapsort(pl, (pr - pl) / elsize + 1, varr);
-            goto stack_pop;
-        }
-        while(pr - pl > SMALL_QUICKSORT*elsize) {
-            /* quicksort partition */
-            pm = pl + (((pr - pl) / elsize) >> 1) * elsize;
-            if (cmp(pm, pl, arr) < 0) {
-                GENERIC_SWAP(pm, pl, elsize);
-            }
-            if (cmp(pr, pm, arr) < 0) {
-                GENERIC_SWAP(pr, pm, elsize);
-            }
-            if (cmp(pm, pl, arr) < 0) {
-                GENERIC_SWAP(pm, pl, elsize);
-            }
-            GENERIC_COPY(vp, pm, elsize);
-            pi = pl;
-            pj = pr - elsize;
-            GENERIC_SWAP(pm, pj, elsize);
-            /*
-             * Generic comparisons may be buggy, so don't rely on the sentinels
-             * to keep the pointers from going out of bounds.
-             */
-            for (;;) {
-                do {
-                    pi += elsize;
-                } while (cmp(pi, vp, arr) < 0 && pi < pj);
-                do {
-                    pj -= elsize;
-                } while (cmp(vp, pj, arr) < 0 && pi < pj);
-                if (pi >= pj) {
-                    break;
-                }
-                GENERIC_SWAP(pi, pj, elsize);
-            }
-            pk = pr - elsize;
-            GENERIC_SWAP(pi, pk, elsize);
-            /* push largest partition on stack */
-            if (pi - pl < pr - pi) {
-                *sptr++ = pi + elsize;
-                *sptr++ = pr;
-                pr = pi - elsize;
-            }
-            else {
-                *sptr++ = pl;
-                *sptr++ = pi - elsize;
-                pl = pi + elsize;
-            }
-            *psdepth++ = --cdepth;
-        }
-
-        /* insertion sort */
-        for (pi = pl + elsize; pi <= pr; pi += elsize) {
-            GENERIC_COPY(vp, pi, elsize);
-            pj = pi;
-            pk = pi - elsize;
-            while (pj > pl && cmp(vp, pk, arr) < 0) {
-                GENERIC_COPY(pj, pk, elsize);
-                pj -= elsize;
-                pk -= elsize;
-            }
-            GENERIC_COPY(pj, vp, elsize);
-        }
-stack_pop:
-        if (sptr == stack) {
-            break;
-        }
-        pr = *(--sptr);
-        pl = *(--sptr);
-        cdepth = *(--psdepth);
-    }
-
-    free(vp);
-    return 0;
-}
-
-
-NPY_NO_EXPORT int
-npy_aquicksort(void *vv, npy_intp* tosort, npy_intp num, void *varr)
-{
-    char *v = vv;
-    PyArrayObject *arr = varr;
-    npy_intp elsize = PyArray_ITEMSIZE(arr);
-    PyArray_CompareFunc *cmp = PyArray_DESCR(arr)->f->compare;
-    char *vp;
-    npy_intp *pl = tosort;
-    npy_intp *pr = tosort + num - 1;
-    npy_intp *stack[PYA_QS_STACK];
-    npy_intp **sptr = stack;
-    npy_intp *pm, *pi, *pj, *pk, vi;
-    int depth[PYA_QS_STACK];
-    int * psdepth = depth;
-    int cdepth = npy_get_msb(num) * 2;
-
-    /* Items that have zero size don't make sense to sort */
-    if (elsize == 0) {
-        return 0;
-    }
-
-    for (;;) {
-        if (NPY_UNLIKELY(cdepth < 0)) {
-            npy_aheapsort(vv, pl, pr - pl + 1, varr);
-            goto stack_pop;
-        }
-        while ((pr - pl) > SMALL_QUICKSORT) {
-            /* quicksort partition */
-            pm = pl + ((pr - pl) >> 1);
-            if (cmp(v + (*pm)*elsize, v + (*pl)*elsize, arr) < 0) {
-                INTP_SWAP(*pm, *pl);
-            }
-            if (cmp(v + (*pr)*elsize, v + (*pm)*elsize, arr) < 0) {
-                INTP_SWAP(*pr, *pm);
-            }
-            if (cmp(v + (*pm)*elsize, v + (*pl)*elsize, arr) < 0) {
-                INTP_SWAP(*pm, *pl);
-            }
-            vp = v + (*pm)*elsize;
-            pi = pl;
-            pj = pr - 1;
-            INTP_SWAP(*pm,*pj);
-            for (;;) {
-                do {
-                    ++pi;
-                } while (cmp(v + (*pi)*elsize, vp, arr) < 0 && pi < pj);
-                do {
-                    --pj;
-                } while (cmp(vp, v + (*pj)*elsize, arr) < 0 && pi < pj);
-                if (pi >= pj) {
-                    break;
-                }
-                INTP_SWAP(*pi,*pj);
-            }
-            pk = pr - 1;
-            INTP_SWAP(*pi,*pk);
-            /* push largest partition on stack */
-            if (pi - pl < pr - pi) {
-                *sptr++ = pi + 1;
-                *sptr++ = pr;
-                pr = pi - 1;
-            }
-            else {
-                *sptr++ = pl;
-                *sptr++ = pi - 1;
-                pl = pi + 1;
-            }
-            *psdepth++ = --cdepth;
-        }
-
-        /* insertion sort */
-        for (pi = pl + 1; pi <= pr; ++pi) {
-            vi = *pi;
-            vp = v + vi*elsize;
-            pj = pi;
-            pk = pi - 1;
-            while (pj > pl && cmp(vp, v + (*pk)*elsize, arr) < 0) {
-                *pj-- = *pk--;
-            }
-            *pj = vi;
-        }
-stack_pop:
-        if (sptr == stack) {
-            break;
-        }
-        pr = *(--sptr);
-        pl = *(--sptr);
-        cdepth = *(--psdepth);
-    }
-
-    return 0;
-}
diff --git a/numpy/core/src/npysort/quicksort.cpp b/numpy/core/src/npysort/quicksort.cpp
new file mode 100644
index 000000000000..3e351dd846c0
--- /dev/null
+++ b/numpy/core/src/npysort/quicksort.cpp
@@ -0,0 +1,952 @@
+/* -*- c -*- */
+
+/*
+ * The purpose of this module is to add faster sort functions
+ * that are type-specific.  This is done by altering the
+ * function table for the builtin descriptors.
+ *
+ * These sorting functions are copied almost directly from numarray
+ * with a few modifications (complex comparisons compare the imaginary
+ * part if the real parts are equal, for example), and the names
+ * are changed.
+ *
+ * The original sorting code is due to Charles R. Harris who wrote
+ * it for numarray.
+ */
+
+/*
+ * Quick sort is usually the fastest, but the worst case scenario is O(N^2) so
+ * the code switches to the O(NlogN) worst case heapsort if not enough progress
+ * is made on the large side of the two quicksort partitions. This improves the
+ * worst case while still retaining the speed of quicksort for the common case.
+ * This is variant known as introsort.
+ *
+ *
+ * def introsort(lower, higher, recursion_limit=log2(higher - lower + 1) * 2):
+ *   # sort remainder with heapsort if we are not making enough progress
+ *   # we arbitrarily choose 2 * log(n) as the cutoff point
+ *   if recursion_limit < 0:
+ *       heapsort(lower, higher)
+ *       return
+ *
+ *   if lower < higher:
+ *      pivot_pos = partition(lower, higher)
+ *      # recurse into smaller first and leave larger on stack
+ *      # this limits the required stack space
+ *      if (pivot_pos - lower > higher - pivot_pos):
+ *          quicksort(pivot_pos + 1, higher, recursion_limit - 1)
+ *          quicksort(lower, pivot_pos, recursion_limit - 1)
+ *      else:
+ *          quicksort(lower, pivot_pos, recursion_limit - 1)
+ *          quicksort(pivot_pos + 1, higher, recursion_limit - 1)
+ *
+ *
+ * the below code implements this converted to an iteration and as an
+ * additional minor optimization skips the recursion depth checking on the
+ * smaller partition as it is always less than half of the remaining data and
+ * will thus terminate fast enough
+ */
+
+#define NPY_NO_DEPRECATED_API NPY_API_VERSION
+
+#include "npy_cpu_features.h"
+#include "npy_sort.h"
+#include "npysort_common.h"
+#include "npysort_heapsort.h"
+#include "numpy_tag.h"
+
+#include "x86-qsort.h"
+#include 
+#include 
+
+#ifndef NPY_DISABLE_OPTIMIZATION
+#include "x86-qsort.dispatch.h"
+#endif
+
+#define NOT_USED NPY_UNUSED(unused)
+/*
+ * pushing largest partition has upper bound of log2(n) space
+ * we store two pointers each time
+ */
+#define PYA_QS_STACK (NPY_BITSOF_INTP * 2)
+#define SMALL_QUICKSORT 15
+#define SMALL_MERGESORT 20
+#define SMALL_STRING 16
+
+/*
+ *****************************************************************************
+ **                            NUMERIC SORTS                                **
+ *****************************************************************************
+ */
+
+namespace {
+
+template 
+struct x86_dispatch {
+    static bool quicksort(typename Tag::type *, npy_intp) { return false; }
+};
+
+template <>
+struct x86_dispatch {
+    static bool quicksort(npy_int *start, npy_intp num)
+    {
+        void (*dispfunc)(void *, npy_intp) = nullptr;
+        NPY_CPU_DISPATCH_CALL_XB(dispfunc = x86_quicksort_int);
+        if (dispfunc) {
+            (*dispfunc)(start, num);
+            return true;
+        }
+        return false;
+    }
+};
+
+template <>
+struct x86_dispatch {
+    static bool quicksort(npy_uint *start, npy_intp num)
+    {
+        void (*dispfunc)(void *, npy_intp) = nullptr;
+        NPY_CPU_DISPATCH_CALL_XB(dispfunc = x86_quicksort_uint);
+        if (dispfunc) {
+            (*dispfunc)(start, num);
+            return true;
+        }
+        return false;
+    }
+};
+
+template <>
+struct x86_dispatch {
+    static bool quicksort(npy_float *start, npy_intp num)
+    {
+        void (*dispfunc)(void *, npy_intp) = nullptr;
+        NPY_CPU_DISPATCH_CALL_XB(dispfunc = x86_quicksort_float);
+        if (dispfunc) {
+            (*dispfunc)(start, num);
+            return true;
+        }
+        return false;
+    }
+};
+
+}  // namespace
+
+template 
+static int
+quicksort_(type *start, npy_intp num)
+{
+    if (x86_dispatch::quicksort(start, num))
+        return 0;
+
+    type vp;
+    type *pl = start;
+    type *pr = pl + num - 1;
+    type *stack[PYA_QS_STACK];
+    type **sptr = stack;
+    type *pm, *pi, *pj, *pk;
+    int depth[PYA_QS_STACK];
+    int *psdepth = depth;
+    int cdepth = npy_get_msb(num) * 2;
+
+    for (;;) {
+        if (NPY_UNLIKELY(cdepth < 0)) {
+            heapsort_(pl, pr - pl + 1);
+            goto stack_pop;
+        }
+        while ((pr - pl) > SMALL_QUICKSORT) {
+            /* quicksort partition */
+            pm = pl + ((pr - pl) >> 1);
+            if (Tag::less(*pm, *pl)) {
+                std::swap(*pm, *pl);
+            }
+            if (Tag::less(*pr, *pm)) {
+                std::swap(*pr, *pm);
+            }
+            if (Tag::less(*pm, *pl)) {
+                std::swap(*pm, *pl);
+            }
+            vp = *pm;
+            pi = pl;
+            pj = pr - 1;
+            std::swap(*pm, *pj);
+            for (;;) {
+                do {
+                    ++pi;
+                } while (Tag::less(*pi, vp));
+                do {
+                    --pj;
+                } while (Tag::less(vp, *pj));
+                if (pi >= pj) {
+                    break;
+                }
+                std::swap(*pi, *pj);
+            }
+            pk = pr - 1;
+            std::swap(*pi, *pk);
+            /* push largest partition on stack */
+            if (pi - pl < pr - pi) {
+                *sptr++ = pi + 1;
+                *sptr++ = pr;
+                pr = pi - 1;
+            }
+            else {
+                *sptr++ = pl;
+                *sptr++ = pi - 1;
+                pl = pi + 1;
+            }
+            *psdepth++ = --cdepth;
+        }
+
+        /* insertion sort */
+        for (pi = pl + 1; pi <= pr; ++pi) {
+            vp = *pi;
+            pj = pi;
+            pk = pi - 1;
+            while (pj > pl && Tag::less(vp, *pk)) {
+                *pj-- = *pk--;
+            }
+            *pj = vp;
+        }
+    stack_pop:
+        if (sptr == stack) {
+            break;
+        }
+        pr = *(--sptr);
+        pl = *(--sptr);
+        cdepth = *(--psdepth);
+    }
+
+    return 0;
+}
+
+template 
+static int
+aquicksort_(type *vv, npy_intp *tosort, npy_intp num)
+{
+    type *v = vv;
+    type vp;
+    npy_intp *pl = tosort;
+    npy_intp *pr = tosort + num - 1;
+    npy_intp *stack[PYA_QS_STACK];
+    npy_intp **sptr = stack;
+    npy_intp *pm, *pi, *pj, *pk, vi;
+    int depth[PYA_QS_STACK];
+    int *psdepth = depth;
+    int cdepth = npy_get_msb(num) * 2;
+
+    for (;;) {
+        if (NPY_UNLIKELY(cdepth < 0)) {
+            aheapsort_(vv, pl, pr - pl + 1);
+            goto stack_pop;
+        }
+        while ((pr - pl) > SMALL_QUICKSORT) {
+            /* quicksort partition */
+            pm = pl + ((pr - pl) >> 1);
+            if (Tag::less(v[*pm], v[*pl])) {
+                std::swap(*pm, *pl);
+            }
+            if (Tag::less(v[*pr], v[*pm])) {
+                std::swap(*pr, *pm);
+            }
+            if (Tag::less(v[*pm], v[*pl])) {
+                std::swap(*pm, *pl);
+            }
+            vp = v[*pm];
+            pi = pl;
+            pj = pr - 1;
+            std::swap(*pm, *pj);
+            for (;;) {
+                do {
+                    ++pi;
+                } while (Tag::less(v[*pi], vp));
+                do {
+                    --pj;
+                } while (Tag::less(vp, v[*pj]));
+                if (pi >= pj) {
+                    break;
+                }
+                std::swap(*pi, *pj);
+            }
+            pk = pr - 1;
+            std::swap(*pi, *pk);
+            /* push largest partition on stack */
+            if (pi - pl < pr - pi) {
+                *sptr++ = pi + 1;
+                *sptr++ = pr;
+                pr = pi - 1;
+            }
+            else {
+                *sptr++ = pl;
+                *sptr++ = pi - 1;
+                pl = pi + 1;
+            }
+            *psdepth++ = --cdepth;
+        }
+
+        /* insertion sort */
+        for (pi = pl + 1; pi <= pr; ++pi) {
+            vi = *pi;
+            vp = v[vi];
+            pj = pi;
+            pk = pi - 1;
+            while (pj > pl && Tag::less(vp, v[*pk])) {
+                *pj-- = *pk--;
+            }
+            *pj = vi;
+        }
+    stack_pop:
+        if (sptr == stack) {
+            break;
+        }
+        pr = *(--sptr);
+        pl = *(--sptr);
+        cdepth = *(--psdepth);
+    }
+
+    return 0;
+}
+
+/*
+ *****************************************************************************
+ **                             STRING SORTS                                **
+ *****************************************************************************
+ */
+
+template 
+static int
+string_quicksort_(type *start, npy_intp num, void *varr)
+{
+    PyArrayObject *arr = (PyArrayObject *)varr;
+    const size_t len = PyArray_ITEMSIZE(arr) / sizeof(type);
+    type *vp;
+    type *pl = start;
+    type *pr = pl + (num - 1) * len;
+    type *stack[PYA_QS_STACK], **sptr = stack, *pm, *pi, *pj, *pk;
+    int depth[PYA_QS_STACK];
+    int *psdepth = depth;
+    int cdepth = npy_get_msb(num) * 2;
+
+    /* Items that have zero size don't make sense to sort */
+    if (len == 0) {
+        return 0;
+    }
+
+    vp = (type *)malloc(PyArray_ITEMSIZE(arr));
+    if (vp == NULL) {
+        return -NPY_ENOMEM;
+    }
+
+    for (;;) {
+        if (NPY_UNLIKELY(cdepth < 0)) {
+            string_heapsort_(pl, (pr - pl) / len + 1, varr);
+            goto stack_pop;
+        }
+        while ((size_t)(pr - pl) > SMALL_QUICKSORT * len) {
+            /* quicksort partition */
+            pm = pl + (((pr - pl) / len) >> 1) * len;
+            if (Tag::less(pm, pl, len)) {
+                Tag::swap(pm, pl, len);
+            }
+            if (Tag::less(pr, pm, len)) {
+                Tag::swap(pr, pm, len);
+            }
+            if (Tag::less(pm, pl, len)) {
+                Tag::swap(pm, pl, len);
+            }
+            Tag::copy(vp, pm, len);
+            pi = pl;
+            pj = pr - len;
+            Tag::swap(pm, pj, len);
+            for (;;) {
+                do {
+                    pi += len;
+                } while (Tag::less(pi, vp, len));
+                do {
+                    pj -= len;
+                } while (Tag::less(vp, pj, len));
+                if (pi >= pj) {
+                    break;
+                }
+                Tag::swap(pi, pj, len);
+            }
+            pk = pr - len;
+            Tag::swap(pi, pk, len);
+            /* push largest partition on stack */
+            if (pi - pl < pr - pi) {
+                *sptr++ = pi + len;
+                *sptr++ = pr;
+                pr = pi - len;
+            }
+            else {
+                *sptr++ = pl;
+                *sptr++ = pi - len;
+                pl = pi + len;
+            }
+            *psdepth++ = --cdepth;
+        }
+
+        /* insertion sort */
+        for (pi = pl + len; pi <= pr; pi += len) {
+            Tag::copy(vp, pi, len);
+            pj = pi;
+            pk = pi - len;
+            while (pj > pl && Tag::less(vp, pk, len)) {
+                Tag::copy(pj, pk, len);
+                pj -= len;
+                pk -= len;
+            }
+            Tag::copy(pj, vp, len);
+        }
+    stack_pop:
+        if (sptr == stack) {
+            break;
+        }
+        pr = *(--sptr);
+        pl = *(--sptr);
+        cdepth = *(--psdepth);
+    }
+
+    free(vp);
+    return 0;
+}
+
+template 
+static int
+string_aquicksort_(type *vv, npy_intp *tosort, npy_intp num, void *varr)
+{
+    type *v = vv;
+    PyArrayObject *arr = (PyArrayObject *)varr;
+    size_t len = PyArray_ITEMSIZE(arr) / sizeof(type);
+    type *vp;
+    npy_intp *pl = tosort;
+    npy_intp *pr = tosort + num - 1;
+    npy_intp *stack[PYA_QS_STACK];
+    npy_intp **sptr = stack;
+    npy_intp *pm, *pi, *pj, *pk, vi;
+    int depth[PYA_QS_STACK];
+    int *psdepth = depth;
+    int cdepth = npy_get_msb(num) * 2;
+
+    /* Items that have zero size don't make sense to sort */
+    if (len == 0) {
+        return 0;
+    }
+
+    for (;;) {
+        if (NPY_UNLIKELY(cdepth < 0)) {
+            string_aheapsort_(vv, pl, pr - pl + 1, varr);
+            goto stack_pop;
+        }
+        while ((pr - pl) > SMALL_QUICKSORT) {
+            /* quicksort partition */
+            pm = pl + ((pr - pl) >> 1);
+            if (Tag::less(v + (*pm) * len, v + (*pl) * len, len)) {
+                std::swap(*pm, *pl);
+            }
+            if (Tag::less(v + (*pr) * len, v + (*pm) * len, len)) {
+                std::swap(*pr, *pm);
+            }
+            if (Tag::less(v + (*pm) * len, v + (*pl) * len, len)) {
+                std::swap(*pm, *pl);
+            }
+            vp = v + (*pm) * len;
+            pi = pl;
+            pj = pr - 1;
+            std::swap(*pm, *pj);
+            for (;;) {
+                do {
+                    ++pi;
+                } while (Tag::less(v + (*pi) * len, vp, len));
+                do {
+                    --pj;
+                } while (Tag::less(vp, v + (*pj) * len, len));
+                if (pi >= pj) {
+                    break;
+                }
+                std::swap(*pi, *pj);
+            }
+            pk = pr - 1;
+            std::swap(*pi, *pk);
+            /* push largest partition on stack */
+            if (pi - pl < pr - pi) {
+                *sptr++ = pi + 1;
+                *sptr++ = pr;
+                pr = pi - 1;
+            }
+            else {
+                *sptr++ = pl;
+                *sptr++ = pi - 1;
+                pl = pi + 1;
+            }
+            *psdepth++ = --cdepth;
+        }
+
+        /* insertion sort */
+        for (pi = pl + 1; pi <= pr; ++pi) {
+            vi = *pi;
+            vp = v + vi * len;
+            pj = pi;
+            pk = pi - 1;
+            while (pj > pl && Tag::less(vp, v + (*pk) * len, len)) {
+                *pj-- = *pk--;
+            }
+            *pj = vi;
+        }
+    stack_pop:
+        if (sptr == stack) {
+            break;
+        }
+        pr = *(--sptr);
+        pl = *(--sptr);
+        cdepth = *(--psdepth);
+    }
+
+    return 0;
+}
+
+/*
+ *****************************************************************************
+ **                             GENERIC SORT                                **
+ *****************************************************************************
+ */
+
+NPY_NO_EXPORT int
+npy_quicksort(void *start, npy_intp num, void *varr)
+{
+    PyArrayObject *arr = (PyArrayObject *)varr;
+    npy_intp elsize = PyArray_ITEMSIZE(arr);
+    PyArray_CompareFunc *cmp = PyArray_DESCR(arr)->f->compare;
+    char *vp;
+    char *pl = (char *)start;
+    char *pr = pl + (num - 1) * elsize;
+    char *stack[PYA_QS_STACK];
+    char **sptr = stack;
+    char *pm, *pi, *pj, *pk;
+    int depth[PYA_QS_STACK];
+    int *psdepth = depth;
+    int cdepth = npy_get_msb(num) * 2;
+
+    /* Items that have zero size don't make sense to sort */
+    if (elsize == 0) {
+        return 0;
+    }
+
+    vp = (char *)malloc(elsize);
+    if (vp == NULL) {
+        return -NPY_ENOMEM;
+    }
+
+    for (;;) {
+        if (NPY_UNLIKELY(cdepth < 0)) {
+            npy_heapsort(pl, (pr - pl) / elsize + 1, varr);
+            goto stack_pop;
+        }
+        while (pr - pl > SMALL_QUICKSORT * elsize) {
+            /* quicksort partition */
+            pm = pl + (((pr - pl) / elsize) >> 1) * elsize;
+            if (cmp(pm, pl, arr) < 0) {
+                GENERIC_SWAP(pm, pl, elsize);
+            }
+            if (cmp(pr, pm, arr) < 0) {
+                GENERIC_SWAP(pr, pm, elsize);
+            }
+            if (cmp(pm, pl, arr) < 0) {
+                GENERIC_SWAP(pm, pl, elsize);
+            }
+            GENERIC_COPY(vp, pm, elsize);
+            pi = pl;
+            pj = pr - elsize;
+            GENERIC_SWAP(pm, pj, elsize);
+            /*
+             * Generic comparisons may be buggy, so don't rely on the sentinels
+             * to keep the pointers from going out of bounds.
+             */
+            for (;;) {
+                do {
+                    pi += elsize;
+                } while (cmp(pi, vp, arr) < 0 && pi < pj);
+                do {
+                    pj -= elsize;
+                } while (cmp(vp, pj, arr) < 0 && pi < pj);
+                if (pi >= pj) {
+                    break;
+                }
+                GENERIC_SWAP(pi, pj, elsize);
+            }
+            pk = pr - elsize;
+            GENERIC_SWAP(pi, pk, elsize);
+            /* push largest partition on stack */
+            if (pi - pl < pr - pi) {
+                *sptr++ = pi + elsize;
+                *sptr++ = pr;
+                pr = pi - elsize;
+            }
+            else {
+                *sptr++ = pl;
+                *sptr++ = pi - elsize;
+                pl = pi + elsize;
+            }
+            *psdepth++ = --cdepth;
+        }
+
+        /* insertion sort */
+        for (pi = pl + elsize; pi <= pr; pi += elsize) {
+            GENERIC_COPY(vp, pi, elsize);
+            pj = pi;
+            pk = pi - elsize;
+            while (pj > pl && cmp(vp, pk, arr) < 0) {
+                GENERIC_COPY(pj, pk, elsize);
+                pj -= elsize;
+                pk -= elsize;
+            }
+            GENERIC_COPY(pj, vp, elsize);
+        }
+    stack_pop:
+        if (sptr == stack) {
+            break;
+        }
+        pr = *(--sptr);
+        pl = *(--sptr);
+        cdepth = *(--psdepth);
+    }
+
+    free(vp);
+    return 0;
+}
+
+NPY_NO_EXPORT int
+npy_aquicksort(void *vv, npy_intp *tosort, npy_intp num, void *varr)
+{
+    char *v = (char *)vv;
+    PyArrayObject *arr = (PyArrayObject *)varr;
+    npy_intp elsize = PyArray_ITEMSIZE(arr);
+    PyArray_CompareFunc *cmp = PyArray_DESCR(arr)->f->compare;
+    char *vp;
+    npy_intp *pl = tosort;
+    npy_intp *pr = tosort + num - 1;
+    npy_intp *stack[PYA_QS_STACK];
+    npy_intp **sptr = stack;
+    npy_intp *pm, *pi, *pj, *pk, vi;
+    int depth[PYA_QS_STACK];
+    int *psdepth = depth;
+    int cdepth = npy_get_msb(num) * 2;
+
+    /* Items that have zero size don't make sense to sort */
+    if (elsize == 0) {
+        return 0;
+    }
+
+    for (;;) {
+        if (NPY_UNLIKELY(cdepth < 0)) {
+            npy_aheapsort(vv, pl, pr - pl + 1, varr);
+            goto stack_pop;
+        }
+        while ((pr - pl) > SMALL_QUICKSORT) {
+            /* quicksort partition */
+            pm = pl + ((pr - pl) >> 1);
+            if (cmp(v + (*pm) * elsize, v + (*pl) * elsize, arr) < 0) {
+                INTP_SWAP(*pm, *pl);
+            }
+            if (cmp(v + (*pr) * elsize, v + (*pm) * elsize, arr) < 0) {
+                INTP_SWAP(*pr, *pm);
+            }
+            if (cmp(v + (*pm) * elsize, v + (*pl) * elsize, arr) < 0) {
+                INTP_SWAP(*pm, *pl);
+            }
+            vp = v + (*pm) * elsize;
+            pi = pl;
+            pj = pr - 1;
+            INTP_SWAP(*pm, *pj);
+            for (;;) {
+                do {
+                    ++pi;
+                } while (cmp(v + (*pi) * elsize, vp, arr) < 0 && pi < pj);
+                do {
+                    --pj;
+                } while (cmp(vp, v + (*pj) * elsize, arr) < 0 && pi < pj);
+                if (pi >= pj) {
+                    break;
+                }
+                INTP_SWAP(*pi, *pj);
+            }
+            pk = pr - 1;
+            INTP_SWAP(*pi, *pk);
+            /* push largest partition on stack */
+            if (pi - pl < pr - pi) {
+                *sptr++ = pi + 1;
+                *sptr++ = pr;
+                pr = pi - 1;
+            }
+            else {
+                *sptr++ = pl;
+                *sptr++ = pi - 1;
+                pl = pi + 1;
+            }
+            *psdepth++ = --cdepth;
+        }
+
+        /* insertion sort */
+        for (pi = pl + 1; pi <= pr; ++pi) {
+            vi = *pi;
+            vp = v + vi * elsize;
+            pj = pi;
+            pk = pi - 1;
+            while (pj > pl && cmp(vp, v + (*pk) * elsize, arr) < 0) {
+                *pj-- = *pk--;
+            }
+            *pj = vi;
+        }
+    stack_pop:
+        if (sptr == stack) {
+            break;
+        }
+        pr = *(--sptr);
+        pl = *(--sptr);
+        cdepth = *(--psdepth);
+    }
+
+    return 0;
+}
+
+/***************************************
+ * C > C++ dispatch
+ ***************************************/
+
+NPY_NO_EXPORT int
+quicksort_bool(void *start, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return quicksort_((npy_bool *)start, n);
+}
+NPY_NO_EXPORT int
+quicksort_byte(void *start, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return quicksort_((npy_byte *)start, n);
+}
+NPY_NO_EXPORT int
+quicksort_ubyte(void *start, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return quicksort_((npy_ubyte *)start, n);
+}
+NPY_NO_EXPORT int
+quicksort_short(void *start, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return quicksort_((npy_short *)start, n);
+}
+NPY_NO_EXPORT int
+quicksort_ushort(void *start, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return quicksort_((npy_ushort *)start, n);
+}
+NPY_NO_EXPORT int
+quicksort_int(void *start, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return quicksort_((npy_int *)start, n);
+}
+NPY_NO_EXPORT int
+quicksort_uint(void *start, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return quicksort_((npy_uint *)start, n);
+}
+NPY_NO_EXPORT int
+quicksort_long(void *start, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return quicksort_((npy_long *)start, n);
+}
+NPY_NO_EXPORT int
+quicksort_ulong(void *start, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return quicksort_((npy_ulong *)start, n);
+}
+NPY_NO_EXPORT int
+quicksort_longlong(void *start, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return quicksort_((npy_longlong *)start, n);
+}
+NPY_NO_EXPORT int
+quicksort_ulonglong(void *start, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return quicksort_((npy_ulonglong *)start, n);
+}
+NPY_NO_EXPORT int
+quicksort_half(void *start, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return quicksort_((npy_half *)start, n);
+}
+NPY_NO_EXPORT int
+quicksort_float(void *start, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return quicksort_((npy_float *)start, n);
+}
+NPY_NO_EXPORT int
+quicksort_double(void *start, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return quicksort_((npy_double *)start, n);
+}
+NPY_NO_EXPORT int
+quicksort_longdouble(void *start, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return quicksort_((npy_longdouble *)start, n);
+}
+NPY_NO_EXPORT int
+quicksort_cfloat(void *start, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return quicksort_((npy_cfloat *)start, n);
+}
+NPY_NO_EXPORT int
+quicksort_cdouble(void *start, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return quicksort_((npy_cdouble *)start, n);
+}
+NPY_NO_EXPORT int
+quicksort_clongdouble(void *start, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return quicksort_((npy_clongdouble *)start, n);
+}
+NPY_NO_EXPORT int
+quicksort_datetime(void *start, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return quicksort_((npy_datetime *)start, n);
+}
+NPY_NO_EXPORT int
+quicksort_timedelta(void *start, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return quicksort_((npy_timedelta *)start, n);
+}
+
+NPY_NO_EXPORT int
+aquicksort_bool(void *vv, npy_intp *tosort, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return aquicksort_((npy_bool *)vv, tosort, n);
+}
+NPY_NO_EXPORT int
+aquicksort_byte(void *vv, npy_intp *tosort, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return aquicksort_((npy_byte *)vv, tosort, n);
+}
+NPY_NO_EXPORT int
+aquicksort_ubyte(void *vv, npy_intp *tosort, npy_intp n,
+                 void *NPY_UNUSED(varr))
+{
+    return aquicksort_((npy_ubyte *)vv, tosort, n);
+}
+NPY_NO_EXPORT int
+aquicksort_short(void *vv, npy_intp *tosort, npy_intp n,
+                 void *NPY_UNUSED(varr))
+{
+    return aquicksort_((npy_short *)vv, tosort, n);
+}
+NPY_NO_EXPORT int
+aquicksort_ushort(void *vv, npy_intp *tosort, npy_intp n,
+                  void *NPY_UNUSED(varr))
+{
+    return aquicksort_((npy_ushort *)vv, tosort, n);
+}
+NPY_NO_EXPORT int
+aquicksort_int(void *vv, npy_intp *tosort, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return aquicksort_((npy_int *)vv, tosort, n);
+}
+NPY_NO_EXPORT int
+aquicksort_uint(void *vv, npy_intp *tosort, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return aquicksort_((npy_uint *)vv, tosort, n);
+}
+NPY_NO_EXPORT int
+aquicksort_long(void *vv, npy_intp *tosort, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return aquicksort_((npy_long *)vv, tosort, n);
+}
+NPY_NO_EXPORT int
+aquicksort_ulong(void *vv, npy_intp *tosort, npy_intp n,
+                 void *NPY_UNUSED(varr))
+{
+    return aquicksort_((npy_ulong *)vv, tosort, n);
+}
+NPY_NO_EXPORT int
+aquicksort_longlong(void *vv, npy_intp *tosort, npy_intp n,
+                    void *NPY_UNUSED(varr))
+{
+    return aquicksort_((npy_longlong *)vv, tosort, n);
+}
+NPY_NO_EXPORT int
+aquicksort_ulonglong(void *vv, npy_intp *tosort, npy_intp n,
+                     void *NPY_UNUSED(varr))
+{
+    return aquicksort_((npy_ulonglong *)vv, tosort, n);
+}
+NPY_NO_EXPORT int
+aquicksort_half(void *vv, npy_intp *tosort, npy_intp n, void *NPY_UNUSED(varr))
+{
+    return aquicksort_((npy_half *)vv, tosort, n);
+}
+NPY_NO_EXPORT int
+aquicksort_float(void *vv, npy_intp *tosort, npy_intp n,
+                 void *NPY_UNUSED(varr))
+{
+    return aquicksort_((npy_float *)vv, tosort, n);
+}
+NPY_NO_EXPORT int
+aquicksort_double(void *vv, npy_intp *tosort, npy_intp n,
+                  void *NPY_UNUSED(varr))
+{
+    return aquicksort_((npy_double *)vv, tosort, n);
+}
+NPY_NO_EXPORT int
+aquicksort_longdouble(void *vv, npy_intp *tosort, npy_intp n,
+                      void *NPY_UNUSED(varr))
+{
+    return aquicksort_((npy_longdouble *)vv, tosort, n);
+}
+NPY_NO_EXPORT int
+aquicksort_cfloat(void *vv, npy_intp *tosort, npy_intp n,
+                  void *NPY_UNUSED(varr))
+{
+    return aquicksort_((npy_cfloat *)vv, tosort, n);
+}
+NPY_NO_EXPORT int
+aquicksort_cdouble(void *vv, npy_intp *tosort, npy_intp n,
+                   void *NPY_UNUSED(varr))
+{
+    return aquicksort_((npy_cdouble *)vv, tosort, n);
+}
+NPY_NO_EXPORT int
+aquicksort_clongdouble(void *vv, npy_intp *tosort, npy_intp n,
+                       void *NPY_UNUSED(varr))
+{
+    return aquicksort_((npy_clongdouble *)vv, tosort, n);
+}
+NPY_NO_EXPORT int
+aquicksort_datetime(void *vv, npy_intp *tosort, npy_intp n,
+                    void *NPY_UNUSED(varr))
+{
+    return aquicksort_((npy_datetime *)vv, tosort, n);
+}
+NPY_NO_EXPORT int
+aquicksort_timedelta(void *vv, npy_intp *tosort, npy_intp n,
+                     void *NPY_UNUSED(varr))
+{
+    return aquicksort_((npy_timedelta *)vv, tosort, n);
+}
+
+NPY_NO_EXPORT int
+quicksort_string(void *start, npy_intp n, void *varr)
+{
+    return string_quicksort_((npy_char *)start, n, varr);
+}
+NPY_NO_EXPORT int
+quicksort_unicode(void *start, npy_intp n, void *varr)
+{
+    return string_quicksort_((npy_ucs4 *)start, n, varr);
+}
+
+NPY_NO_EXPORT int
+aquicksort_string(void *vv, npy_intp *tosort, npy_intp n, void *varr)
+{
+    return string_aquicksort_((npy_char *)vv, tosort, n,
+                                               varr);
+}
+NPY_NO_EXPORT int
+aquicksort_unicode(void *vv, npy_intp *tosort, npy_intp n, void *varr)
+{
+    return string_aquicksort_((npy_ucs4 *)vv, tosort, n,
+                                                varr);
+}
diff --git a/numpy/core/src/npysort/radixsort.cpp b/numpy/core/src/npysort/radixsort.cpp
index 017ea43b6bed..0e1a41c69cbe 100644
--- a/numpy/core/src/npysort/radixsort.cpp
+++ b/numpy/core/src/npysort/radixsort.cpp
@@ -4,7 +4,7 @@
 #include "npysort_common.h"
 
 #include "../common/numpy_tag.h"
-#include 
+#include 
 #include 
 
 /*
@@ -14,9 +14,9 @@
  */
 
 // Reference: https://github.com/eloj/radix-sorting#-key-derivation
-template 
-T
-KEY_OF(T x)
+template 
+UT
+KEY_OF(UT x)
 {
     // Floating-point is currently disabled.
     // Floating-point tests succeed for double and float on macOS but not on
@@ -27,12 +27,12 @@ KEY_OF(T x)
         // For floats, we invert the key if the sign bit is set, else we invert
         // the sign bit.
         return ((x) ^ (-((x) >> (sizeof(T) * 8 - 1)) |
-                       ((T)1 << (sizeof(T) * 8 - 1))));
+                       ((UT)1 << (sizeof(T) * 8 - 1))));
     }
     else if (std::is_signed::value) {
         // For signed ints, we flip the sign bit so the negatives are below the
         // positives.
-        return ((x) ^ ((T)1 << (sizeof(T) * 8 - 1)));
+        return ((x) ^ ((UT)1 << (sizeof(UT) * 8 - 1)));
     }
     else {
         return x;
@@ -46,24 +46,24 @@ nth_byte(T key, npy_intp l)
     return (key >> (l << 3)) & 0xFF;
 }
 
-template 
-static T *
-radixsort0(T *start, T *aux, npy_intp num)
+template 
+static UT *
+radixsort0(UT *start, UT *aux, npy_intp num)
 {
-    npy_intp cnt[sizeof(T)][1 << 8] = {{0}};
-    T key0 = KEY_OF(start[0]);
+    npy_intp cnt[sizeof(UT)][1 << 8] = {{0}};
+    UT key0 = KEY_OF(start[0]);
 
     for (npy_intp i = 0; i < num; i++) {
-        T k = KEY_OF(start[i]);
+        UT k = KEY_OF(start[i]);
 
-        for (size_t l = 0; l < sizeof(T); l++) {
+        for (size_t l = 0; l < sizeof(UT); l++) {
             cnt[l][nth_byte(k, l)]++;
         }
     }
 
     size_t ncols = 0;
-    npy_ubyte cols[sizeof(T)];
-    for (size_t l = 0; l < sizeof(T); l++) {
+    npy_ubyte cols[sizeof(UT)];
+    for (size_t l = 0; l < sizeof(UT); l++) {
         if (cnt[l][nth_byte(key0, l)] != num) {
             cols[ncols++] = l;
         }
@@ -79,9 +79,9 @@ radixsort0(T *start, T *aux, npy_intp num)
     }
 
     for (size_t l = 0; l < ncols; l++) {
-        T *temp;
+        UT *temp;
         for (npy_intp i = 0; i < num; i++) {
-            T k = KEY_OF(start[i]);
+            UT k = KEY_OF(start[i]);
             npy_intp dst = cnt[cols[l]][nth_byte(k, cols[l])]++;
             aux[dst] = start[i];
         }
@@ -94,18 +94,18 @@ radixsort0(T *start, T *aux, npy_intp num)
     return start;
 }
 
-template 
+template 
 static int
-radixsort_(T *start, npy_intp num)
+radixsort_(UT *start, npy_intp num)
 {
     if (num < 2) {
         return 0;
     }
 
     npy_bool all_sorted = 1;
-    T k1 = KEY_OF(start[0]), k2;
+    UT k1 = KEY_OF(start[0]);
     for (npy_intp i = 1; i < num; i++) {
-        k2 = KEY_OF(start[i]);
+        UT k2 = KEY_OF(start[i]);
         if (k1 > k2) {
             all_sorted = 0;
             break;
@@ -117,14 +117,14 @@ radixsort_(T *start, npy_intp num)
         return 0;
     }
 
-    T *aux = (T *)malloc(num * sizeof(T));
+    UT *aux = (UT *)malloc(num * sizeof(UT));
     if (aux == nullptr) {
         return -NPY_ENOMEM;
     }
 
-    T *sorted = radixsort0(start, aux, num);
+    UT *sorted = radixsort0(start, aux, num);
     if (sorted != start) {
-        memcpy(start, sorted, num * sizeof(T));
+        memcpy(start, sorted, num * sizeof(UT));
     }
 
     free(aux);
@@ -135,27 +135,28 @@ template 
 static int
 radixsort(void *start, npy_intp num)
 {
-    return radixsort_((T *)start, num);
+    using UT = typename std::make_unsigned::type;
+    return radixsort_((UT *)start, num);
 }
 
-template 
+template 
 static npy_intp *
-aradixsort0(T *start, npy_intp *aux, npy_intp *tosort, npy_intp num)
+aradixsort0(UT *start, npy_intp *aux, npy_intp *tosort, npy_intp num)
 {
-    npy_intp cnt[sizeof(T)][1 << 8] = {{0}};
-    T key0 = KEY_OF(start[0]);
+    npy_intp cnt[sizeof(UT)][1 << 8] = {{0}};
+    UT key0 = KEY_OF(start[0]);
 
     for (npy_intp i = 0; i < num; i++) {
-        T k = KEY_OF(start[i]);
+        UT k = KEY_OF(start[i]);
 
-        for (size_t l = 0; l < sizeof(T); l++) {
+        for (size_t l = 0; l < sizeof(UT); l++) {
             cnt[l][nth_byte(k, l)]++;
         }
     }
 
     size_t ncols = 0;
-    npy_ubyte cols[sizeof(T)];
-    for (size_t l = 0; l < sizeof(T); l++) {
+    npy_ubyte cols[sizeof(UT)];
+    for (size_t l = 0; l < sizeof(UT); l++) {
         if (cnt[l][nth_byte(key0, l)] != num) {
             cols[ncols++] = l;
         }
@@ -173,7 +174,7 @@ aradixsort0(T *start, npy_intp *aux, npy_intp *tosort, npy_intp num)
     for (size_t l = 0; l < ncols; l++) {
         npy_intp *temp;
         for (npy_intp i = 0; i < num; i++) {
-            T k = KEY_OF(start[tosort[i]]);
+            UT k = KEY_OF(start[tosort[i]]);
             npy_intp dst = cnt[cols[l]][nth_byte(k, cols[l])]++;
             aux[dst] = tosort[i];
         }
@@ -186,22 +187,22 @@ aradixsort0(T *start, npy_intp *aux, npy_intp *tosort, npy_intp num)
     return tosort;
 }
 
-template 
+template 
 static int
-aradixsort_(T *start, npy_intp *tosort, npy_intp num)
+aradixsort_(UT *start, npy_intp *tosort, npy_intp num)
 {
     npy_intp *sorted;
     npy_intp *aux;
-    T k1, k2;
+    UT k1, k2;
     npy_bool all_sorted = 1;
 
     if (num < 2) {
         return 0;
     }
 
-    k1 = KEY_OF(start[tosort[0]]);
+    k1 = KEY_OF(start[tosort[0]]);
     for (npy_intp i = 1; i < num; i++) {
-        k2 = KEY_OF(start[tosort[i]]);
+        k2 = KEY_OF(start[tosort[i]]);
         if (k1 > k2) {
             all_sorted = 0;
             break;
@@ -218,7 +219,7 @@ aradixsort_(T *start, npy_intp *tosort, npy_intp num)
         return -NPY_ENOMEM;
     }
 
-    sorted = aradixsort0(start, aux, tosort, num);
+    sorted = aradixsort0(start, aux, tosort, num);
     if (sorted != tosort) {
         memcpy(tosort, sorted, num * sizeof(npy_intp));
     }
@@ -231,7 +232,8 @@ template 
 static int
 aradixsort(void *start, npy_intp *tosort, npy_intp num)
 {
-    return aradixsort_((T *)start, tosort, num);
+    using UT = typename std::make_unsigned::type;
+    return aradixsort_((UT *)start, tosort, num);
 }
 
 extern "C" {
diff --git a/numpy/core/src/npysort/selection.c.src b/numpy/core/src/npysort/selection.c.src
deleted file mode 100644
index 0e285b320b91..000000000000
--- a/numpy/core/src/npysort/selection.c.src
+++ /dev/null
@@ -1,419 +0,0 @@
-/* -*- c -*- */
-
-/*
- *
- * The code is loosely based on the quickselect from
- * Nicolas Devillard - 1998 public domain
- * http://ndevilla.free.fr/median/median/
- *
- * Quick select with median of 3 pivot is usually the fastest,
- * but the worst case scenario can be quadratic complexity,
- * e.g. np.roll(np.arange(x), x / 2)
- * To avoid this if it recurses too much it falls back to the
- * worst case linear median of median of group 5 pivot strategy.
- */
-
-
-#define NPY_NO_DEPRECATED_API NPY_API_VERSION
-
-#include "npy_sort.h"
-#include "npysort_common.h"
-#include "numpy/npy_math.h"
-#include "npy_partition.h"
-#include 
-
-#define NOT_USED NPY_UNUSED(unused)
-
-
-/*
- *****************************************************************************
- **                            NUMERIC SORTS                                **
- *****************************************************************************
- */
-
-
-static NPY_INLINE void store_pivot(npy_intp pivot, npy_intp kth,
-                                   npy_intp * pivots, npy_intp * npiv)
-{
-    if (pivots == NULL) {
-        return;
-    }
-
-    /*
-     * If pivot is the requested kth store it, overwriting other pivots if
-     * required. This must be done so iterative partition can work without
-     * manually shifting lower data offset by kth each time
-     */
-    if (pivot == kth && *npiv == NPY_MAX_PIVOT_STACK) {
-        pivots[*npiv - 1] = pivot;
-    }
-    /*
-     * we only need pivots larger than current kth, larger pivots are not
-     * useful as partitions on smaller kth would reorder the stored pivots
-     */
-    else if (pivot >= kth && *npiv < NPY_MAX_PIVOT_STACK) {
-        pivots[*npiv] = pivot;
-        (*npiv) += 1;
-    }
-}
-
-/**begin repeat
- *
- * #TYPE = BOOL, BYTE, UBYTE, SHORT, USHORT, INT, UINT, LONG, ULONG,
- *         LONGLONG, ULONGLONG, HALF, FLOAT, DOUBLE, LONGDOUBLE,
- *         CFLOAT, CDOUBLE, CLONGDOUBLE#
- * #suff = bool, byte, ubyte, short, ushort, int, uint, long, ulong,
- *         longlong, ulonglong, half, float, double, longdouble,
- *         cfloat, cdouble, clongdouble#
- * #type = npy_bool, npy_byte, npy_ubyte, npy_short, npy_ushort, npy_int,
- *         npy_uint, npy_long, npy_ulong, npy_longlong, npy_ulonglong,
- *         npy_ushort, npy_float, npy_double, npy_longdouble, npy_cfloat,
- *         npy_cdouble, npy_clongdouble#
- * #inexact = 0*11, 1*7#
- */
-
-static npy_intp
-amedian_of_median5_@suff@(@type@ *v, npy_intp* tosort, const npy_intp num,
-                         npy_intp * pivots,
-                         npy_intp * npiv);
-
-static npy_intp
-median_of_median5_@suff@(@type@ *v, const npy_intp num,
-                         npy_intp * pivots,
-                         npy_intp * npiv);
-
-/**begin repeat1
- * #name = , a#
- * #idx = , tosort#
- * #arg = 0, 1#
- */
-#if @arg@
-/* helper macros to avoid duplication of direct/indirect selection */
-#define IDX(x) tosort[x]
-#define SORTEE(x) tosort[x]
-#define SWAP INTP_SWAP
-#define MEDIAN3_SWAP(v, tosort, low, mid, high) \
-    amedian3_swap_@suff@(v, tosort, low, mid, high)
-#define MEDIAN5(v, tosort, subleft) \
-        amedian5_@suff@(v, tosort + subleft)
-#define UNGUARDED_PARTITION(v, tosort, pivot, ll, hh) \
-        aunguarded_partition_@suff@(v, tosort, pivot, ll, hh)
-#define INTROSELECT(v, tosort, num, kth, pivots, npiv) \
-        aintroselect_@suff@(v, tosort, nmed, nmed / 2, pivots, npiv, NULL)
-#define DUMBSELECT(v, tosort, left, num, kth) \
-        adumb_select_@suff@(v, tosort + left, num, kth)
-#else
-#define IDX(x) (x)
-#define SORTEE(x) v[x]
-#define SWAP @TYPE@_SWAP
-#define MEDIAN3_SWAP(v, tosort, low, mid, high) \
-    median3_swap_@suff@(v, low, mid, high)
-#define MEDIAN5(v, tosort, subleft) \
-        median5_@suff@(v + subleft)
-#define UNGUARDED_PARTITION(v, tosort, pivot, ll, hh) \
-        unguarded_partition_@suff@(v, pivot, ll, hh)
-#define INTROSELECT(v, tosort, num, kth, pivots, npiv) \
-        introselect_@suff@(v, nmed, nmed / 2, pivots, npiv, NULL)
-#define DUMBSELECT(v, tosort, left, num, kth) \
-        dumb_select_@suff@(v + left, num, kth)
-#endif
-
-
-/*
- * median of 3 pivot strategy
- * gets min and median and moves median to low and min to low + 1
- * for efficient partitioning, see unguarded_partition
- */
-static NPY_INLINE void
-@name@median3_swap_@suff@(@type@ * v,
-#if @arg@
-                          npy_intp * tosort,
-#endif
-                          npy_intp low, npy_intp mid, npy_intp high)
-{
-    if (@TYPE@_LT(v[IDX(high)], v[IDX(mid)]))
-        SWAP(SORTEE(high), SORTEE(mid));
-    if (@TYPE@_LT(v[IDX(high)], v[IDX(low)]))
-        SWAP(SORTEE(high), SORTEE(low));
-    /* move pivot to low */
-    if (@TYPE@_LT(v[IDX(low)], v[IDX(mid)]))
-        SWAP(SORTEE(low), SORTEE(mid));
-    /* move 3-lowest element to low + 1 */
-    SWAP(SORTEE(mid), SORTEE(low + 1));
-}
-
-
-/* select index of median of five elements */
-static npy_intp @name@median5_@suff@(
-#if @arg@
-                                    const @type@ * v, npy_intp * tosort
-#else
-                                    @type@ * v
-#endif
-                                    )
-{
-    /* could be optimized as we only need the index (no swaps) */
-    if (@TYPE@_LT(v[IDX(1)], v[IDX(0)])) {
-        SWAP(SORTEE(1), SORTEE(0));
-    }
-    if (@TYPE@_LT(v[IDX(4)], v[IDX(3)])) {
-        SWAP(SORTEE(4), SORTEE(3));
-    }
-    if (@TYPE@_LT(v[IDX(3)], v[IDX(0)])) {
-        SWAP(SORTEE(3), SORTEE(0));
-    }
-    if (@TYPE@_LT(v[IDX(4)], v[IDX(1)])) {
-        SWAP(SORTEE(4), SORTEE(1));
-    }
-    if (@TYPE@_LT(v[IDX(2)], v[IDX(1)])) {
-        SWAP(SORTEE(2), SORTEE(1));
-    }
-    if (@TYPE@_LT(v[IDX(3)], v[IDX(2)])) {
-        if (@TYPE@_LT(v[IDX(3)], v[IDX(1)])) {
-            return 1;
-        }
-        else {
-            return 3;
-        }
-    }
-    else {
-        /* v[1] and v[2] swapped into order above */
-        return 2;
-    }
-}
-
-
-/*
- * partition and return the index were the pivot belongs
- * the data must have following property to avoid bound checks:
- *                  ll ... hh
- * lower-than-pivot [x x x x] larger-than-pivot
- */
-static NPY_INLINE void
-@name@unguarded_partition_@suff@(@type@ * v,
-#if @arg@
-                                 npy_intp * tosort,
-#endif
-                                 const @type@ pivot,
-                                 npy_intp * ll, npy_intp * hh)
-{
-    for (;;) {
-        do (*ll)++; while (@TYPE@_LT(v[IDX(*ll)], pivot));
-        do (*hh)--; while (@TYPE@_LT(pivot, v[IDX(*hh)]));
-
-        if (*hh < *ll)
-            break;
-
-        SWAP(SORTEE(*ll), SORTEE(*hh));
-    }
-}
-
-
-/*
- * select median of median of blocks of 5
- * if used as partition pivot it splits the range into at least 30%/70%
- * allowing linear time worstcase quickselect
- */
-static npy_intp
-@name@median_of_median5_@suff@(@type@ *v,
-#if @arg@
-                               npy_intp* tosort,
-#endif
-                               const npy_intp num,
-                               npy_intp * pivots,
-                               npy_intp * npiv)
-{
-    npy_intp i, subleft;
-    npy_intp right = num - 1;
-    npy_intp nmed = (right + 1) / 5;
-    for (i = 0, subleft = 0; i < nmed; i++, subleft += 5) {
-        npy_intp m = MEDIAN5(v, tosort, subleft);
-        SWAP(SORTEE(subleft + m), SORTEE(i));
-    }
-
-    if (nmed > 2)
-        INTROSELECT(v, tosort, nmed, nmed / 2, pivots, npiv);
-    return nmed / 2;
-}
-
-
-/*
- * N^2 selection, fast only for very small kth
- * useful for close multiple partitions
- * (e.g. even element median, interpolating percentile)
- */
-static int
-@name@dumb_select_@suff@(@type@ *v,
-#if @arg@
-                         npy_intp * tosort,
-#endif
-                         npy_intp num, npy_intp kth)
-{
-    npy_intp i;
-    for (i = 0; i <= kth; i++) {
-        npy_intp minidx = i;
-        @type@ minval = v[IDX(i)];
-        npy_intp k;
-        for (k = i + 1; k < num; k++) {
-            if (@TYPE@_LT(v[IDX(k)], minval)) {
-                minidx = k;
-                minval = v[IDX(k)];
-            }
-        }
-        SWAP(SORTEE(i), SORTEE(minidx));
-    }
-
-    return 0;
-}
-
-
-/*
- * iterative median of 3 quickselect with cutoff to median-of-medians-of5
- * receives stack of already computed pivots in v to minimize the
- * partition size were kth is searched in
- *
- * area that needs partitioning in [...]
- * kth 0:  [8  7  6  5  4  3  2  1  0] -> med3 partitions elements [4, 2, 0]
- *          0  1  2  3  4  8  7  5  6  -> pop requested kth -> stack [4, 2]
- * kth 3:   0  1  2 [3] 4  8  7  5  6  -> stack [4]
- * kth 5:   0  1  2  3  4 [8  7  5  6] -> stack [6]
- * kth 8:   0  1  2  3  4  5  6 [8  7] -> stack []
- *
- */
-NPY_NO_EXPORT int
-@name@introselect_@suff@(@type@ *v,
-#if @arg@
-                         npy_intp* tosort,
-#endif
-                         npy_intp num, npy_intp kth,
-                         npy_intp * pivots,
-                         npy_intp * npiv,
-                         void *NOT_USED)
-{
-    npy_intp low  = 0;
-    npy_intp high = num - 1;
-    int depth_limit;
-
-    if (npiv == NULL)
-        pivots = NULL;
-
-    while (pivots != NULL && *npiv > 0) {
-        if (pivots[*npiv - 1] > kth) {
-            /* pivot larger than kth set it as upper bound */
-            high = pivots[*npiv - 1] - 1;
-            break;
-        }
-        else if (pivots[*npiv - 1] == kth) {
-            /* kth was already found in a previous iteration -> done */
-            return 0;
-        }
-
-        low = pivots[*npiv - 1] + 1;
-
-        /* pop from stack */
-        *npiv -= 1;
-    }
-
-    /*
-     * use a faster O(n*kth) algorithm for very small kth
-     * e.g. for interpolating percentile
-     */
-    if (kth - low < 3) {
-        DUMBSELECT(v, tosort, low, high - low + 1, kth - low);
-        store_pivot(kth, kth, pivots, npiv);
-        return 0;
-    }
-    // Parenthesis around @inexact@ tells clang dead code as intentional
-    else if ((@inexact@) && kth == num - 1) {
-        /* useful to check if NaN present via partition(d, (x, -1)) */
-        npy_intp k;
-        npy_intp maxidx = low;
-        @type@ maxval = v[IDX(low)];
-        for (k = low + 1; k < num; k++) {
-            if (!@TYPE@_LT(v[IDX(k)], maxval)) {
-                maxidx = k;
-                maxval = v[IDX(k)];
-            }
-        }
-        SWAP(SORTEE(kth), SORTEE(maxidx));
-        return 0;
-    }
-
-    depth_limit = npy_get_msb(num) * 2;
-
-    /* guarantee three elements */
-    for (;low + 1 < high;) {
-        npy_intp       ll = low + 1;
-        npy_intp       hh = high;
-
-        /*
-         * if we aren't making sufficient progress with median of 3
-         * fall back to median-of-median5 pivot for linear worst case
-         * med3 for small sizes is required to do unguarded partition
-         */
-        if (depth_limit > 0 || hh - ll < 5) {
-            const npy_intp mid = low + (high - low) / 2;
-            /* median of 3 pivot strategy,
-             * swapping for efficient partition */
-            MEDIAN3_SWAP(v, tosort, low, mid, high);
-        }
-        else {
-            npy_intp mid;
-            /* FIXME: always use pivots to optimize this iterative partition */
-#if @arg@
-            mid = ll + amedian_of_median5_@suff@(v, tosort + ll, hh - ll, NULL, NULL);
-#else
-            mid = ll + median_of_median5_@suff@(v + ll, hh - ll, NULL, NULL);
-#endif
-            SWAP(SORTEE(mid), SORTEE(low));
-            /* adapt for the larger partition than med3 pivot */
-            ll--;
-            hh++;
-        }
-
-        depth_limit--;
-
-        /*
-         * find place to put pivot (in low):
-         * previous swapping removes need for bound checks
-         * pivot 3-lowest [x x x] 3-highest
-         */
-        UNGUARDED_PARTITION(v, tosort, v[IDX(low)], &ll, &hh);
-
-        /* move pivot into position */
-        SWAP(SORTEE(low), SORTEE(hh));
-
-        /* kth pivot stored later */
-        if (hh != kth) {
-            store_pivot(hh, kth, pivots, npiv);
-        }
-
-        if (hh >= kth)
-            high = hh - 1;
-        if (hh <= kth)
-            low = ll;
-    }
-
-    /* two elements */
-    if (high == low + 1) {
-        if (@TYPE@_LT(v[IDX(high)], v[IDX(low)])) {
-            SWAP(SORTEE(high), SORTEE(low))
-        }
-    }
-    store_pivot(kth, kth, pivots, npiv);
-
-    return 0;
-}
-
-
-#undef IDX
-#undef SWAP
-#undef SORTEE
-#undef MEDIAN3_SWAP
-#undef MEDIAN5
-#undef UNGUARDED_PARTITION
-#undef INTROSELECT
-#undef DUMBSELECT
-/**end repeat1**/
-
-/**end repeat**/
diff --git a/numpy/core/src/npysort/selection.cpp b/numpy/core/src/npysort/selection.cpp
new file mode 100644
index 000000000000..ebe188b719ca
--- /dev/null
+++ b/numpy/core/src/npysort/selection.cpp
@@ -0,0 +1,492 @@
+/* -*- c -*- */
+
+/*
+ *
+ * The code is loosely based on the quickselect from
+ * Nicolas Devillard - 1998 public domain
+ * http://ndevilla.free.fr/median/median/
+ *
+ * Quick select with median of 3 pivot is usually the fastest,
+ * but the worst case scenario can be quadratic complexity,
+ * e.g. np.roll(np.arange(x), x / 2)
+ * To avoid this if it recurses too much it falls back to the
+ * worst case linear median of median of group 5 pivot strategy.
+ */
+
+#define NPY_NO_DEPRECATED_API NPY_API_VERSION
+
+#include "numpy/npy_math.h"
+
+#include "npy_partition.h"
+#include "npy_sort.h"
+#include "npysort_common.h"
+#include "numpy_tag.h"
+
+#include 
+#include 
+#include 
+
+#define NOT_USED NPY_UNUSED(unused)
+
+template 
+NPY_NO_EXPORT int
+introselect_(type *v, npy_intp *tosort, npy_intp num, npy_intp kth,
+             npy_intp *pivots, npy_intp *npiv);
+
+/*
+ *****************************************************************************
+ **                            NUMERIC SORTS                                **
+ *****************************************************************************
+ */
+
+static inline void
+store_pivot(npy_intp pivot, npy_intp kth, npy_intp *pivots, npy_intp *npiv)
+{
+    if (pivots == NULL) {
+        return;
+    }
+
+    /*
+     * If pivot is the requested kth store it, overwriting other pivots if
+     * required. This must be done so iterative partition can work without
+     * manually shifting lower data offset by kth each time
+     */
+    if (pivot == kth && *npiv == NPY_MAX_PIVOT_STACK) {
+        pivots[*npiv - 1] = pivot;
+    }
+    /*
+     * we only need pivots larger than current kth, larger pivots are not
+     * useful as partitions on smaller kth would reorder the stored pivots
+     */
+    else if (pivot >= kth && *npiv < NPY_MAX_PIVOT_STACK) {
+        pivots[*npiv] = pivot;
+        (*npiv) += 1;
+    }
+}
+
+template 
+struct Sortee {
+    type *v;
+    Sortee(type *v, npy_intp *) : v(v) {}
+    type &operator()(npy_intp i) const { return v[i]; }
+};
+
+template 
+struct Idx {
+    Idx(npy_intp *) {}
+    npy_intp operator()(npy_intp i) const { return i; }
+};
+
+template 
+struct Sortee {
+    npy_intp *tosort;
+    Sortee(type *, npy_intp *tosort) : tosort(tosort) {}
+    npy_intp &operator()(npy_intp i) const { return tosort[i]; }
+};
+
+template <>
+struct Idx {
+    npy_intp *tosort;
+    Idx(npy_intp *tosort) : tosort(tosort) {}
+    npy_intp operator()(npy_intp i) const { return tosort[i]; }
+};
+
+template 
+static constexpr bool
+inexact()
+{
+    return !std::is_integral::value;
+}
+
+/*
+ * median of 3 pivot strategy
+ * gets min and median and moves median to low and min to low + 1
+ * for efficient partitioning, see unguarded_partition
+ */
+template 
+static inline void
+median3_swap_(type *v, npy_intp *tosort, npy_intp low, npy_intp mid,
+              npy_intp high)
+{
+    Idx idx(tosort);
+    Sortee sortee(v, tosort);
+
+    if (Tag::less(v[idx(high)], v[idx(mid)])) {
+        std::swap(sortee(high), sortee(mid));
+    }
+    if (Tag::less(v[idx(high)], v[idx(low)])) {
+        std::swap(sortee(high), sortee(low));
+    }
+    /* move pivot to low */
+    if (Tag::less(v[idx(low)], v[idx(mid)])) {
+        std::swap(sortee(low), sortee(mid));
+    }
+    /* move 3-lowest element to low + 1 */
+    std::swap(sortee(mid), sortee(low + 1));
+}
+
+/* select index of median of five elements */
+template 
+static npy_intp
+median5_(type *v, npy_intp *tosort)
+{
+    Idx idx(tosort);
+    Sortee sortee(v, tosort);
+
+    /* could be optimized as we only need the index (no swaps) */
+    if (Tag::less(v[idx(1)], v[idx(0)])) {
+        std::swap(sortee(1), sortee(0));
+    }
+    if (Tag::less(v[idx(4)], v[idx(3)])) {
+        std::swap(sortee(4), sortee(3));
+    }
+    if (Tag::less(v[idx(3)], v[idx(0)])) {
+        std::swap(sortee(3), sortee(0));
+    }
+    if (Tag::less(v[idx(4)], v[idx(1)])) {
+        std::swap(sortee(4), sortee(1));
+    }
+    if (Tag::less(v[idx(2)], v[idx(1)])) {
+        std::swap(sortee(2), sortee(1));
+    }
+    if (Tag::less(v[idx(3)], v[idx(2)])) {
+        if (Tag::less(v[idx(3)], v[idx(1)])) {
+            return 1;
+        }
+        else {
+            return 3;
+        }
+    }
+    else {
+        /* v[1] and v[2] swapped into order above */
+        return 2;
+    }
+}
+
+/*
+ * partition and return the index were the pivot belongs
+ * the data must have following property to avoid bound checks:
+ *                  ll ... hh
+ * lower-than-pivot [x x x x] larger-than-pivot
+ */
+template 
+static inline void
+unguarded_partition_(type *v, npy_intp *tosort, const type pivot, npy_intp *ll,
+                     npy_intp *hh)
+{
+    Idx idx(tosort);
+    Sortee sortee(v, tosort);
+
+    for (;;) {
+        do {
+            (*ll)++;
+        } while (Tag::less(v[idx(*ll)], pivot));
+        do {
+            (*hh)--;
+        } while (Tag::less(pivot, v[idx(*hh)]));
+
+        if (*hh < *ll) {
+            break;
+        }
+
+        std::swap(sortee(*ll), sortee(*hh));
+    }
+}
+
+/*
+ * select median of median of blocks of 5
+ * if used as partition pivot it splits the range into at least 30%/70%
+ * allowing linear time worstcase quickselect
+ */
+template 
+static npy_intp
+median_of_median5_(type *v, npy_intp *tosort, const npy_intp num,
+                   npy_intp *pivots, npy_intp *npiv)
+{
+    Idx idx(tosort);
+    Sortee sortee(v, tosort);
+
+    npy_intp i, subleft;
+    npy_intp right = num - 1;
+    npy_intp nmed = (right + 1) / 5;
+    for (i = 0, subleft = 0; i < nmed; i++, subleft += 5) {
+        npy_intp m = median5_(v + (arg ? 0 : subleft),
+                                        tosort + (arg ? subleft : 0));
+        std::swap(sortee(subleft + m), sortee(i));
+    }
+
+    if (nmed > 2) {
+        introselect_(v, tosort, nmed, nmed / 2, pivots, npiv);
+    }
+    return nmed / 2;
+}
+
+/*
+ * N^2 selection, fast only for very small kth
+ * useful for close multiple partitions
+ * (e.g. even element median, interpolating percentile)
+ */
+template 
+static int
+dumb_select_(type *v, npy_intp *tosort, npy_intp num, npy_intp kth)
+{
+    Idx idx(tosort);
+    Sortee sortee(v, tosort);
+
+    npy_intp i;
+    for (i = 0; i <= kth; i++) {
+        npy_intp minidx = i;
+        type minval = v[idx(i)];
+        npy_intp k;
+        for (k = i + 1; k < num; k++) {
+            if (Tag::less(v[idx(k)], minval)) {
+                minidx = k;
+                minval = v[idx(k)];
+            }
+        }
+        std::swap(sortee(i), sortee(minidx));
+    }
+
+    return 0;
+}
+
+/*
+ * iterative median of 3 quickselect with cutoff to median-of-medians-of5
+ * receives stack of already computed pivots in v to minimize the
+ * partition size were kth is searched in
+ *
+ * area that needs partitioning in [...]
+ * kth 0:  [8  7  6  5  4  3  2  1  0] -> med3 partitions elements [4, 2, 0]
+ *          0  1  2  3  4  8  7  5  6  -> pop requested kth -> stack [4, 2]
+ * kth 3:   0  1  2 [3] 4  8  7  5  6  -> stack [4]
+ * kth 5:   0  1  2  3  4 [8  7  5  6] -> stack [6]
+ * kth 8:   0  1  2  3  4  5  6 [8  7] -> stack []
+ *
+ */
+template 
+NPY_NO_EXPORT int
+introselect_(type *v, npy_intp *tosort, npy_intp num, npy_intp kth,
+             npy_intp *pivots, npy_intp *npiv)
+{
+    Idx idx(tosort);
+    Sortee sortee(v, tosort);
+
+    npy_intp low = 0;
+    npy_intp high = num - 1;
+    int depth_limit;
+
+    if (npiv == NULL) {
+        pivots = NULL;
+    }
+
+    while (pivots != NULL && *npiv > 0) {
+        if (pivots[*npiv - 1] > kth) {
+            /* pivot larger than kth set it as upper bound */
+            high = pivots[*npiv - 1] - 1;
+            break;
+        }
+        else if (pivots[*npiv - 1] == kth) {
+            /* kth was already found in a previous iteration -> done */
+            return 0;
+        }
+
+        low = pivots[*npiv - 1] + 1;
+
+        /* pop from stack */
+        *npiv -= 1;
+    }
+
+    /*
+     * use a faster O(n*kth) algorithm for very small kth
+     * e.g. for interpolating percentile
+     */
+    if (kth - low < 3) {
+        dumb_select_(v + (arg ? 0 : low), tosort + (arg ? low : 0),
+                               high - low + 1, kth - low);
+        store_pivot(kth, kth, pivots, npiv);
+        return 0;
+    }
+
+    else if (inexact() && kth == num - 1) {
+        /* useful to check if NaN present via partition(d, (x, -1)) */
+        npy_intp k;
+        npy_intp maxidx = low;
+        type maxval = v[idx(low)];
+        for (k = low + 1; k < num; k++) {
+            if (!Tag::less(v[idx(k)], maxval)) {
+                maxidx = k;
+                maxval = v[idx(k)];
+            }
+        }
+        std::swap(sortee(kth), sortee(maxidx));
+        return 0;
+    }
+
+    depth_limit = npy_get_msb(num) * 2;
+
+    /* guarantee three elements */
+    for (; low + 1 < high;) {
+        npy_intp ll = low + 1;
+        npy_intp hh = high;
+
+        /*
+         * if we aren't making sufficient progress with median of 3
+         * fall back to median-of-median5 pivot for linear worst case
+         * med3 for small sizes is required to do unguarded partition
+         */
+        if (depth_limit > 0 || hh - ll < 5) {
+            const npy_intp mid = low + (high - low) / 2;
+            /* median of 3 pivot strategy,
+             * swapping for efficient partition */
+            median3_swap_(v, tosort, low, mid, high);
+        }
+        else {
+            npy_intp mid;
+            /* FIXME: always use pivots to optimize this iterative partition */
+            mid = ll + median_of_median5_(v + (arg ? 0 : ll),
+                                                    tosort + (arg ? ll : 0),
+                                                    hh - ll, NULL, NULL);
+            std::swap(sortee(mid), sortee(low));
+            /* adapt for the larger partition than med3 pivot */
+            ll--;
+            hh++;
+        }
+
+        depth_limit--;
+
+        /*
+         * find place to put pivot (in low):
+         * previous swapping removes need for bound checks
+         * pivot 3-lowest [x x x] 3-highest
+         */
+        unguarded_partition_(v, tosort, v[idx(low)], &ll, &hh);
+
+        /* move pivot into position */
+        std::swap(sortee(low), sortee(hh));
+
+        /* kth pivot stored later */
+        if (hh != kth) {
+            store_pivot(hh, kth, pivots, npiv);
+        }
+
+        if (hh >= kth) {
+            high = hh - 1;
+        }
+        if (hh <= kth) {
+            low = ll;
+        }
+    }
+
+    /* two elements */
+    if (high == low + 1) {
+        if (Tag::less(v[idx(high)], v[idx(low)])) {
+            std::swap(sortee(high), sortee(low));
+        }
+    }
+    store_pivot(kth, kth, pivots, npiv);
+
+    return 0;
+}
+
+/*
+ *****************************************************************************
+ **                             GENERATOR                                   **
+ *****************************************************************************
+ */
+
+template 
+static int
+introselect_noarg(void *v, npy_intp num, npy_intp kth, npy_intp *pivots,
+                  npy_intp *npiv, void *)
+{
+    return introselect_((typename Tag::type *)v, nullptr, num, kth,
+                                    pivots, npiv);
+}
+
+template 
+static int
+introselect_arg(void *v, npy_intp *tosort, npy_intp num, npy_intp kth,
+                npy_intp *pivots, npy_intp *npiv, void *)
+{
+    return introselect_((typename Tag::type *)v, tosort, num, kth,
+                                   pivots, npiv);
+}
+
+struct arg_map {
+    int typenum;
+    PyArray_PartitionFunc *part[NPY_NSELECTS];
+    PyArray_ArgPartitionFunc *argpart[NPY_NSELECTS];
+};
+
+template 
+static constexpr std::array
+make_partition_map(npy::taglist)
+{
+    return std::array{
+            arg_map{Tags::type_value, &introselect_noarg,
+                    &introselect_arg}...};
+}
+
+struct partition_t {
+    using taglist =
+            npy::taglist;
+
+    static constexpr std::array map =
+            make_partition_map(taglist());
+};
+constexpr std::array partition_t::map;
+
+static inline PyArray_PartitionFunc *
+_get_partition_func(int type, NPY_SELECTKIND which)
+{
+    npy_intp i;
+    npy_intp ntypes = partition_t::map.size();
+
+    if (which >= NPY_NSELECTS) {
+        return NULL;
+    }
+    for (i = 0; i < ntypes; i++) {
+        if (type == partition_t::map[i].typenum) {
+            return partition_t::map[i].part[which];
+        }
+    }
+    return NULL;
+}
+
+static inline PyArray_ArgPartitionFunc *
+_get_argpartition_func(int type, NPY_SELECTKIND which)
+{
+    npy_intp i;
+    npy_intp ntypes = partition_t::map.size();
+
+    for (i = 0; i < ntypes; i++) {
+        if (type == partition_t::map[i].typenum) {
+            return partition_t::map[i].argpart[which];
+        }
+    }
+    return NULL;
+}
+
+/*
+ *****************************************************************************
+ **                            C INTERFACE                                  **
+ *****************************************************************************
+ */
+extern "C" {
+NPY_NO_EXPORT PyArray_PartitionFunc *
+get_partition_func(int type, NPY_SELECTKIND which)
+{
+    return _get_partition_func(type, which);
+}
+NPY_NO_EXPORT PyArray_ArgPartitionFunc *
+get_argpartition_func(int type, NPY_SELECTKIND which)
+{
+    return _get_argpartition_func(type, which);
+}
+}
diff --git a/numpy/core/src/npysort/timsort.c.src b/numpy/core/src/npysort/timsort.cpp
similarity index 53%
rename from numpy/core/src/npysort/timsort.c.src
rename to numpy/core/src/npysort/timsort.cpp
index 5298f5a1d057..27294af0c8ac 100644
--- a/numpy/core/src/npysort/timsort.c.src
+++ b/numpy/core/src/npysort/timsort.cpp
@@ -26,7 +26,6 @@
  * The heap sort is included for completeness.
  */
 
-
 /* For details of Timsort, refer to
  * https://github.com/python/cpython/blob/3.7/Objects/listsort.txt
  */
@@ -35,14 +34,16 @@
 
 #include "npy_sort.h"
 #include "npysort_common.h"
-#include 
+#include "numpy_tag.h"
+
+#include 
+#include 
 
 /* enough for 32 * 1.618 ** 128 elements */
 #define TIMSORT_STACK_SIZE 128
 
-
-
-static npy_intp compute_min_run(npy_intp num)
+static npy_intp
+compute_min_run(npy_intp num)
 {
     npy_intp r = 0;
 
@@ -59,16 +60,14 @@ typedef struct {
     npy_intp l; /* length */
 } run;
 
-
 /* buffer for argsort. Declared here to avoid multiple declarations. */
 typedef struct {
     npy_intp *pw;
     npy_intp size;
 } buffer_intp;
 
-
 /* buffer method */
-static NPY_INLINE int
+static inline int
 resize_buffer_intp(buffer_intp *buffer, npy_intp new_size)
 {
     if (new_size <= buffer->size) {
@@ -76,16 +75,19 @@ resize_buffer_intp(buffer_intp *buffer, npy_intp new_size)
     }
 
     if (NPY_UNLIKELY(buffer->pw == NULL)) {
-        buffer->pw = malloc(new_size * sizeof(npy_intp));
-    } else {
-        buffer->pw = realloc(buffer->pw, new_size * sizeof(npy_intp));
+        buffer->pw = (npy_intp *)malloc(new_size * sizeof(npy_intp));
+    }
+    else {
+        buffer->pw =
+                (npy_intp *)realloc(buffer->pw, new_size * sizeof(npy_intp));
     }
 
     buffer->size = new_size;
 
     if (NPY_UNLIKELY(buffer->pw == NULL)) {
         return -NPY_ENOMEM;
-    } else {
+    }
+    else {
         return 0;
     }
 }
@@ -96,56 +98,44 @@ resize_buffer_intp(buffer_intp *buffer, npy_intp new_size)
  *****************************************************************************
  */
 
-
-/**begin repeat
- *
- * #TYPE = BOOL, BYTE, UBYTE, SHORT, USHORT, INT, UINT, LONG, ULONG,
- *         LONGLONG, ULONGLONG, HALF, FLOAT, DOUBLE, LONGDOUBLE,
- *         CFLOAT, CDOUBLE, CLONGDOUBLE, DATETIME, TIMEDELTA#
- * #suff = bool, byte, ubyte, short, ushort, int, uint, long, ulong,
- *         longlong, ulonglong, half, float, double, longdouble,
- *         cfloat, cdouble, clongdouble, datetime, timedelta#
- * #type = npy_bool, npy_byte, npy_ubyte, npy_short, npy_ushort, npy_int,
- *         npy_uint, npy_long, npy_ulong, npy_longlong, npy_ulonglong,
- *         npy_ushort, npy_float, npy_double, npy_longdouble, npy_cfloat,
- *         npy_cdouble, npy_clongdouble, npy_datetime, npy_timedelta#
- */
-
-
-typedef struct {
-    @type@ * pw;
+template 
+struct buffer_ {
+    typename Tag::type *pw;
     npy_intp size;
-} buffer_@suff@;
+};
 
-
-static NPY_INLINE int
-resize_buffer_@suff@(buffer_@suff@ *buffer, npy_intp new_size)
+template 
+static inline int
+resize_buffer_(buffer_ *buffer, npy_intp new_size)
 {
+    using type = typename Tag::type;
     if (new_size <= buffer->size) {
         return 0;
     }
 
     if (NPY_UNLIKELY(buffer->pw == NULL)) {
-        buffer->pw = malloc(new_size * sizeof(@type@));
-    } else {
-        buffer->pw = realloc(buffer->pw, new_size * sizeof(@type@));
+        buffer->pw = (type *)malloc(new_size * sizeof(type));
+    }
+    else {
+        buffer->pw = (type *)realloc(buffer->pw, new_size * sizeof(type));
     }
 
     buffer->size = new_size;
 
     if (NPY_UNLIKELY(buffer->pw == NULL)) {
         return -NPY_ENOMEM;
-    } else {
+    }
+    else {
         return 0;
     }
 }
 
-
+template 
 static npy_intp
-count_run_@suff@(@type@ *arr, npy_intp l, npy_intp num, npy_intp minrun)
+count_run_(type *arr, npy_intp l, npy_intp num, npy_intp minrun)
 {
     npy_intp sz;
-    @type@ vc, *pl, *pi, *pj, *pr;
+    type vc, *pl, *pi, *pj, *pr;
 
     if (NPY_UNLIKELY(num - l == 1)) {
         return 1;
@@ -154,15 +144,18 @@ count_run_@suff@(@type@ *arr, npy_intp l, npy_intp num, npy_intp minrun)
     pl = arr + l;
 
     /* (not strictly) ascending sequence */
-    if (!@TYPE@_LT(*(pl + 1), *pl)) {
-        for (pi = pl + 1; pi < arr + num - 1 && !@TYPE@_LT(*(pi + 1), *pi); ++pi) {
+    if (!Tag::less(*(pl + 1), *pl)) {
+        for (pi = pl + 1; pi < arr + num - 1 && !Tag::less(*(pi + 1), *pi);
+             ++pi) {
         }
-    } else {  /* (strictly) descending sequence */
-        for (pi = pl + 1; pi < arr + num - 1 && @TYPE@_LT(*(pi + 1), *pi); ++pi) {
+    }
+    else { /* (strictly) descending sequence */
+        for (pi = pl + 1; pi < arr + num - 1 && Tag::less(*(pi + 1), *pi);
+             ++pi) {
         }
 
         for (pj = pl, pr = pi; pj < pr; ++pj, --pr) {
-            @TYPE@_SWAP(*pj, *pr);
+            std::swap(*pj, *pr);
         }
     }
 
@@ -172,7 +165,8 @@ count_run_@suff@(@type@ *arr, npy_intp l, npy_intp num, npy_intp minrun)
     if (sz < minrun) {
         if (l + minrun < num) {
             sz = minrun;
-        } else {
+        }
+        else {
             sz = num - l;
         }
 
@@ -183,7 +177,7 @@ count_run_@suff@(@type@ *arr, npy_intp l, npy_intp num, npy_intp minrun)
             vc = *pi;
             pj = pi;
 
-            while (pl < pj && @TYPE@_LT(vc, *(pj - 1))) {
+            while (pl < pj && Tag::less(vc, *(pj - 1))) {
                 *pj = *(pj - 1);
                 --pj;
             }
@@ -195,43 +189,42 @@ count_run_@suff@(@type@ *arr, npy_intp l, npy_intp num, npy_intp minrun)
     return sz;
 }
 
-
 /* when the left part of the array (p1) is smaller, copy p1 to buffer
  * and merge from left to right
  */
+template 
 static void
-merge_left_@suff@(@type@ *p1, npy_intp l1, @type@ *p2, npy_intp l2,
-                  @type@ *p3)
+merge_left_(type *p1, npy_intp l1, type *p2, npy_intp l2, type *p3)
 {
-    @type@ *end = p2 + l2;
-    memcpy(p3, p1, sizeof(@type@) * l1);
+    type *end = p2 + l2;
+    memcpy(p3, p1, sizeof(type) * l1);
     /* first element must be in p2 otherwise skipped in the caller */
     *p1++ = *p2++;
 
     while (p1 < p2 && p2 < end) {
-        if (@TYPE@_LT(*p2, *p3)) {
+        if (Tag::less(*p2, *p3)) {
             *p1++ = *p2++;
-        } else {
+        }
+        else {
             *p1++ = *p3++;
         }
     }
 
     if (p1 != p2) {
-        memcpy(p1, p3, sizeof(@type@) * (p2 - p1));
+        memcpy(p1, p3, sizeof(type) * (p2 - p1));
     }
 }
 
-
 /* when the right part of the array (p2) is smaller, copy p2 to buffer
  * and merge from right to left
  */
+template 
 static void
-merge_right_@suff@(@type@ *p1, npy_intp l1, @type@ *p2, npy_intp l2,
-                   @type@ *p3)
+merge_right_(type *p1, npy_intp l1, type *p2, npy_intp l2, type *p3)
 {
     npy_intp ofs;
-    @type@ *start = p1 - 1;
-    memcpy(p3, p2, sizeof(@type@) * l2);
+    type *start = p1 - 1;
+    memcpy(p3, p2, sizeof(type) * l2);
     p1 += l1 - 1;
     p2 += l2 - 1;
     p3 += l2 - 1;
@@ -239,31 +232,32 @@ merge_right_@suff@(@type@ *p1, npy_intp l1, @type@ *p2, npy_intp l2,
     *p2-- = *p1--;
 
     while (p1 < p2 && start < p1) {
-        if (@TYPE@_LT(*p3, *p1)) {
+        if (Tag::less(*p3, *p1)) {
             *p2-- = *p1--;
-        } else {
+        }
+        else {
             *p2-- = *p3--;
         }
     }
 
     if (p1 != p2) {
         ofs = p2 - start;
-        memcpy(start + 1, p3 - ofs + 1, sizeof(@type@) * ofs);
+        memcpy(start + 1, p3 - ofs + 1, sizeof(type) * ofs);
     }
 }
 
-
 /* Note: the naming convention of gallop functions are different from that of
  * CPython. For example, here gallop_right means gallop from left toward right,
  * whereas in CPython gallop_right means gallop
  * and find the right most element among equal elements
  */
+template 
 static npy_intp
-gallop_right_@suff@(const @type@ *arr, const npy_intp size, const @type@ key)
+gallop_right_(const type *arr, const npy_intp size, const type key)
 {
     npy_intp last_ofs, ofs, m;
 
-    if (@TYPE@_LT(key, arr[0])) {
+    if (Tag::less(key, arr[0])) {
         return 0;
     }
 
@@ -276,9 +270,10 @@ gallop_right_@suff@(const @type@ *arr, const npy_intp size, const @type@ key)
             break;
         }
 
-        if (@TYPE@_LT(key, arr[ofs])) {
+        if (Tag::less(key, arr[ofs])) {
             break;
-        } else {
+        }
+        else {
             last_ofs = ofs;
             /* ofs = 1, 3, 7, 15... */
             ofs = (ofs << 1) + 1;
@@ -289,9 +284,10 @@ gallop_right_@suff@(const @type@ *arr, const npy_intp size, const @type@ key)
     while (last_ofs + 1 < ofs) {
         m = last_ofs + ((ofs - last_ofs) >> 1);
 
-        if (@TYPE@_LT(key, arr[m])) {
+        if (Tag::less(key, arr[m])) {
             ofs = m;
-        } else {
+        }
+        else {
             last_ofs = m;
         }
     }
@@ -300,13 +296,13 @@ gallop_right_@suff@(const @type@ *arr, const npy_intp size, const @type@ key)
     return ofs;
 }
 
-
+template 
 static npy_intp
-gallop_left_@suff@(const @type@ *arr, const npy_intp size, const @type@ key)
+gallop_left_(const type *arr, const npy_intp size, const type key)
 {
     npy_intp last_ofs, ofs, l, m, r;
 
-    if (@TYPE@_LT(arr[size - 1], key)) {
+    if (Tag::less(arr[size - 1], key)) {
         return size;
     }
 
@@ -319,9 +315,10 @@ gallop_left_@suff@(const @type@ *arr, const npy_intp size, const @type@ key)
             break;
         }
 
-        if (@TYPE@_LT(arr[size - ofs - 1], key)) {
+        if (Tag::less(arr[size - ofs - 1], key)) {
             break;
-        } else {
+        }
+        else {
             last_ofs = ofs;
             ofs = (ofs << 1) + 1;
         }
@@ -334,9 +331,10 @@ gallop_left_@suff@(const @type@ *arr, const npy_intp size, const @type@ key)
     while (l + 1 < r) {
         m = l + ((r - l) >> 1);
 
-        if (@TYPE@_LT(arr[m], key)) {
+        if (Tag::less(arr[m], key)) {
             l = m;
-        } else {
+        }
+        else {
             r = m;
         }
     }
@@ -345,14 +343,13 @@ gallop_left_@suff@(const @type@ *arr, const npy_intp size, const @type@ key)
     return r;
 }
 
-
+template 
 static int
-merge_at_@suff@(@type@ *arr, const run *stack, const npy_intp at,
-                buffer_@suff@ *buffer)
+merge_at_(type *arr, const run *stack, const npy_intp at, buffer_ *buffer)
 {
     int ret;
     npy_intp s1, l1, s2, l2, k;
-    @type@ *p1, *p2;
+    type *p1, *p2;
     s1 = stack[at].s;
     l1 = stack[at].l;
     s2 = stack[at + 1].s;
@@ -361,7 +358,7 @@ merge_at_@suff@(@type@ *arr, const run *stack, const npy_intp at,
      * if try to comment this out for debugging purpose, remember
      * in the merging process the first element is skipped
      */
-    k = gallop_right_@suff@(arr + s1, l1, arr[s2]);
+    k = gallop_right_(arr + s1, l1, arr[s2]);
 
     if (l1 == k) {
         /* already sorted */
@@ -372,29 +369,33 @@ merge_at_@suff@(@type@ *arr, const run *stack, const npy_intp at,
     l1 -= k;
     p2 = arr + s2;
     /* arr[s2-1] belongs to arr[s2+l2] */
-    l2 = gallop_left_@suff@(arr + s2, l2, arr[s2 - 1]);
+    l2 = gallop_left_(arr + s2, l2, arr[s2 - 1]);
 
     if (l2 < l1) {
-        ret = resize_buffer_@suff@(buffer, l2);
+        ret = resize_buffer_(buffer, l2);
 
-        if (NPY_UNLIKELY(ret < 0)) { return ret; }
+        if (NPY_UNLIKELY(ret < 0)) {
+            return ret;
+        }
 
-        merge_right_@suff@(p1, l1, p2, l2, buffer->pw);
-    } else {
-        ret = resize_buffer_@suff@(buffer, l1);
+        merge_right_(p1, l1, p2, l2, buffer->pw);
+    }
+    else {
+        ret = resize_buffer_(buffer, l1);
 
-        if (NPY_UNLIKELY(ret < 0)) { return ret; }
+        if (NPY_UNLIKELY(ret < 0)) {
+            return ret;
+        }
 
-        merge_left_@suff@(p1, l1, p2, l2, buffer->pw);
+        merge_left_(p1, l1, p2, l2, buffer->pw);
     }
 
     return 0;
 }
 
-
+template 
 static int
-try_collapse_@suff@(@type@ *arr, run *stack, npy_intp *stack_ptr,
-                    buffer_@suff@ *buffer)
+try_collapse_(type *arr, run *stack, npy_intp *stack_ptr, buffer_ *buffer)
 {
     int ret;
     npy_intp A, B, C, top;
@@ -405,33 +406,42 @@ try_collapse_@suff@(@type@ *arr, run *stack, npy_intp *stack_ptr,
         C = stack[top - 1].l;
 
         if ((2 < top && stack[top - 3].l <= B + C) ||
-                (3 < top && stack[top - 4].l <= stack[top - 3].l + B)) {
+            (3 < top && stack[top - 4].l <= stack[top - 3].l + B)) {
             A = stack[top - 3].l;
 
             if (A <= C) {
-                ret = merge_at_@suff@(arr, stack, top - 3, buffer);
+                ret = merge_at_(arr, stack, top - 3, buffer);
 
-                if (NPY_UNLIKELY(ret < 0)) { return ret; }
+                if (NPY_UNLIKELY(ret < 0)) {
+                    return ret;
+                }
 
                 stack[top - 3].l += B;
                 stack[top - 2] = stack[top - 1];
                 --top;
-            } else {
-                ret = merge_at_@suff@(arr, stack, top - 2, buffer);
+            }
+            else {
+                ret = merge_at_(arr, stack, top - 2, buffer);
 
-                if (NPY_UNLIKELY(ret < 0)) { return ret; }
+                if (NPY_UNLIKELY(ret < 0)) {
+                    return ret;
+                }
 
                 stack[top - 2].l += C;
                 --top;
             }
-        } else if (1 < top && B <= C) {
-            ret = merge_at_@suff@(arr, stack, top - 2, buffer);
+        }
+        else if (1 < top && B <= C) {
+            ret = merge_at_(arr, stack, top - 2, buffer);
 
-            if (NPY_UNLIKELY(ret < 0)) { return ret; }
+            if (NPY_UNLIKELY(ret < 0)) {
+                return ret;
+            }
 
             stack[top - 2].l += C;
             --top;
-        } else {
+        }
+        else {
             break;
         }
     }
@@ -440,26 +450,32 @@ try_collapse_@suff@(@type@ *arr, run *stack, npy_intp *stack_ptr,
     return 0;
 }
 
+template 
 static int
-force_collapse_@suff@(@type@ *arr, run *stack, npy_intp *stack_ptr,
-                      buffer_@suff@ *buffer)
+force_collapse_(type *arr, run *stack, npy_intp *stack_ptr,
+                buffer_ *buffer)
 {
     int ret;
     npy_intp top = *stack_ptr;
 
     while (2 < top) {
         if (stack[top - 3].l <= stack[top - 1].l) {
-            ret = merge_at_@suff@(arr, stack, top - 3, buffer);
+            ret = merge_at_(arr, stack, top - 3, buffer);
 
-            if (NPY_UNLIKELY(ret < 0)) { return ret; }
+            if (NPY_UNLIKELY(ret < 0)) {
+                return ret;
+            }
 
             stack[top - 3].l += stack[top - 2].l;
             stack[top - 2] = stack[top - 1];
             --top;
-        } else {
-            ret = merge_at_@suff@(arr, stack, top - 2, buffer);
+        }
+        else {
+            ret = merge_at_(arr, stack, top - 2, buffer);
 
-            if (NPY_UNLIKELY(ret < 0)) { return ret; }
+            if (NPY_UNLIKELY(ret < 0)) {
+                return ret;
+            }
 
             stack[top - 2].l += stack[top - 1].l;
             --top;
@@ -467,21 +483,24 @@ force_collapse_@suff@(@type@ *arr, run *stack, npy_intp *stack_ptr,
     }
 
     if (1 < top) {
-        ret = merge_at_@suff@(arr, stack, top - 2, buffer);
+        ret = merge_at_(arr, stack, top - 2, buffer);
 
-        if (NPY_UNLIKELY(ret < 0)) { return ret; }
+        if (NPY_UNLIKELY(ret < 0)) {
+            return ret;
+        }
     }
 
     return 0;
 }
 
-
-NPY_NO_EXPORT int
-timsort_@suff@(void *start, npy_intp num, void *NPY_UNUSED(varr))
+template 
+static int
+timsort_(void *start, npy_intp num)
 {
+    using type = typename Tag::type;
     int ret;
     npy_intp l, n, stack_ptr, minrun;
-    buffer_@suff@ buffer;
+    buffer_ buffer;
     run stack[TIMSORT_STACK_SIZE];
     buffer.pw = NULL;
     buffer.size = 0;
@@ -489,20 +508,24 @@ timsort_@suff@(void *start, npy_intp num, void *NPY_UNUSED(varr))
     minrun = compute_min_run(num);
 
     for (l = 0; l < num;) {
-        n = count_run_@suff@(start, l, num, minrun);
+        n = count_run_((type *)start, l, num, minrun);
         stack[stack_ptr].s = l;
         stack[stack_ptr].l = n;
         ++stack_ptr;
-        ret = try_collapse_@suff@(start, stack, &stack_ptr, &buffer);
+        ret = try_collapse_((type *)start, stack, &stack_ptr, &buffer);
 
-        if (NPY_UNLIKELY(ret < 0)) { goto cleanup; }
+        if (NPY_UNLIKELY(ret < 0)) {
+            goto cleanup;
+        }
 
         l += n;
     }
 
-    ret = force_collapse_@suff@(start, stack, &stack_ptr, &buffer);
+    ret = force_collapse_((type *)start, stack, &stack_ptr, &buffer);
 
-    if (NPY_UNLIKELY(ret < 0)) { goto cleanup; }
+    if (NPY_UNLIKELY(ret < 0)) {
+        goto cleanup;
+    }
 
     ret = 0;
 cleanup:
@@ -512,16 +535,15 @@ timsort_@suff@(void *start, npy_intp num, void *NPY_UNUSED(varr))
     return ret;
 }
 
-
 /* argsort */
 
-
+template 
 static npy_intp
-acount_run_@suff@(@type@ *arr, npy_intp *tosort, npy_intp l, npy_intp num,
-                  npy_intp minrun)
+acount_run_(type *arr, npy_intp *tosort, npy_intp l, npy_intp num,
+            npy_intp minrun)
 {
     npy_intp sz;
-    @type@ vc;
+    type vc;
     npy_intp vi;
     npy_intp *pl, *pi, *pj, *pr;
 
@@ -532,17 +554,20 @@ acount_run_@suff@(@type@ *arr, npy_intp *tosort, npy_intp l, npy_intp num,
     pl = tosort + l;
 
     /* (not strictly) ascending sequence */
-    if (!@TYPE@_LT(arr[*(pl + 1)], arr[*pl])) {
-        for (pi = pl + 1; pi < tosort + num - 1
-                && !@TYPE@_LT(arr[*(pi + 1)], arr[*pi]); ++pi) {
+    if (!Tag::less(arr[*(pl + 1)], arr[*pl])) {
+        for (pi = pl + 1;
+             pi < tosort + num - 1 && !Tag::less(arr[*(pi + 1)], arr[*pi]);
+             ++pi) {
         }
-    } else {  /* (strictly) descending sequence */
-        for (pi = pl + 1; pi < tosort + num - 1
-                && @TYPE@_LT(arr[*(pi + 1)], arr[*pi]); ++pi) {
+    }
+    else { /* (strictly) descending sequence */
+        for (pi = pl + 1;
+             pi < tosort + num - 1 && Tag::less(arr[*(pi + 1)], arr[*pi]);
+             ++pi) {
         }
 
         for (pj = pl, pr = pi; pj < pr; ++pj, --pr) {
-            INTP_SWAP(*pj, *pr);
+            std::swap(*pj, *pr);
         }
     }
 
@@ -552,7 +577,8 @@ acount_run_@suff@(@type@ *arr, npy_intp *tosort, npy_intp l, npy_intp num,
     if (sz < minrun) {
         if (l + minrun < num) {
             sz = minrun;
-        } else {
+        }
+        else {
             sz = num - l;
         }
 
@@ -564,7 +590,7 @@ acount_run_@suff@(@type@ *arr, npy_intp *tosort, npy_intp l, npy_intp num,
             vc = arr[*pi];
             pj = pi;
 
-            while (pl < pj && @TYPE@_LT(vc, arr[*(pj - 1)])) {
+            while (pl < pj && Tag::less(vc, arr[*(pj - 1)])) {
                 *pj = *(pj - 1);
                 --pj;
             }
@@ -576,14 +602,14 @@ acount_run_@suff@(@type@ *arr, npy_intp *tosort, npy_intp l, npy_intp num,
     return sz;
 }
 
-
+template 
 static npy_intp
-agallop_right_@suff@(const @type@ *arr, const npy_intp *tosort,
-                     const npy_intp size, const @type@ key)
+agallop_right_(const type *arr, const npy_intp *tosort, const npy_intp size,
+               const type key)
 {
     npy_intp last_ofs, ofs, m;
 
-    if (@TYPE@_LT(key, arr[tosort[0]])) {
+    if (Tag::less(key, arr[tosort[0]])) {
         return 0;
     }
 
@@ -596,9 +622,10 @@ agallop_right_@suff@(const @type@ *arr, const npy_intp *tosort,
             break;
         }
 
-        if (@TYPE@_LT(key, arr[tosort[ofs]])) {
+        if (Tag::less(key, arr[tosort[ofs]])) {
             break;
-        } else {
+        }
+        else {
             last_ofs = ofs;
             /* ofs = 1, 3, 7, 15... */
             ofs = (ofs << 1) + 1;
@@ -609,9 +636,10 @@ agallop_right_@suff@(const @type@ *arr, const npy_intp *tosort,
     while (last_ofs + 1 < ofs) {
         m = last_ofs + ((ofs - last_ofs) >> 1);
 
-        if (@TYPE@_LT(key, arr[tosort[m]])) {
+        if (Tag::less(key, arr[tosort[m]])) {
             ofs = m;
-        } else {
+        }
+        else {
             last_ofs = m;
         }
     }
@@ -620,15 +648,14 @@ agallop_right_@suff@(const @type@ *arr, const npy_intp *tosort,
     return ofs;
 }
 
-
-
+template 
 static npy_intp
-agallop_left_@suff@(const @type@ *arr, const npy_intp *tosort,
-                    const npy_intp size, const @type@ key)
+agallop_left_(const type *arr, const npy_intp *tosort, const npy_intp size,
+              const type key)
 {
     npy_intp last_ofs, ofs, l, m, r;
 
-    if (@TYPE@_LT(arr[tosort[size - 1]], key)) {
+    if (Tag::less(arr[tosort[size - 1]], key)) {
         return size;
     }
 
@@ -641,24 +668,27 @@ agallop_left_@suff@(const @type@ *arr, const npy_intp *tosort,
             break;
         }
 
-        if (@TYPE@_LT(arr[tosort[size - ofs - 1]], key)) {
+        if (Tag::less(arr[tosort[size - ofs - 1]], key)) {
             break;
-        } else {
+        }
+        else {
             last_ofs = ofs;
             ofs = (ofs << 1) + 1;
         }
     }
 
-    /* now that arr[tosort[size-ofs-1]] < key <= arr[tosort[size-last_ofs-1]] */
+    /* now that arr[tosort[size-ofs-1]] < key <= arr[tosort[size-last_ofs-1]]
+     */
     l = size - ofs - 1;
     r = size - last_ofs - 1;
 
     while (l + 1 < r) {
         m = l + ((r - l) >> 1);
 
-        if (@TYPE@_LT(arr[tosort[m]], key)) {
+        if (Tag::less(arr[tosort[m]], key)) {
             l = m;
-        } else {
+        }
+        else {
             r = m;
         }
     }
@@ -667,11 +697,10 @@ agallop_left_@suff@(const @type@ *arr, const npy_intp *tosort,
     return r;
 }
 
-
+template 
 static void
-amerge_left_@suff@(@type@ *arr, npy_intp *p1, npy_intp l1, npy_intp *p2,
-                   npy_intp l2,
-                   npy_intp *p3)
+amerge_left_(type *arr, npy_intp *p1, npy_intp l1, npy_intp *p2, npy_intp l2,
+             npy_intp *p3)
 {
     npy_intp *end = p2 + l2;
     memcpy(p3, p1, sizeof(npy_intp) * l1);
@@ -679,9 +708,10 @@ amerge_left_@suff@(@type@ *arr, npy_intp *p1, npy_intp l1, npy_intp *p2,
     *p1++ = *p2++;
 
     while (p1 < p2 && p2 < end) {
-        if (@TYPE@_LT(arr[*p2], arr[*p3])) {
+        if (Tag::less(arr[*p2], arr[*p3])) {
             *p1++ = *p2++;
-        } else {
+        }
+        else {
             *p1++ = *p3++;
         }
     }
@@ -691,11 +721,10 @@ amerge_left_@suff@(@type@ *arr, npy_intp *p1, npy_intp l1, npy_intp *p2,
     }
 }
 
-
+template 
 static void
-amerge_right_@suff@(@type@ *arr, npy_intp* p1, npy_intp l1, npy_intp *p2,
-                    npy_intp l2,
-                    npy_intp *p3)
+amerge_right_(type *arr, npy_intp *p1, npy_intp l1, npy_intp *p2, npy_intp l2,
+              npy_intp *p3)
 {
     npy_intp ofs;
     npy_intp *start = p1 - 1;
@@ -707,9 +736,10 @@ amerge_right_@suff@(@type@ *arr, npy_intp* p1, npy_intp l1, npy_intp *p2,
     *p2-- = *p1--;
 
     while (p1 < p2 && start < p1) {
-        if (@TYPE@_LT(arr[*p3], arr[*p1])) {
+        if (Tag::less(arr[*p3], arr[*p1])) {
             *p2-- = *p1--;
-        } else {
+        }
+        else {
             *p2-- = *p3--;
         }
     }
@@ -720,11 +750,10 @@ amerge_right_@suff@(@type@ *arr, npy_intp* p1, npy_intp l1, npy_intp *p2,
     }
 }
 
-
+template 
 static int
-amerge_at_@suff@(@type@ *arr, npy_intp *tosort, const run *stack,
-                 const npy_intp at,
-                 buffer_intp *buffer)
+amerge_at_(type *arr, npy_intp *tosort, const run *stack, const npy_intp at,
+           buffer_intp *buffer)
 {
     int ret;
     npy_intp s1, l1, s2, l2, k;
@@ -734,7 +763,7 @@ amerge_at_@suff@(@type@ *arr, npy_intp *tosort, const run *stack,
     s2 = stack[at + 1].s;
     l2 = stack[at + 1].l;
     /* tosort[s2] belongs to tosort[s1+k] */
-    k = agallop_right_@suff@(arr, tosort + s1, l1, arr[tosort[s2]]);
+    k = agallop_right_(arr, tosort + s1, l1, arr[tosort[s2]]);
 
     if (l1 == k) {
         /* already sorted */
@@ -745,30 +774,34 @@ amerge_at_@suff@(@type@ *arr, npy_intp *tosort, const run *stack,
     l1 -= k;
     p2 = tosort + s2;
     /* tosort[s2-1] belongs to tosort[s2+l2] */
-    l2 = agallop_left_@suff@(arr, tosort + s2, l2, arr[tosort[s2 - 1]]);
+    l2 = agallop_left_(arr, tosort + s2, l2, arr[tosort[s2 - 1]]);
 
     if (l2 < l1) {
         ret = resize_buffer_intp(buffer, l2);
 
-        if (NPY_UNLIKELY(ret < 0)) { return ret; }
+        if (NPY_UNLIKELY(ret < 0)) {
+            return ret;
+        }
 
-        amerge_right_@suff@(arr, p1, l1, p2, l2, buffer->pw);
-    } else {
+        amerge_right_(arr, p1, l1, p2, l2, buffer->pw);
+    }
+    else {
         ret = resize_buffer_intp(buffer, l1);
 
-        if (NPY_UNLIKELY(ret < 0)) { return ret; }
+        if (NPY_UNLIKELY(ret < 0)) {
+            return ret;
+        }
 
-        amerge_left_@suff@(arr, p1, l1, p2, l2, buffer->pw);
+        amerge_left_(arr, p1, l1, p2, l2, buffer->pw);
     }
 
     return 0;
 }
 
-
+template 
 static int
-atry_collapse_@suff@(@type@ *arr, npy_intp *tosort, run *stack,
-                     npy_intp *stack_ptr,
-                     buffer_intp *buffer)
+atry_collapse_(type *arr, npy_intp *tosort, run *stack, npy_intp *stack_ptr,
+               buffer_intp *buffer)
 {
     int ret;
     npy_intp A, B, C, top;
@@ -779,33 +812,42 @@ atry_collapse_@suff@(@type@ *arr, npy_intp *tosort, run *stack,
         C = stack[top - 1].l;
 
         if ((2 < top && stack[top - 3].l <= B + C) ||
-                (3 < top && stack[top - 4].l <= stack[top - 3].l + B)) {
+            (3 < top && stack[top - 4].l <= stack[top - 3].l + B)) {
             A = stack[top - 3].l;
 
             if (A <= C) {
-                ret = amerge_at_@suff@(arr, tosort, stack, top - 3, buffer);
+                ret = amerge_at_(arr, tosort, stack, top - 3, buffer);
 
-                if (NPY_UNLIKELY(ret < 0)) { return ret; }
+                if (NPY_UNLIKELY(ret < 0)) {
+                    return ret;
+                }
 
                 stack[top - 3].l += B;
                 stack[top - 2] = stack[top - 1];
                 --top;
-            } else {
-                ret = amerge_at_@suff@(arr, tosort, stack, top - 2, buffer);
+            }
+            else {
+                ret = amerge_at_(arr, tosort, stack, top - 2, buffer);
 
-                if (NPY_UNLIKELY(ret < 0)) { return ret; }
+                if (NPY_UNLIKELY(ret < 0)) {
+                    return ret;
+                }
 
                 stack[top - 2].l += C;
                 --top;
             }
-        } else if (1 < top && B <= C) {
-            ret = amerge_at_@suff@(arr, tosort, stack, top - 2, buffer);
+        }
+        else if (1 < top && B <= C) {
+            ret = amerge_at_(arr, tosort, stack, top - 2, buffer);
 
-            if (NPY_UNLIKELY(ret < 0)) { return ret; }
+            if (NPY_UNLIKELY(ret < 0)) {
+                return ret;
+            }
 
             stack[top - 2].l += C;
             --top;
-        } else {
+        }
+        else {
             break;
         }
     }
@@ -814,28 +856,32 @@ atry_collapse_@suff@(@type@ *arr, npy_intp *tosort, run *stack,
     return 0;
 }
 
-
+template 
 static int
-aforce_collapse_@suff@(@type@ *arr, npy_intp *tosort, run *stack,
-                       npy_intp *stack_ptr,
-                       buffer_intp *buffer)
+aforce_collapse_(type *arr, npy_intp *tosort, run *stack, npy_intp *stack_ptr,
+                 buffer_intp *buffer)
 {
     int ret;
     npy_intp top = *stack_ptr;
 
     while (2 < top) {
         if (stack[top - 3].l <= stack[top - 1].l) {
-            ret = amerge_at_@suff@(arr, tosort, stack, top - 3, buffer);
+            ret = amerge_at_(arr, tosort, stack, top - 3, buffer);
 
-            if (NPY_UNLIKELY(ret < 0)) { return ret; }
+            if (NPY_UNLIKELY(ret < 0)) {
+                return ret;
+            }
 
             stack[top - 3].l += stack[top - 2].l;
             stack[top - 2] = stack[top - 1];
             --top;
-        } else {
-            ret = amerge_at_@suff@(arr, tosort, stack, top - 2, buffer);
+        }
+        else {
+            ret = amerge_at_(arr, tosort, stack, top - 2, buffer);
 
-            if (NPY_UNLIKELY(ret < 0)) { return ret; }
+            if (NPY_UNLIKELY(ret < 0)) {
+                return ret;
+            }
 
             stack[top - 2].l += stack[top - 1].l;
             --top;
@@ -843,19 +889,21 @@ aforce_collapse_@suff@(@type@ *arr, npy_intp *tosort, run *stack,
     }
 
     if (1 < top) {
-        ret = amerge_at_@suff@(arr, tosort, stack, top - 2, buffer);
+        ret = amerge_at_(arr, tosort, stack, top - 2, buffer);
 
-        if (NPY_UNLIKELY(ret < 0)) { return ret; }
+        if (NPY_UNLIKELY(ret < 0)) {
+            return ret;
+        }
     }
 
     return 0;
 }
 
-
-NPY_NO_EXPORT int
-atimsort_@suff@(void *v, npy_intp *tosort, npy_intp num,
-                void *NPY_UNUSED(varr))
+template 
+static int
+atimsort_(void *v, npy_intp *tosort, npy_intp num)
 {
+    using type = typename Tag::type;
     int ret;
     npy_intp l, n, stack_ptr, minrun;
     buffer_intp buffer;
@@ -866,20 +914,25 @@ atimsort_@suff@(void *v, npy_intp *tosort, npy_intp num,
     minrun = compute_min_run(num);
 
     for (l = 0; l < num;) {
-        n = acount_run_@suff@(v, tosort, l, num, minrun);
+        n = acount_run_((type *)v, tosort, l, num, minrun);
         stack[stack_ptr].s = l;
         stack[stack_ptr].l = n;
         ++stack_ptr;
-        ret = atry_collapse_@suff@(v, tosort, stack, &stack_ptr, &buffer);
+        ret = atry_collapse_((type *)v, tosort, stack, &stack_ptr,
+                                  &buffer);
 
-        if (NPY_UNLIKELY(ret < 0)) { goto cleanup; }
+        if (NPY_UNLIKELY(ret < 0)) {
+            goto cleanup;
+        }
 
         l += n;
     }
 
-    ret = aforce_collapse_@suff@(v, tosort, stack, &stack_ptr, &buffer);
+    ret = aforce_collapse_((type *)v, tosort, stack, &stack_ptr, &buffer);
 
-    if (NPY_UNLIKELY(ret < 0)) { goto cleanup; }
+    if (NPY_UNLIKELY(ret < 0)) {
+        goto cleanup;
+    }
 
     ret = 0;
 cleanup:
@@ -891,18 +944,15 @@ atimsort_@suff@(void *v, npy_intp *tosort, npy_intp num,
     return ret;
 }
 
-/**end repeat**/
-
-
-
 /* For string sorts and generic sort, element comparisons are very expensive,
- * and the time cost of insertion sort (involves N**2 comparison) clearly hurts.
- * Implementing binary insertion sort and probably gallop mode during merging process
- * can hopefully boost the performance. Here as a temporary workaround we use shorter
- * run length to reduce the cost of insertion sort.
+ * and the time cost of insertion sort (involves N**2 comparison) clearly
+ * hurts. Implementing binary insertion sort and probably gallop mode during
+ * merging process can hopefully boost the performance. Here as a temporary
+ * workaround we use shorter run length to reduce the cost of insertion sort.
  */
 
-static npy_intp compute_min_run_short(npy_intp num)
+static npy_intp
+compute_min_run_short(npy_intp num)
 {
     npy_intp r = 0;
 
@@ -920,51 +970,47 @@ static npy_intp compute_min_run_short(npy_intp num)
  *****************************************************************************
  */
 
-
-/**begin repeat
- *
- * #TYPE = STRING, UNICODE#
- * #suff = string, unicode#
- * #type = npy_char, npy_ucs4#
- */
-
-
-typedef struct {
-    @type@ * pw;
+template 
+struct string_buffer_ {
+    typename Tag::type *pw;
     npy_intp size;
     size_t len;
-} buffer_@suff@;
-
+};
 
-static NPY_INLINE int
-resize_buffer_@suff@(buffer_@suff@ *buffer, npy_intp new_size)
+template 
+static inline int
+resize_buffer_(string_buffer_ *buffer, npy_intp new_size)
 {
+    using type = typename Tag::type;
     if (new_size <= buffer->size) {
         return 0;
     }
 
     if (NPY_UNLIKELY(buffer->pw == NULL)) {
-        buffer->pw = malloc(sizeof(@type@) * new_size * buffer->len);
-    } else {
-        buffer->pw = realloc(buffer->pw,  sizeof(@type@) * new_size * buffer->len);
+        buffer->pw = (type *)malloc(sizeof(type) * new_size * buffer->len);
+    }
+    else {
+        buffer->pw = (type *)realloc(buffer->pw,
+                                     sizeof(type) * new_size * buffer->len);
     }
 
     buffer->size = new_size;
 
     if (NPY_UNLIKELY(buffer->pw == NULL)) {
         return -NPY_ENOMEM;
-    } else {
+    }
+    else {
         return 0;
     }
 }
 
-
+template 
 static npy_intp
-count_run_@suff@(@type@ *arr, npy_intp l, npy_intp num, npy_intp minrun,
-                 @type@ *vp, size_t len)
+count_run_(type *arr, npy_intp l, npy_intp num, npy_intp minrun, type *vp,
+           size_t len)
 {
     npy_intp sz;
-    @type@ *pl, *pi, *pj, *pr;
+    type *pl, *pi, *pj, *pr;
 
     if (NPY_UNLIKELY(num - l == 1)) {
         return 1;
@@ -973,17 +1019,20 @@ count_run_@suff@(@type@ *arr, npy_intp l, npy_intp num, npy_intp minrun,
     pl = arr + l * len;
 
     /* (not strictly) ascending sequence */
-    if (!@TYPE@_LT(pl + len, pl, len)) {
-        for (pi = pl + len; pi < arr + (num - 1) * len
-                && !@TYPE@_LT(pi + len, pi, len); pi += len) {
+    if (!Tag::less(pl + len, pl, len)) {
+        for (pi = pl + len;
+             pi < arr + (num - 1) * len && !Tag::less(pi + len, pi, len);
+             pi += len) {
         }
-    } else {  /* (strictly) descending sequence */
-        for (pi = pl + len; pi < arr + (num - 1) * len
-                && @TYPE@_LT(pi + len, pi, len); pi += len) {
+    }
+    else { /* (strictly) descending sequence */
+        for (pi = pl + len;
+             pi < arr + (num - 1) * len && Tag::less(pi + len, pi, len);
+             pi += len) {
         }
 
         for (pj = pl, pr = pi; pj < pr; pj += len, pr -= len) {
-            @TYPE@_SWAP(pj, pr, len);
+            Tag::swap(pj, pr, len);
         }
     }
 
@@ -993,7 +1042,8 @@ count_run_@suff@(@type@ *arr, npy_intp l, npy_intp num, npy_intp minrun,
     if (sz < minrun) {
         if (l + minrun < num) {
             sz = minrun;
-        } else {
+        }
+        else {
             sz = num - l;
         }
 
@@ -1001,29 +1051,29 @@ count_run_@suff@(@type@ *arr, npy_intp l, npy_intp num, npy_intp minrun,
 
         /* insertion sort */
         for (; pi < pr; pi += len) {
-            @TYPE@_COPY(vp, pi, len);
+            Tag::copy(vp, pi, len);
             pj = pi;
 
-            while (pl < pj && @TYPE@_LT(vp, pj - len, len)) {
-                @TYPE@_COPY(pj, pj - len, len);
+            while (pl < pj && Tag::less(vp, pj - len, len)) {
+                Tag::copy(pj, pj - len, len);
                 pj -= len;
             }
 
-            @TYPE@_COPY(pj, vp, len);
+            Tag::copy(pj, vp, len);
         }
     }
 
     return sz;
 }
 
-
+template 
 static npy_intp
-gallop_right_@suff@(const @type@ *arr, const npy_intp size,
-                    const @type@ *key, size_t len)
+gallop_right_(const typename Tag::type *arr, const npy_intp size,
+              const typename Tag::type *key, size_t len)
 {
     npy_intp last_ofs, ofs, m;
 
-    if (@TYPE@_LT(key, arr, len)) {
+    if (Tag::less(key, arr, len)) {
         return 0;
     }
 
@@ -1036,9 +1086,10 @@ gallop_right_@suff@(const @type@ *arr, const npy_intp size,
             break;
         }
 
-        if (@TYPE@_LT(key, arr + ofs * len, len)) {
+        if (Tag::less(key, arr + ofs * len, len)) {
             break;
-        } else {
+        }
+        else {
             last_ofs = ofs;
             /* ofs = 1, 3, 7, 15... */
             ofs = (ofs << 1) + 1;
@@ -1049,9 +1100,10 @@ gallop_right_@suff@(const @type@ *arr, const npy_intp size,
     while (last_ofs + 1 < ofs) {
         m = last_ofs + ((ofs - last_ofs) >> 1);
 
-        if (@TYPE@_LT(key, arr + m * len, len)) {
+        if (Tag::less(key, arr + m * len, len)) {
             ofs = m;
-        } else {
+        }
+        else {
             last_ofs = m;
         }
     }
@@ -1060,15 +1112,14 @@ gallop_right_@suff@(const @type@ *arr, const npy_intp size,
     return ofs;
 }
 
-
-
+template 
 static npy_intp
-gallop_left_@suff@(const @type@ *arr, const npy_intp size, const @type@ *key,
-                   size_t len)
+gallop_left_(const typename Tag::type *arr, const npy_intp size,
+             const typename Tag::type *key, size_t len)
 {
     npy_intp last_ofs, ofs, l, m, r;
 
-    if (@TYPE@_LT(arr + (size - 1) * len, key, len)) {
+    if (Tag::less(arr + (size - 1) * len, key, len)) {
         return size;
     }
 
@@ -1081,9 +1132,10 @@ gallop_left_@suff@(const @type@ *arr, const npy_intp size, const @type@ *key,
             break;
         }
 
-        if (@TYPE@_LT(arr + (size - ofs - 1) * len, key, len)) {
+        if (Tag::less(arr + (size - ofs - 1) * len, key, len)) {
             break;
-        } else {
+        }
+        else {
             last_ofs = ofs;
             ofs = (ofs << 1) + 1;
         }
@@ -1096,9 +1148,10 @@ gallop_left_@suff@(const @type@ *arr, const npy_intp size, const @type@ *key,
     while (l + 1 < r) {
         m = l + ((r - l) >> 1);
 
-        if (@TYPE@_LT(arr + m * len, key, len)) {
+        if (Tag::less(arr + m * len, key, len)) {
             l = m;
-        } else {
+        }
+        else {
             r = m;
         }
     }
@@ -1107,58 +1160,61 @@ gallop_left_@suff@(const @type@ *arr, const npy_intp size, const @type@ *key,
     return r;
 }
 
-
+template 
 static void
-merge_left_@suff@(@type@ *p1, npy_intp l1, @type@ *p2, npy_intp l2,
-                  @type@ *p3, size_t len)
+merge_left_(typename Tag::type *p1, npy_intp l1, typename Tag::type *p2,
+            npy_intp l2, typename Tag::type *p3, size_t len)
 {
-    @type@ *end = p2 + l2 * len;
-    memcpy(p3, p1, sizeof(@type@) * l1 * len);
+    using type = typename Tag::type;
+    type *end = p2 + l2 * len;
+    memcpy(p3, p1, sizeof(type) * l1 * len);
     /* first element must be in p2 otherwise skipped in the caller */
-    @TYPE@_COPY(p1, p2, len);
+    Tag::copy(p1, p2, len);
     p1 += len;
     p2 += len;
 
     while (p1 < p2 && p2 < end) {
-        if (@TYPE@_LT(p2, p3, len)) {
-            @TYPE@_COPY(p1, p2, len);
+        if (Tag::less(p2, p3, len)) {
+            Tag::copy(p1, p2, len);
             p1 += len;
             p2 += len;
-        } else {
-            @TYPE@_COPY(p1, p3, len);
+        }
+        else {
+            Tag::copy(p1, p3, len);
             p1 += len;
             p3 += len;
         }
     }
 
     if (p1 != p2) {
-        memcpy(p1, p3, sizeof(@type@) * (p2 - p1));
+        memcpy(p1, p3, sizeof(type) * (p2 - p1));
     }
 }
 
-
+template 
 static void
-merge_right_@suff@(@type@ *p1, npy_intp l1, @type@ *p2, npy_intp l2,
-                   @type@ *p3, size_t len)
+merge_right_(type *p1, npy_intp l1, type *p2, npy_intp l2, type *p3,
+             size_t len)
 {
     npy_intp ofs;
-    @type@ *start = p1 - len;
-    memcpy(p3, p2, sizeof(@type@) * l2 * len);
+    type *start = p1 - len;
+    memcpy(p3, p2, sizeof(type) * l2 * len);
     p1 += (l1 - 1) * len;
     p2 += (l2 - 1) * len;
     p3 += (l2 - 1) * len;
     /* first element must be in p1 otherwise skipped in the caller */
-    @TYPE@_COPY(p2, p1, len);
+    Tag::copy(p2, p1, len);
     p2 -= len;
     p1 -= len;
 
     while (p1 < p2 && start < p1) {
-        if (@TYPE@_LT(p3, p1, len)) {
-            @TYPE@_COPY(p2, p1, len);
+        if (Tag::less(p3, p1, len)) {
+            Tag::copy(p2, p1, len);
             p2 -= len;
             p1 -= len;
-        } else {
-            @TYPE@_COPY(p2, p3, len);
+        }
+        else {
+            Tag::copy(p2, p3, len);
             p2 -= len;
             p3 -= len;
         }
@@ -1166,25 +1222,25 @@ merge_right_@suff@(@type@ *p1, npy_intp l1, @type@ *p2, npy_intp l2,
 
     if (p1 != p2) {
         ofs = p2 - start;
-        memcpy(start + len, p3 - ofs + len, sizeof(@type@) * ofs);
+        memcpy(start + len, p3 - ofs + len, sizeof(type) * ofs);
     }
 }
 
-
+template 
 static int
-merge_at_@suff@(@type@ *arr, const run *stack, const npy_intp at,
-                buffer_@suff@ *buffer, size_t len)
+merge_at_(type *arr, const run *stack, const npy_intp at,
+          string_buffer_ *buffer, size_t len)
 {
     int ret;
     npy_intp s1, l1, s2, l2, k;
-    @type@ *p1, *p2;
+    type *p1, *p2;
     s1 = stack[at].s;
     l1 = stack[at].l;
     s2 = stack[at + 1].s;
     l2 = stack[at + 1].l;
     /* arr[s2] belongs to arr[s1+k] */
-    @TYPE@_COPY(buffer->pw, arr + s2 * len, len);
-    k = gallop_right_@suff@(arr + s1 * len, l1, buffer->pw, len);
+    Tag::copy(buffer->pw, arr + s2 * len, len);
+    k = gallop_right_(arr + s1 * len, l1, buffer->pw, len);
 
     if (l1 == k) {
         /* already sorted */
@@ -1195,30 +1251,35 @@ merge_at_@suff@(@type@ *arr, const run *stack, const npy_intp at,
     l1 -= k;
     p2 = arr + s2 * len;
     /* arr[s2-1] belongs to arr[s2+l2] */
-    @TYPE@_COPY(buffer->pw, arr + (s2 - 1) * len, len);
-    l2 = gallop_left_@suff@(arr + s2 * len, l2, buffer->pw, len);
+    Tag::copy(buffer->pw, arr + (s2 - 1) * len, len);
+    l2 = gallop_left_(arr + s2 * len, l2, buffer->pw, len);
 
     if (l2 < l1) {
-        ret = resize_buffer_@suff@(buffer, l2);
+        ret = resize_buffer_(buffer, l2);
 
-        if (NPY_UNLIKELY(ret < 0)) { return ret; }
+        if (NPY_UNLIKELY(ret < 0)) {
+            return ret;
+        }
 
-        merge_right_@suff@(p1, l1, p2, l2, buffer->pw, len);
-    } else {
-        ret = resize_buffer_@suff@(buffer, l1);
+        merge_right_(p1, l1, p2, l2, buffer->pw, len);
+    }
+    else {
+        ret = resize_buffer_(buffer, l1);
 
-        if (NPY_UNLIKELY(ret < 0)) { return ret; }
+        if (NPY_UNLIKELY(ret < 0)) {
+            return ret;
+        }
 
-        merge_left_@suff@(p1, l1, p2, l2, buffer->pw, len);
+        merge_left_(p1, l1, p2, l2, buffer->pw, len);
     }
 
     return 0;
 }
 
-
+template 
 static int
-try_collapse_@suff@(@type@ *arr, run *stack, npy_intp *stack_ptr,
-                    buffer_@suff@ *buffer, size_t len)
+try_collapse_(type *arr, run *stack, npy_intp *stack_ptr,
+              string_buffer_ *buffer, size_t len)
 {
     int ret;
     npy_intp A, B, C, top;
@@ -1229,33 +1290,42 @@ try_collapse_@suff@(@type@ *arr, run *stack, npy_intp *stack_ptr,
         C = stack[top - 1].l;
 
         if ((2 < top && stack[top - 3].l <= B + C) ||
-                (3 < top && stack[top - 4].l <= stack[top - 3].l + B)) {
+            (3 < top && stack[top - 4].l <= stack[top - 3].l + B)) {
             A = stack[top - 3].l;
 
             if (A <= C) {
-                ret = merge_at_@suff@(arr, stack, top - 3, buffer, len);
+                ret = merge_at_(arr, stack, top - 3, buffer, len);
 
-                if (NPY_UNLIKELY(ret < 0)) { return ret; }
+                if (NPY_UNLIKELY(ret < 0)) {
+                    return ret;
+                }
 
                 stack[top - 3].l += B;
                 stack[top - 2] = stack[top - 1];
                 --top;
-            } else {
-                ret = merge_at_@suff@(arr, stack, top - 2, buffer, len);
+            }
+            else {
+                ret = merge_at_(arr, stack, top - 2, buffer, len);
 
-                if (NPY_UNLIKELY(ret < 0)) { return ret; }
+                if (NPY_UNLIKELY(ret < 0)) {
+                    return ret;
+                }
 
                 stack[top - 2].l += C;
                 --top;
             }
-        } else if (1 < top && B <= C) {
-            ret = merge_at_@suff@(arr, stack, top - 2, buffer, len);
+        }
+        else if (1 < top && B <= C) {
+            ret = merge_at_(arr, stack, top - 2, buffer, len);
 
-            if (NPY_UNLIKELY(ret < 0)) { return ret; }
+            if (NPY_UNLIKELY(ret < 0)) {
+                return ret;
+            }
 
             stack[top - 2].l += C;
             --top;
-        } else {
+        }
+        else {
             break;
         }
     }
@@ -1264,27 +1334,32 @@ try_collapse_@suff@(@type@ *arr, run *stack, npy_intp *stack_ptr,
     return 0;
 }
 
-
+template 
 static int
-force_collapse_@suff@(@type@ *arr, run *stack, npy_intp *stack_ptr,
-                      buffer_@suff@ *buffer, size_t len)
+force_collapse_(type *arr, run *stack, npy_intp *stack_ptr,
+                string_buffer_ *buffer, size_t len)
 {
     int ret;
     npy_intp top = *stack_ptr;
 
     while (2 < top) {
         if (stack[top - 3].l <= stack[top - 1].l) {
-            ret = merge_at_@suff@(arr, stack, top - 3, buffer, len);
+            ret = merge_at_(arr, stack, top - 3, buffer, len);
 
-            if (NPY_UNLIKELY(ret < 0)) { return ret; }
+            if (NPY_UNLIKELY(ret < 0)) {
+                return ret;
+            }
 
             stack[top - 3].l += stack[top - 2].l;
             stack[top - 2] = stack[top - 1];
             --top;
-        } else {
-            ret = merge_at_@suff@(arr, stack, top - 2, buffer, len);
+        }
+        else {
+            ret = merge_at_(arr, stack, top - 2, buffer, len);
 
-            if (NPY_UNLIKELY(ret < 0)) { return ret; }
+            if (NPY_UNLIKELY(ret < 0)) {
+                return ret;
+            }
 
             stack[top - 2].l += stack[top - 1].l;
             --top;
@@ -1292,25 +1367,28 @@ force_collapse_@suff@(@type@ *arr, run *stack, npy_intp *stack_ptr,
     }
 
     if (1 < top) {
-        ret = merge_at_@suff@(arr, stack, top - 2, buffer, len);
+        ret = merge_at_(arr, stack, top - 2, buffer, len);
 
-        if (NPY_UNLIKELY(ret < 0)) { return ret; }
+        if (NPY_UNLIKELY(ret < 0)) {
+            return ret;
+        }
     }
 
     return 0;
 }
 
-
+template 
 NPY_NO_EXPORT int
-timsort_@suff@(void *start, npy_intp num, void *varr)
+string_timsort_(void *start, npy_intp num, void *varr)
 {
-    PyArrayObject *arr = varr;
+    using type = typename Tag::type;
+    PyArrayObject *arr = reinterpret_cast(varr);
     size_t elsize = PyArray_ITEMSIZE(arr);
-    size_t len = elsize / sizeof(@type@);
+    size_t len = elsize / sizeof(type);
     int ret;
     npy_intp l, n, stack_ptr, minrun;
     run stack[TIMSORT_STACK_SIZE];
-    buffer_@suff@ buffer;
+    string_buffer_ buffer;
 
     /* Items that have zero size don't make sense to sort */
     if (len == 0) {
@@ -1323,26 +1401,33 @@ timsort_@suff@(void *start, npy_intp num, void *varr)
     stack_ptr = 0;
     minrun = compute_min_run_short(num);
     /* used for insertion sort and gallop key */
-    ret = resize_buffer_@suff@(&buffer, 1);
+    ret = resize_buffer_(&buffer, 1);
 
-    if (NPY_UNLIKELY(ret < 0)) { goto cleanup; }
+    if (NPY_UNLIKELY(ret < 0)) {
+        goto cleanup;
+    }
 
     for (l = 0; l < num;) {
-        n = count_run_@suff@(start, l, num, minrun, buffer.pw, len);
+        n = count_run_((type *)start, l, num, minrun, buffer.pw, len);
         /* both s and l are scaled by len */
         stack[stack_ptr].s = l;
         stack[stack_ptr].l = n;
         ++stack_ptr;
-        ret = try_collapse_@suff@(start, stack, &stack_ptr, &buffer, len);
+        ret = try_collapse_((type *)start, stack, &stack_ptr, &buffer,
+                                 len);
 
-        if (NPY_UNLIKELY(ret < 0)) { goto cleanup; }
+        if (NPY_UNLIKELY(ret < 0)) {
+            goto cleanup;
+        }
 
         l += n;
     }
 
-    ret = force_collapse_@suff@(start, stack, &stack_ptr, &buffer, len);
+    ret = force_collapse_((type *)start, stack, &stack_ptr, &buffer, len);
 
-    if (NPY_UNLIKELY(ret < 0)) { goto cleanup; }
+    if (NPY_UNLIKELY(ret < 0)) {
+        goto cleanup;
+    }
 
     ret = 0;
 
@@ -1353,13 +1438,12 @@ timsort_@suff@(void *start, npy_intp num, void *varr)
     return ret;
 }
 
-
 /* argsort */
 
-
+template 
 static npy_intp
-acount_run_@suff@(@type@ *arr, npy_intp *tosort, npy_intp l, npy_intp num,
-                  npy_intp minrun, size_t len)
+acount_run_(type *arr, npy_intp *tosort, npy_intp l, npy_intp num,
+            npy_intp minrun, size_t len)
 {
     npy_intp sz;
     npy_intp vi;
@@ -1372,17 +1456,22 @@ acount_run_@suff@(@type@ *arr, npy_intp *tosort, npy_intp l, npy_intp num,
     pl = tosort + l;
 
     /* (not strictly) ascending sequence */
-    if (!@TYPE@_LT(arr + (*(pl + 1)) * len, arr + (*pl) * len, len)) {
-        for (pi = pl + 1; pi < tosort + num - 1
-                && !@TYPE@_LT(arr + (*(pi + 1)) * len, arr + (*pi) * len, len); ++pi) {
+    if (!Tag::less(arr + (*(pl + 1)) * len, arr + (*pl) * len, len)) {
+        for (pi = pl + 1;
+             pi < tosort + num - 1 &&
+             !Tag::less(arr + (*(pi + 1)) * len, arr + (*pi) * len, len);
+             ++pi) {
         }
-    } else {  /* (strictly) descending sequence */
-        for (pi = pl + 1; pi < tosort + num - 1
-                && @TYPE@_LT(arr + (*(pi + 1)) * len, arr + (*pi) * len, len); ++pi) {
+    }
+    else { /* (strictly) descending sequence */
+        for (pi = pl + 1;
+             pi < tosort + num - 1 &&
+             Tag::less(arr + (*(pi + 1)) * len, arr + (*pi) * len, len);
+             ++pi) {
         }
 
         for (pj = pl, pr = pi; pj < pr; ++pj, --pr) {
-            INTP_SWAP(*pj, *pr);
+            std::swap(*pj, *pr);
         }
     }
 
@@ -1392,7 +1481,8 @@ acount_run_@suff@(@type@ *arr, npy_intp *tosort, npy_intp l, npy_intp num,
     if (sz < minrun) {
         if (l + minrun < num) {
             sz = minrun;
-        } else {
+        }
+        else {
             sz = num - l;
         }
 
@@ -1403,7 +1493,8 @@ acount_run_@suff@(@type@ *arr, npy_intp *tosort, npy_intp l, npy_intp num,
             vi = *pi;
             pj = pi;
 
-            while (pl < pj && @TYPE@_LT(arr + vi * len, arr + (*(pj - 1)) * len, len)) {
+            while (pl < pj &&
+                   Tag::less(arr + vi * len, arr + (*(pj - 1)) * len, len)) {
                 *pj = *(pj - 1);
                 --pj;
             }
@@ -1415,14 +1506,14 @@ acount_run_@suff@(@type@ *arr, npy_intp *tosort, npy_intp l, npy_intp num,
     return sz;
 }
 
-
+template 
 static npy_intp
-agallop_left_@suff@(const @type@ *arr, const npy_intp *tosort,
-                    const npy_intp size, const @type@ *key, size_t len)
+agallop_left_(const type *arr, const npy_intp *tosort, const npy_intp size,
+              const type *key, size_t len)
 {
     npy_intp last_ofs, ofs, l, m, r;
 
-    if (@TYPE@_LT(arr + tosort[size - 1] * len, key, len)) {
+    if (Tag::less(arr + tosort[size - 1] * len, key, len)) {
         return size;
     }
 
@@ -1435,24 +1526,27 @@ agallop_left_@suff@(const @type@ *arr, const npy_intp *tosort,
             break;
         }
 
-        if (@TYPE@_LT(arr + tosort[size - ofs - 1] * len, key, len)) {
+        if (Tag::less(arr + tosort[size - ofs - 1] * len, key, len)) {
             break;
-        } else {
+        }
+        else {
             last_ofs = ofs;
             ofs = (ofs << 1) + 1;
         }
     }
 
-    /* now that arr[tosort[size-ofs-1]*len] < key <= arr[tosort[size-last_ofs-1]*len] */
+    /* now that arr[tosort[size-ofs-1]*len] < key <=
+     * arr[tosort[size-last_ofs-1]*len] */
     l = size - ofs - 1;
     r = size - last_ofs - 1;
 
     while (l + 1 < r) {
         m = l + ((r - l) >> 1);
 
-        if (@TYPE@_LT(arr + tosort[m] * len, key, len)) {
+        if (Tag::less(arr + tosort[m] * len, key, len)) {
             l = m;
-        } else {
+        }
+        else {
             r = m;
         }
     }
@@ -1461,14 +1555,14 @@ agallop_left_@suff@(const @type@ *arr, const npy_intp *tosort,
     return r;
 }
 
-
+template 
 static npy_intp
-agallop_right_@suff@(const @type@ *arr, const npy_intp *tosort,
-                     const npy_intp size, const @type@ *key, size_t len)
+agallop_right_(const type *arr, const npy_intp *tosort, const npy_intp size,
+               const type *key, size_t len)
 {
     npy_intp last_ofs, ofs, m;
 
-    if (@TYPE@_LT(key, arr + tosort[0] * len, len)) {
+    if (Tag::less(key, arr + tosort[0] * len, len)) {
         return 0;
     }
 
@@ -1481,9 +1575,10 @@ agallop_right_@suff@(const @type@ *arr, const npy_intp *tosort,
             break;
         }
 
-        if (@TYPE@_LT(key, arr + tosort[ofs] * len, len)) {
+        if (Tag::less(key, arr + tosort[ofs] * len, len)) {
             break;
-        } else {
+        }
+        else {
             last_ofs = ofs;
             /* ofs = 1, 3, 7, 15... */
             ofs = (ofs << 1) + 1;
@@ -1494,9 +1589,10 @@ agallop_right_@suff@(const @type@ *arr, const npy_intp *tosort,
     while (last_ofs + 1 < ofs) {
         m = last_ofs + ((ofs - last_ofs) >> 1);
 
-        if (@TYPE@_LT(key, arr + tosort[m] * len, len)) {
+        if (Tag::less(key, arr + tosort[m] * len, len)) {
             ofs = m;
-        } else {
+        }
+        else {
             last_ofs = m;
         }
     }
@@ -1505,11 +1601,10 @@ agallop_right_@suff@(const @type@ *arr, const npy_intp *tosort,
     return ofs;
 }
 
-
-
+template 
 static void
-amerge_left_@suff@(@type@ *arr, npy_intp *p1, npy_intp l1, npy_intp *p2,
-                   npy_intp l2, npy_intp *p3, size_t len)
+amerge_left_(type *arr, npy_intp *p1, npy_intp l1, npy_intp *p2, npy_intp l2,
+             npy_intp *p3, size_t len)
 {
     npy_intp *end = p2 + l2;
     memcpy(p3, p1, sizeof(npy_intp) * l1);
@@ -1517,9 +1612,10 @@ amerge_left_@suff@(@type@ *arr, npy_intp *p1, npy_intp l1, npy_intp *p2,
     *p1++ = *p2++;
 
     while (p1 < p2 && p2 < end) {
-        if (@TYPE@_LT(arr + (*p2) * len, arr + (*p3) * len, len)) {
+        if (Tag::less(arr + (*p2) * len, arr + (*p3) * len, len)) {
             *p1++ = *p2++;
-        } else {
+        }
+        else {
             *p1++ = *p3++;
         }
     }
@@ -1529,10 +1625,10 @@ amerge_left_@suff@(@type@ *arr, npy_intp *p1, npy_intp l1, npy_intp *p2,
     }
 }
 
-
+template 
 static void
-amerge_right_@suff@(@type@ *arr, npy_intp* p1, npy_intp l1, npy_intp *p2,
-                    npy_intp l2, npy_intp *p3, size_t len)
+amerge_right_(type *arr, npy_intp *p1, npy_intp l1, npy_intp *p2, npy_intp l2,
+              npy_intp *p3, size_t len)
 {
     npy_intp ofs;
     npy_intp *start = p1 - 1;
@@ -1544,9 +1640,10 @@ amerge_right_@suff@(@type@ *arr, npy_intp* p1, npy_intp l1, npy_intp *p2,
     *p2-- = *p1--;
 
     while (p1 < p2 && start < p1) {
-        if (@TYPE@_LT(arr + (*p3) * len, arr + (*p1) * len, len)) {
+        if (Tag::less(arr + (*p3) * len, arr + (*p1) * len, len)) {
             *p2-- = *p1--;
-        } else {
+        }
+        else {
             *p2-- = *p3--;
         }
     }
@@ -1557,11 +1654,10 @@ amerge_right_@suff@(@type@ *arr, npy_intp* p1, npy_intp l1, npy_intp *p2,
     }
 }
 
-
-
+template 
 static int
-amerge_at_@suff@(@type@ *arr, npy_intp *tosort, const run *stack,
-                 const npy_intp at, buffer_intp *buffer, size_t len)
+amerge_at_(type *arr, npy_intp *tosort, const run *stack, const npy_intp at,
+           buffer_intp *buffer, size_t len)
 {
     int ret;
     npy_intp s1, l1, s2, l2, k;
@@ -1571,7 +1667,7 @@ amerge_at_@suff@(@type@ *arr, npy_intp *tosort, const run *stack,
     s2 = stack[at + 1].s;
     l2 = stack[at + 1].l;
     /* tosort[s2] belongs to tosort[s1+k] */
-    k = agallop_right_@suff@(arr, tosort + s1, l1, arr + tosort[s2] * len, len);
+    k = agallop_right_(arr, tosort + s1, l1, arr + tosort[s2] * len, len);
 
     if (l1 == k) {
         /* already sorted */
@@ -1582,30 +1678,35 @@ amerge_at_@suff@(@type@ *arr, npy_intp *tosort, const run *stack,
     l1 -= k;
     p2 = tosort + s2;
     /* tosort[s2-1] belongs to tosort[s2+l2] */
-    l2 = agallop_left_@suff@(arr, tosort + s2, l2, arr + tosort[s2 - 1] * len,
-                             len);
+    l2 = agallop_left_(arr, tosort + s2, l2, arr + tosort[s2 - 1] * len,
+                            len);
 
     if (l2 < l1) {
         ret = resize_buffer_intp(buffer, l2);
 
-        if (NPY_UNLIKELY(ret < 0)) { return ret; }
+        if (NPY_UNLIKELY(ret < 0)) {
+            return ret;
+        }
 
-        amerge_right_@suff@(arr, p1, l1, p2, l2, buffer->pw, len);
-    } else {
+        amerge_right_(arr, p1, l1, p2, l2, buffer->pw, len);
+    }
+    else {
         ret = resize_buffer_intp(buffer, l1);
 
-        if (NPY_UNLIKELY(ret < 0)) { return ret; }
+        if (NPY_UNLIKELY(ret < 0)) {
+            return ret;
+        }
 
-        amerge_left_@suff@(arr, p1, l1, p2, l2, buffer->pw, len);
+        amerge_left_(arr, p1, l1, p2, l2, buffer->pw, len);
     }
 
     return 0;
 }
 
-
+template 
 static int
-atry_collapse_@suff@(@type@ *arr, npy_intp *tosort, run *stack,
-                     npy_intp *stack_ptr, buffer_intp *buffer, size_t len)
+atry_collapse_(type *arr, npy_intp *tosort, run *stack, npy_intp *stack_ptr,
+               buffer_intp *buffer, size_t len)
 {
     int ret;
     npy_intp A, B, C, top;
@@ -1616,33 +1717,44 @@ atry_collapse_@suff@(@type@ *arr, npy_intp *tosort, run *stack,
         C = stack[top - 1].l;
 
         if ((2 < top && stack[top - 3].l <= B + C) ||
-                (3 < top && stack[top - 4].l <= stack[top - 3].l + B)) {
+            (3 < top && stack[top - 4].l <= stack[top - 3].l + B)) {
             A = stack[top - 3].l;
 
             if (A <= C) {
-                ret = amerge_at_@suff@(arr, tosort, stack, top - 3, buffer, len);
+                ret = amerge_at_(arr, tosort, stack, top - 3, buffer,
+                                      len);
 
-                if (NPY_UNLIKELY(ret < 0)) { return ret; }
+                if (NPY_UNLIKELY(ret < 0)) {
+                    return ret;
+                }
 
                 stack[top - 3].l += B;
                 stack[top - 2] = stack[top - 1];
                 --top;
-            } else {
-                ret = amerge_at_@suff@(arr, tosort, stack, top - 2, buffer, len);
+            }
+            else {
+                ret = amerge_at_(arr, tosort, stack, top - 2, buffer,
+                                      len);
 
-                if (NPY_UNLIKELY(ret < 0)) { return ret; }
+                if (NPY_UNLIKELY(ret < 0)) {
+                    return ret;
+                }
 
                 stack[top - 2].l += C;
                 --top;
             }
-        } else if (1 < top && B <= C) {
-            ret = amerge_at_@suff@(arr, tosort, stack, top - 2, buffer, len);
+        }
+        else if (1 < top && B <= C) {
+            ret = amerge_at_(arr, tosort, stack, top - 2, buffer, len);
 
-            if (NPY_UNLIKELY(ret < 0)) { return ret; }
+            if (NPY_UNLIKELY(ret < 0)) {
+                return ret;
+            }
 
             stack[top - 2].l += C;
             --top;
-        } else {
+        }
+        else {
             break;
         }
     }
@@ -1651,28 +1763,32 @@ atry_collapse_@suff@(@type@ *arr, npy_intp *tosort, run *stack,
     return 0;
 }
 
-
-
+template 
 static int
-aforce_collapse_@suff@(@type@ *arr, npy_intp *tosort, run *stack,
-                       npy_intp *stack_ptr, buffer_intp *buffer, size_t len)
+aforce_collapse_(type *arr, npy_intp *tosort, run *stack, npy_intp *stack_ptr,
+                 buffer_intp *buffer, size_t len)
 {
     int ret;
     npy_intp top = *stack_ptr;
 
     while (2 < top) {
         if (stack[top - 3].l <= stack[top - 1].l) {
-            ret = amerge_at_@suff@(arr, tosort, stack, top - 3, buffer, len);
+            ret = amerge_at_(arr, tosort, stack, top - 3, buffer, len);
 
-            if (NPY_UNLIKELY(ret < 0)) { return ret; }
+            if (NPY_UNLIKELY(ret < 0)) {
+                return ret;
+            }
 
             stack[top - 3].l += stack[top - 2].l;
             stack[top - 2] = stack[top - 1];
             --top;
-        } else {
-            ret = amerge_at_@suff@(arr, tosort, stack, top - 2, buffer, len);
+        }
+        else {
+            ret = amerge_at_(arr, tosort, stack, top - 2, buffer, len);
 
-            if (NPY_UNLIKELY(ret < 0)) { return ret; }
+            if (NPY_UNLIKELY(ret < 0)) {
+                return ret;
+            }
 
             stack[top - 2].l += stack[top - 1].l;
             --top;
@@ -1680,21 +1796,24 @@ aforce_collapse_@suff@(@type@ *arr, npy_intp *tosort, run *stack,
     }
 
     if (1 < top) {
-        ret = amerge_at_@suff@(arr, tosort, stack, top - 2, buffer, len);
+        ret = amerge_at_(arr, tosort, stack, top - 2, buffer, len);
 
-        if (NPY_UNLIKELY(ret < 0)) { return ret; }
+        if (NPY_UNLIKELY(ret < 0)) {
+            return ret;
+        }
     }
 
     return 0;
 }
 
-
+template 
 NPY_NO_EXPORT int
-atimsort_@suff@(void *start, npy_intp *tosort, npy_intp num, void *varr)
+string_atimsort_(void *start, npy_intp *tosort, npy_intp num, void *varr)
 {
-    PyArrayObject *arr = varr;
+    using type = typename Tag::type;
+    PyArrayObject *arr = reinterpret_cast(varr);
     size_t elsize = PyArray_ITEMSIZE(arr);
-    size_t len = elsize / sizeof(@type@);
+    size_t len = elsize / sizeof(type);
     int ret;
     npy_intp l, n, stack_ptr, minrun;
     run stack[TIMSORT_STACK_SIZE];
@@ -1711,21 +1830,27 @@ atimsort_@suff@(void *start, npy_intp *tosort, npy_intp num, void *varr)
     minrun = compute_min_run_short(num);
 
     for (l = 0; l < num;) {
-        n = acount_run_@suff@(start, tosort, l, num, minrun, len);
+        n = acount_run_((type *)start, tosort, l, num, minrun, len);
         /* both s and l are scaled by len */
         stack[stack_ptr].s = l;
         stack[stack_ptr].l = n;
         ++stack_ptr;
-        ret = atry_collapse_@suff@(start, tosort, stack, &stack_ptr, &buffer, len);
+        ret = atry_collapse_((type *)start, tosort, stack, &stack_ptr,
+                                  &buffer, len);
 
-        if (NPY_UNLIKELY(ret < 0)) { goto cleanup; }
+        if (NPY_UNLIKELY(ret < 0)) {
+            goto cleanup;
+        }
 
         l += n;
     }
 
-    ret = aforce_collapse_@suff@(start, tosort, stack, &stack_ptr, &buffer, len);
+    ret = aforce_collapse_((type *)start, tosort, stack, &stack_ptr,
+                                &buffer, len);
 
-    if (NPY_UNLIKELY(ret < 0)) { goto cleanup; }
+    if (NPY_UNLIKELY(ret < 0)) {
+        goto cleanup;
+    }
 
     ret = 0;
 
@@ -1736,26 +1861,19 @@ atimsort_@suff@(void *start, npy_intp *tosort, npy_intp num, void *varr)
     return ret;
 }
 
-
-/**end repeat**/
-
-
-
 /*
  *****************************************************************************
  **                             GENERIC SORT                                **
  *****************************************************************************
  */
 
-
 typedef struct {
     char *pw;
     npy_intp size;
     size_t len;
 } buffer_char;
 
-
-static NPY_INLINE int
+static inline int
 resize_buffer_char(buffer_char *buffer, npy_intp new_size)
 {
     if (new_size <= buffer->size) {
@@ -1763,24 +1881,26 @@ resize_buffer_char(buffer_char *buffer, npy_intp new_size)
     }
 
     if (NPY_UNLIKELY(buffer->pw == NULL)) {
-        buffer->pw = malloc(sizeof(char) * new_size * buffer->len);
-    } else {
-        buffer->pw = realloc(buffer->pw,  sizeof(char) * new_size * buffer->len);
+        buffer->pw = (char *)malloc(sizeof(char) * new_size * buffer->len);
+    }
+    else {
+        buffer->pw = (char *)realloc(buffer->pw,
+                                     sizeof(char) * new_size * buffer->len);
     }
 
     buffer->size = new_size;
 
     if (NPY_UNLIKELY(buffer->pw == NULL)) {
         return -NPY_ENOMEM;
-    } else {
+    }
+    else {
         return 0;
     }
 }
 
-
 static npy_intp
-npy_count_run(char *arr, npy_intp l, npy_intp num, npy_intp minrun,
-              char *vp, size_t len, PyArray_CompareFunc *cmp, PyArrayObject *py_arr)
+npy_count_run(char *arr, npy_intp l, npy_intp num, npy_intp minrun, char *vp,
+              size_t len, PyArray_CompareFunc *cmp, PyArrayObject *py_arr)
 {
     npy_intp sz;
     char *pl, *pi, *pj, *pr;
@@ -1793,12 +1913,15 @@ npy_count_run(char *arr, npy_intp l, npy_intp num, npy_intp minrun,
 
     /* (not strictly) ascending sequence */
     if (cmp(pl, pl + len, py_arr) <= 0) {
-        for (pi = pl + len; pi < arr + (num - 1) * len
-                && cmp(pi, pi + len, py_arr) <= 0; pi += len) {
+        for (pi = pl + len;
+             pi < arr + (num - 1) * len && cmp(pi, pi + len, py_arr) <= 0;
+             pi += len) {
         }
-    } else {  /* (strictly) descending sequence */
-        for (pi = pl + len; pi < arr + (num - 1) * len
-                && cmp(pi + len, pi, py_arr) < 0; pi += len) {
+    }
+    else { /* (strictly) descending sequence */
+        for (pi = pl + len;
+             pi < arr + (num - 1) * len && cmp(pi + len, pi, py_arr) < 0;
+             pi += len) {
         }
 
         for (pj = pl, pr = pi; pj < pr; pj += len, pr -= len) {
@@ -1812,7 +1935,8 @@ npy_count_run(char *arr, npy_intp l, npy_intp num, npy_intp minrun,
     if (sz < minrun) {
         if (l + minrun < num) {
             sz = minrun;
-        } else {
+        }
+        else {
             sz = num - l;
         }
 
@@ -1835,7 +1959,6 @@ npy_count_run(char *arr, npy_intp l, npy_intp num, npy_intp minrun,
     return sz;
 }
 
-
 static npy_intp
 npy_gallop_right(const char *arr, const npy_intp size, const char *key,
                  size_t len, PyArray_CompareFunc *cmp, PyArrayObject *py_arr)
@@ -1857,7 +1980,8 @@ npy_gallop_right(const char *arr, const npy_intp size, const char *key,
 
         if (cmp(key, arr + ofs * len, py_arr) < 0) {
             break;
-        } else {
+        }
+        else {
             last_ofs = ofs;
             /* ofs = 1, 3, 7, 15... */
             ofs = (ofs << 1) + 1;
@@ -1870,7 +1994,8 @@ npy_gallop_right(const char *arr, const npy_intp size, const char *key,
 
         if (cmp(key, arr + m * len, py_arr) < 0) {
             ofs = m;
-        } else {
+        }
+        else {
             last_ofs = m;
         }
     }
@@ -1879,8 +2004,6 @@ npy_gallop_right(const char *arr, const npy_intp size, const char *key,
     return ofs;
 }
 
-
-
 static npy_intp
 npy_gallop_left(const char *arr, const npy_intp size, const char *key,
                 size_t len, PyArray_CompareFunc *cmp, PyArrayObject *py_arr)
@@ -1902,7 +2025,8 @@ npy_gallop_left(const char *arr, const npy_intp size, const char *key,
 
         if (cmp(arr + (size - ofs - 1) * len, key, py_arr) < 0) {
             break;
-        } else {
+        }
+        else {
             last_ofs = ofs;
             ofs = (ofs << 1) + 1;
         }
@@ -1917,7 +2041,8 @@ npy_gallop_left(const char *arr, const npy_intp size, const char *key,
 
         if (cmp(arr + m * len, key, py_arr) < 0) {
             l = m;
-        } else {
+        }
+        else {
             r = m;
         }
     }
@@ -1926,11 +2051,9 @@ npy_gallop_left(const char *arr, const npy_intp size, const char *key,
     return r;
 }
 
-
 static void
-npy_merge_left(char *p1, npy_intp l1, char *p2, npy_intp l2,
-               char *p3, size_t len,
-               PyArray_CompareFunc *cmp, PyArrayObject *py_arr)
+npy_merge_left(char *p1, npy_intp l1, char *p2, npy_intp l2, char *p3,
+               size_t len, PyArray_CompareFunc *cmp, PyArrayObject *py_arr)
 {
     char *end = p2 + l2 * len;
     memcpy(p3, p1, sizeof(char) * l1 * len);
@@ -1944,7 +2067,8 @@ npy_merge_left(char *p1, npy_intp l1, char *p2, npy_intp l2,
             GENERIC_COPY(p1, p2, len);
             p1 += len;
             p2 += len;
-        } else {
+        }
+        else {
             GENERIC_COPY(p1, p3, len);
             p1 += len;
             p3 += len;
@@ -1956,11 +2080,9 @@ npy_merge_left(char *p1, npy_intp l1, char *p2, npy_intp l2,
     }
 }
 
-
 static void
-npy_merge_right(char *p1, npy_intp l1, char *p2, npy_intp l2,
-                char *p3, size_t len,
-                PyArray_CompareFunc *cmp, PyArrayObject *py_arr)
+npy_merge_right(char *p1, npy_intp l1, char *p2, npy_intp l2, char *p3,
+                size_t len, PyArray_CompareFunc *cmp, PyArrayObject *py_arr)
 {
     npy_intp ofs;
     char *start = p1 - len;
@@ -1978,7 +2100,8 @@ npy_merge_right(char *p1, npy_intp l1, char *p2, npy_intp l2,
             GENERIC_COPY(p2, p1, len);
             p2 -= len;
             p1 -= len;
-        } else {
+        }
+        else {
             GENERIC_COPY(p2, p3, len);
             p2 -= len;
             p3 -= len;
@@ -1991,12 +2114,10 @@ npy_merge_right(char *p1, npy_intp l1, char *p2, npy_intp l2,
     }
 }
 
-
-
 static int
 npy_merge_at(char *arr, const run *stack, const npy_intp at,
-             buffer_char *buffer, size_t len,
-             PyArray_CompareFunc *cmp, PyArrayObject *py_arr)
+             buffer_char *buffer, size_t len, PyArray_CompareFunc *cmp,
+             PyArrayObject *py_arr)
 {
     int ret;
     npy_intp s1, l1, s2, l2, k;
@@ -2024,13 +2145,18 @@ npy_merge_at(char *arr, const run *stack, const npy_intp at,
     if (l2 < l1) {
         ret = resize_buffer_char(buffer, l2);
 
-        if (NPY_UNLIKELY(ret < 0)) { return ret; }
+        if (NPY_UNLIKELY(ret < 0)) {
+            return ret;
+        }
 
         npy_merge_right(p1, l1, p2, l2, buffer->pw, len, cmp, py_arr);
-    } else {
+    }
+    else {
         ret = resize_buffer_char(buffer, l1);
 
-        if (NPY_UNLIKELY(ret < 0)) { return ret; }
+        if (NPY_UNLIKELY(ret < 0)) {
+            return ret;
+        }
 
         npy_merge_left(p1, l1, p2, l2, buffer->pw, len, cmp, py_arr);
     }
@@ -2038,11 +2164,10 @@ npy_merge_at(char *arr, const run *stack, const npy_intp at,
     return 0;
 }
 
-
 static int
 npy_try_collapse(char *arr, run *stack, npy_intp *stack_ptr,
-                 buffer_char *buffer, size_t len,
-                 PyArray_CompareFunc *cmp, PyArrayObject *py_arr)
+                 buffer_char *buffer, size_t len, PyArray_CompareFunc *cmp,
+                 PyArrayObject *py_arr)
 {
     int ret;
     npy_intp A, B, C, top;
@@ -2053,33 +2178,44 @@ npy_try_collapse(char *arr, run *stack, npy_intp *stack_ptr,
         C = stack[top - 1].l;
 
         if ((2 < top && stack[top - 3].l <= B + C) ||
-                (3 < top && stack[top - 4].l <= stack[top - 3].l + B)) {
+            (3 < top && stack[top - 4].l <= stack[top - 3].l + B)) {
             A = stack[top - 3].l;
 
             if (A <= C) {
-                ret = npy_merge_at(arr, stack, top - 3, buffer, len, cmp, py_arr);
+                ret = npy_merge_at(arr, stack, top - 3, buffer, len, cmp,
+                                   py_arr);
 
-                if (NPY_UNLIKELY(ret < 0)) { return ret; }
+                if (NPY_UNLIKELY(ret < 0)) {
+                    return ret;
+                }
 
                 stack[top - 3].l += B;
                 stack[top - 2] = stack[top - 1];
                 --top;
-            } else {
-                ret = npy_merge_at(arr, stack, top - 2, buffer, len, cmp, py_arr);
+            }
+            else {
+                ret = npy_merge_at(arr, stack, top - 2, buffer, len, cmp,
+                                   py_arr);
 
-                if (NPY_UNLIKELY(ret < 0)) { return ret; }
+                if (NPY_UNLIKELY(ret < 0)) {
+                    return ret;
+                }
 
                 stack[top - 2].l += C;
                 --top;
             }
-        } else if (1 < top && B <= C) {
+        }
+        else if (1 < top && B <= C) {
             ret = npy_merge_at(arr, stack, top - 2, buffer, len, cmp, py_arr);
 
-            if (NPY_UNLIKELY(ret < 0)) { return ret; }
+            if (NPY_UNLIKELY(ret < 0)) {
+                return ret;
+            }
 
             stack[top - 2].l += C;
             --top;
-        } else {
+        }
+        else {
             break;
         }
     }
@@ -2088,11 +2224,10 @@ npy_try_collapse(char *arr, run *stack, npy_intp *stack_ptr,
     return 0;
 }
 
-
 static int
 npy_force_collapse(char *arr, run *stack, npy_intp *stack_ptr,
-                   buffer_char *buffer, size_t len,
-                   PyArray_CompareFunc *cmp, PyArrayObject *py_arr)
+                   buffer_char *buffer, size_t len, PyArray_CompareFunc *cmp,
+                   PyArrayObject *py_arr)
 {
     int ret;
     npy_intp top = *stack_ptr;
@@ -2101,15 +2236,20 @@ npy_force_collapse(char *arr, run *stack, npy_intp *stack_ptr,
         if (stack[top - 3].l <= stack[top - 1].l) {
             ret = npy_merge_at(arr, stack, top - 3, buffer, len, cmp, py_arr);
 
-            if (NPY_UNLIKELY(ret < 0)) { return ret; }
+            if (NPY_UNLIKELY(ret < 0)) {
+                return ret;
+            }
 
             stack[top - 3].l += stack[top - 2].l;
             stack[top - 2] = stack[top - 1];
             --top;
-        } else {
+        }
+        else {
             ret = npy_merge_at(arr, stack, top - 2, buffer, len, cmp, py_arr);
 
-            if (NPY_UNLIKELY(ret < 0)) { return ret; }
+            if (NPY_UNLIKELY(ret < 0)) {
+                return ret;
+            }
 
             stack[top - 2].l += stack[top - 1].l;
             --top;
@@ -2119,17 +2259,18 @@ npy_force_collapse(char *arr, run *stack, npy_intp *stack_ptr,
     if (1 < top) {
         ret = npy_merge_at(arr, stack, top - 2, buffer, len, cmp, py_arr);
 
-        if (NPY_UNLIKELY(ret < 0)) { return ret; }
+        if (NPY_UNLIKELY(ret < 0)) {
+            return ret;
+        }
     }
 
     return 0;
 }
 
-
 NPY_NO_EXPORT int
 npy_timsort(void *start, npy_intp num, void *varr)
 {
-    PyArrayObject *arr = varr;
+    PyArrayObject *arr = reinterpret_cast(varr);
     size_t len = PyArray_ITEMSIZE(arr);
     PyArray_CompareFunc *cmp = PyArray_DESCR(arr)->f->compare;
     int ret;
@@ -2151,25 +2292,34 @@ npy_timsort(void *start, npy_intp num, void *varr)
     /* used for insertion sort and gallop key */
     ret = resize_buffer_char(&buffer, len);
 
-    if (NPY_UNLIKELY(ret < 0)) { goto cleanup; }
+    if (NPY_UNLIKELY(ret < 0)) {
+        goto cleanup;
+    }
 
     for (l = 0; l < num;) {
-        n = npy_count_run(start, l, num, minrun, buffer.pw, len, cmp, arr);
+        n = npy_count_run((char *)start, l, num, minrun, buffer.pw, len, cmp,
+                          arr);
 
         /* both s and l are scaled by len */
         stack[stack_ptr].s = l;
         stack[stack_ptr].l = n;
         ++stack_ptr;
-        ret = npy_try_collapse(start, stack, &stack_ptr, &buffer, len, cmp, arr);
+        ret = npy_try_collapse((char *)start, stack, &stack_ptr, &buffer, len,
+                               cmp, arr);
 
-        if (NPY_UNLIKELY(ret < 0)) { goto cleanup; }
+        if (NPY_UNLIKELY(ret < 0)) {
+            goto cleanup;
+        }
 
         l += n;
     }
 
-    ret = npy_force_collapse(start, stack, &stack_ptr, &buffer, len, cmp, arr);
+    ret = npy_force_collapse((char *)start, stack, &stack_ptr, &buffer, len,
+                             cmp, arr);
 
-    if (NPY_UNLIKELY(ret < 0)) { goto cleanup; }
+    if (NPY_UNLIKELY(ret < 0)) {
+        goto cleanup;
+    }
 
     ret = 0;
 
@@ -2180,13 +2330,12 @@ npy_timsort(void *start, npy_intp num, void *varr)
     return ret;
 }
 
-
 /* argsort */
 
 static npy_intp
 npy_acount_run(char *arr, npy_intp *tosort, npy_intp l, npy_intp num,
-               npy_intp minrun, size_t len,
-               PyArray_CompareFunc *cmp, PyArrayObject *py_arr)
+               npy_intp minrun, size_t len, PyArray_CompareFunc *cmp,
+               PyArrayObject *py_arr)
 {
     npy_intp sz;
     npy_intp vi;
@@ -2200,16 +2349,21 @@ npy_acount_run(char *arr, npy_intp *tosort, npy_intp l, npy_intp num,
 
     /* (not strictly) ascending sequence */
     if (cmp(arr + (*pl) * len, arr + (*(pl + 1)) * len, py_arr) <= 0) {
-        for (pi = pl + 1; pi < tosort + num - 1
-                && cmp(arr + (*pi) * len, arr + (*(pi + 1)) * len, py_arr) <= 0; ++pi) {
+        for (pi = pl + 1;
+             pi < tosort + num - 1 &&
+             cmp(arr + (*pi) * len, arr + (*(pi + 1)) * len, py_arr) <= 0;
+             ++pi) {
         }
-    } else {  /* (strictly) descending sequence */
-        for (pi = pl + 1; pi < tosort + num - 1
-                && cmp(arr + (*(pi + 1)) * len, arr + (*pi) * len, py_arr) < 0; ++pi) {
+    }
+    else { /* (strictly) descending sequence */
+        for (pi = pl + 1;
+             pi < tosort + num - 1 &&
+             cmp(arr + (*(pi + 1)) * len, arr + (*pi) * len, py_arr) < 0;
+             ++pi) {
         }
 
         for (pj = pl, pr = pi; pj < pr; ++pj, --pr) {
-            INTP_SWAP(*pj, *pr);
+            std::swap(*pj, *pr);
         }
     }
 
@@ -2219,7 +2373,8 @@ npy_acount_run(char *arr, npy_intp *tosort, npy_intp l, npy_intp num,
     if (sz < minrun) {
         if (l + minrun < num) {
             sz = minrun;
-        } else {
+        }
+        else {
             sz = num - l;
         }
 
@@ -2230,7 +2385,8 @@ npy_acount_run(char *arr, npy_intp *tosort, npy_intp l, npy_intp num,
             vi = *pi;
             pj = pi;
 
-            while (pl < pj && cmp(arr + vi * len, arr + (*(pj - 1)) * len, py_arr) < 0) {
+            while (pl < pj &&
+                   cmp(arr + vi * len, arr + (*(pj - 1)) * len, py_arr) < 0) {
                 *pj = *(pj - 1);
                 --pj;
             }
@@ -2242,11 +2398,10 @@ npy_acount_run(char *arr, npy_intp *tosort, npy_intp l, npy_intp num,
     return sz;
 }
 
-
 static npy_intp
-npy_agallop_left(const char *arr, const npy_intp *tosort,
-                 const npy_intp size, const char *key, size_t len,
-                 PyArray_CompareFunc *cmp, PyArrayObject *py_arr)
+npy_agallop_left(const char *arr, const npy_intp *tosort, const npy_intp size,
+                 const char *key, size_t len, PyArray_CompareFunc *cmp,
+                 PyArrayObject *py_arr)
 {
     npy_intp last_ofs, ofs, l, m, r;
 
@@ -2265,13 +2420,15 @@ npy_agallop_left(const char *arr, const npy_intp *tosort,
 
         if (cmp(arr + tosort[size - ofs - 1] * len, key, py_arr) < 0) {
             break;
-        } else {
+        }
+        else {
             last_ofs = ofs;
             ofs = (ofs << 1) + 1;
         }
     }
 
-    /* now that arr[tosort[size-ofs-1]*len] < key <= arr[tosort[size-last_ofs-1]*len] */
+    /* now that arr[tosort[size-ofs-1]*len] < key <=
+     * arr[tosort[size-last_ofs-1]*len] */
     l = size - ofs - 1;
     r = size - last_ofs - 1;
 
@@ -2280,7 +2437,8 @@ npy_agallop_left(const char *arr, const npy_intp *tosort,
 
         if (cmp(arr + tosort[m] * len, key, py_arr) < 0) {
             l = m;
-        } else {
+        }
+        else {
             r = m;
         }
     }
@@ -2289,11 +2447,10 @@ npy_agallop_left(const char *arr, const npy_intp *tosort,
     return r;
 }
 
-
 static npy_intp
-npy_agallop_right(const char *arr, const npy_intp *tosort,
-                  const npy_intp size, const char *key, size_t len,
-                  PyArray_CompareFunc *cmp, PyArrayObject *py_arr)
+npy_agallop_right(const char *arr, const npy_intp *tosort, const npy_intp size,
+                  const char *key, size_t len, PyArray_CompareFunc *cmp,
+                  PyArrayObject *py_arr)
 {
     npy_intp last_ofs, ofs, m;
 
@@ -2312,7 +2469,8 @@ npy_agallop_right(const char *arr, const npy_intp *tosort,
 
         if (cmp(key, arr + tosort[ofs] * len, py_arr) < 0) {
             break;
-        } else {
+        }
+        else {
             last_ofs = ofs;
             /* ofs = 1, 3, 7, 15... */
             ofs = (ofs << 1) + 1;
@@ -2325,7 +2483,8 @@ npy_agallop_right(const char *arr, const npy_intp *tosort,
 
         if (cmp(key, arr + tosort[m] * len, py_arr) < 0) {
             ofs = m;
-        } else {
+        }
+        else {
             last_ofs = m;
         }
     }
@@ -2334,7 +2493,6 @@ npy_agallop_right(const char *arr, const npy_intp *tosort,
     return ofs;
 }
 
-
 static void
 npy_amerge_left(char *arr, npy_intp *p1, npy_intp l1, npy_intp *p2,
                 npy_intp l2, npy_intp *p3, size_t len,
@@ -2348,7 +2506,8 @@ npy_amerge_left(char *arr, npy_intp *p1, npy_intp l1, npy_intp *p2,
     while (p1 < p2 && p2 < end) {
         if (cmp(arr + (*p2) * len, arr + (*p3) * len, py_arr) < 0) {
             *p1++ = *p2++;
-        } else {
+        }
+        else {
             *p1++ = *p3++;
         }
     }
@@ -2358,9 +2517,8 @@ npy_amerge_left(char *arr, npy_intp *p1, npy_intp l1, npy_intp *p2,
     }
 }
 
-
 static void
-npy_amerge_right(char *arr, npy_intp* p1, npy_intp l1, npy_intp *p2,
+npy_amerge_right(char *arr, npy_intp *p1, npy_intp l1, npy_intp *p2,
                  npy_intp l2, npy_intp *p3, size_t len,
                  PyArray_CompareFunc *cmp, PyArrayObject *py_arr)
 {
@@ -2376,7 +2534,8 @@ npy_amerge_right(char *arr, npy_intp* p1, npy_intp l1, npy_intp *p2,
     while (p1 < p2 && start < p1) {
         if (cmp(arr + (*p3) * len, arr + (*p1) * len, py_arr) < 0) {
             *p2-- = *p1--;
-        } else {
+        }
+        else {
             *p2-- = *p3--;
         }
     }
@@ -2387,12 +2546,10 @@ npy_amerge_right(char *arr, npy_intp* p1, npy_intp l1, npy_intp *p2,
     }
 }
 
-
-
 static int
-npy_amerge_at(char *arr, npy_intp *tosort, const run *stack,
-              const npy_intp at, buffer_intp *buffer, size_t len,
-              PyArray_CompareFunc *cmp, PyArrayObject *py_arr)
+npy_amerge_at(char *arr, npy_intp *tosort, const run *stack, const npy_intp at,
+              buffer_intp *buffer, size_t len, PyArray_CompareFunc *cmp,
+              PyArrayObject *py_arr)
 {
     int ret;
     npy_intp s1, l1, s2, l2, k;
@@ -2402,8 +2559,8 @@ npy_amerge_at(char *arr, npy_intp *tosort, const run *stack,
     s2 = stack[at + 1].s;
     l2 = stack[at + 1].l;
     /* tosort[s2] belongs to tosort[s1+k] */
-    k = npy_agallop_right(arr, tosort + s1, l1, arr + tosort[s2] * len, len, cmp,
-                          py_arr);
+    k = npy_agallop_right(arr, tosort + s1, l1, arr + tosort[s2] * len, len,
+                          cmp, py_arr);
 
     if (l1 == k) {
         /* already sorted */
@@ -2420,13 +2577,18 @@ npy_amerge_at(char *arr, npy_intp *tosort, const run *stack,
     if (l2 < l1) {
         ret = resize_buffer_intp(buffer, l2);
 
-        if (NPY_UNLIKELY(ret < 0)) { return ret; }
+        if (NPY_UNLIKELY(ret < 0)) {
+            return ret;
+        }
 
         npy_amerge_right(arr, p1, l1, p2, l2, buffer->pw, len, cmp, py_arr);
-    } else {
+    }
+    else {
         ret = resize_buffer_intp(buffer, l1);
 
-        if (NPY_UNLIKELY(ret < 0)) { return ret; }
+        if (NPY_UNLIKELY(ret < 0)) {
+            return ret;
+        }
 
         npy_amerge_left(arr, p1, l1, p2, l2, buffer->pw, len, cmp, py_arr);
     }
@@ -2434,11 +2596,10 @@ npy_amerge_at(char *arr, npy_intp *tosort, const run *stack,
     return 0;
 }
 
-
 static int
-npy_atry_collapse(char *arr, npy_intp *tosort, run *stack,
-                  npy_intp *stack_ptr, buffer_intp *buffer, size_t len,
-                  PyArray_CompareFunc *cmp, PyArrayObject *py_arr)
+npy_atry_collapse(char *arr, npy_intp *tosort, run *stack, npy_intp *stack_ptr,
+                  buffer_intp *buffer, size_t len, PyArray_CompareFunc *cmp,
+                  PyArrayObject *py_arr)
 {
     int ret;
     npy_intp A, B, C, top;
@@ -2449,33 +2610,45 @@ npy_atry_collapse(char *arr, npy_intp *tosort, run *stack,
         C = stack[top - 1].l;
 
         if ((2 < top && stack[top - 3].l <= B + C) ||
-                (3 < top && stack[top - 4].l <= stack[top - 3].l + B)) {
+            (3 < top && stack[top - 4].l <= stack[top - 3].l + B)) {
             A = stack[top - 3].l;
 
             if (A <= C) {
-                ret = npy_amerge_at(arr, tosort, stack, top - 3, buffer, len, cmp, py_arr);
+                ret = npy_amerge_at(arr, tosort, stack, top - 3, buffer, len,
+                                    cmp, py_arr);
 
-                if (NPY_UNLIKELY(ret < 0)) { return ret; }
+                if (NPY_UNLIKELY(ret < 0)) {
+                    return ret;
+                }
 
                 stack[top - 3].l += B;
                 stack[top - 2] = stack[top - 1];
                 --top;
-            } else {
-                ret = npy_amerge_at(arr, tosort, stack, top - 2, buffer, len, cmp, py_arr);
+            }
+            else {
+                ret = npy_amerge_at(arr, tosort, stack, top - 2, buffer, len,
+                                    cmp, py_arr);
 
-                if (NPY_UNLIKELY(ret < 0)) { return ret; }
+                if (NPY_UNLIKELY(ret < 0)) {
+                    return ret;
+                }
 
                 stack[top - 2].l += C;
                 --top;
             }
-        } else if (1 < top && B <= C) {
-            ret = npy_amerge_at(arr, tosort, stack, top - 2, buffer, len, cmp, py_arr);
+        }
+        else if (1 < top && B <= C) {
+            ret = npy_amerge_at(arr, tosort, stack, top - 2, buffer, len, cmp,
+                                py_arr);
 
-            if (NPY_UNLIKELY(ret < 0)) { return ret; }
+            if (NPY_UNLIKELY(ret < 0)) {
+                return ret;
+            }
 
             stack[top - 2].l += C;
             --top;
-        } else {
+        }
+        else {
             break;
         }
     }
@@ -2484,7 +2657,6 @@ npy_atry_collapse(char *arr, npy_intp *tosort, run *stack,
     return 0;
 }
 
-
 static int
 npy_aforce_collapse(char *arr, npy_intp *tosort, run *stack,
                     npy_intp *stack_ptr, buffer_intp *buffer, size_t len,
@@ -2495,17 +2667,24 @@ npy_aforce_collapse(char *arr, npy_intp *tosort, run *stack,
 
     while (2 < top) {
         if (stack[top - 3].l <= stack[top - 1].l) {
-            ret = npy_amerge_at(arr, tosort, stack, top - 3, buffer, len, cmp, py_arr);
+            ret = npy_amerge_at(arr, tosort, stack, top - 3, buffer, len, cmp,
+                                py_arr);
 
-            if (NPY_UNLIKELY(ret < 0)) { return ret; }
+            if (NPY_UNLIKELY(ret < 0)) {
+                return ret;
+            }
 
             stack[top - 3].l += stack[top - 2].l;
             stack[top - 2] = stack[top - 1];
             --top;
-        } else {
-            ret = npy_amerge_at(arr, tosort, stack, top - 2, buffer, len, cmp, py_arr);
+        }
+        else {
+            ret = npy_amerge_at(arr, tosort, stack, top - 2, buffer, len, cmp,
+                                py_arr);
 
-            if (NPY_UNLIKELY(ret < 0)) { return ret; }
+            if (NPY_UNLIKELY(ret < 0)) {
+                return ret;
+            }
 
             stack[top - 2].l += stack[top - 1].l;
             --top;
@@ -2513,19 +2692,21 @@ npy_aforce_collapse(char *arr, npy_intp *tosort, run *stack,
     }
 
     if (1 < top) {
-        ret = npy_amerge_at(arr, tosort, stack, top - 2, buffer, len, cmp, py_arr);
+        ret = npy_amerge_at(arr, tosort, stack, top - 2, buffer, len, cmp,
+                            py_arr);
 
-        if (NPY_UNLIKELY(ret < 0)) { return ret; }
+        if (NPY_UNLIKELY(ret < 0)) {
+            return ret;
+        }
     }
 
     return 0;
 }
 
-
 NPY_NO_EXPORT int
 npy_atimsort(void *start, npy_intp *tosort, npy_intp num, void *varr)
 {
-    PyArrayObject *arr = varr;
+    PyArrayObject *arr = reinterpret_cast(varr);
     size_t len = PyArray_ITEMSIZE(arr);
     PyArray_CompareFunc *cmp = PyArray_DESCR(arr)->f->compare;
     int ret;
@@ -2544,23 +2725,28 @@ npy_atimsort(void *start, npy_intp *tosort, npy_intp num, void *varr)
     minrun = compute_min_run_short(num);
 
     for (l = 0; l < num;) {
-        n = npy_acount_run(start, tosort, l, num, minrun, len, cmp, arr);
+        n = npy_acount_run((char *)start, tosort, l, num, minrun, len, cmp,
+                           arr);
         /* both s and l are scaled by len */
         stack[stack_ptr].s = l;
         stack[stack_ptr].l = n;
         ++stack_ptr;
-        ret = npy_atry_collapse(start, tosort, stack, &stack_ptr, &buffer, len, cmp,
-                                arr);
+        ret = npy_atry_collapse((char *)start, tosort, stack, &stack_ptr,
+                                &buffer, len, cmp, arr);
 
-        if (NPY_UNLIKELY(ret < 0)) { goto cleanup; }
+        if (NPY_UNLIKELY(ret < 0)) {
+            goto cleanup;
+        }
 
         l += n;
     }
 
-    ret = npy_aforce_collapse(start, tosort, stack, &stack_ptr, &buffer, len,
-                              cmp, arr);
+    ret = npy_aforce_collapse((char *)start, tosort, stack, &stack_ptr,
+                              &buffer, len, cmp, arr);
 
-    if (NPY_UNLIKELY(ret < 0)) { goto cleanup; }
+    if (NPY_UNLIKELY(ret < 0)) {
+        goto cleanup;
+    }
 
     ret = 0;
 
@@ -2570,3 +2756,239 @@ npy_atimsort(void *start, npy_intp *tosort, npy_intp num, void *varr)
     }
     return ret;
 }
+
+/***************************************
+ * C > C++ dispatch
+ ***************************************/
+
+NPY_NO_EXPORT int
+timsort_bool(void *start, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return timsort_(start, num);
+}
+NPY_NO_EXPORT int
+timsort_byte(void *start, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return timsort_(start, num);
+}
+NPY_NO_EXPORT int
+timsort_ubyte(void *start, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return timsort_(start, num);
+}
+NPY_NO_EXPORT int
+timsort_short(void *start, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return timsort_(start, num);
+}
+NPY_NO_EXPORT int
+timsort_ushort(void *start, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return timsort_(start, num);
+}
+NPY_NO_EXPORT int
+timsort_int(void *start, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return timsort_(start, num);
+}
+NPY_NO_EXPORT int
+timsort_uint(void *start, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return timsort_(start, num);
+}
+NPY_NO_EXPORT int
+timsort_long(void *start, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return timsort_(start, num);
+}
+NPY_NO_EXPORT int
+timsort_ulong(void *start, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return timsort_(start, num);
+}
+NPY_NO_EXPORT int
+timsort_longlong(void *start, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return timsort_(start, num);
+}
+NPY_NO_EXPORT int
+timsort_ulonglong(void *start, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return timsort_(start, num);
+}
+NPY_NO_EXPORT int
+timsort_half(void *start, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return timsort_(start, num);
+}
+NPY_NO_EXPORT int
+timsort_float(void *start, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return timsort_(start, num);
+}
+NPY_NO_EXPORT int
+timsort_double(void *start, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return timsort_(start, num);
+}
+NPY_NO_EXPORT int
+timsort_longdouble(void *start, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return timsort_(start, num);
+}
+NPY_NO_EXPORT int
+timsort_cfloat(void *start, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return timsort_(start, num);
+}
+NPY_NO_EXPORT int
+timsort_cdouble(void *start, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return timsort_(start, num);
+}
+NPY_NO_EXPORT int
+timsort_clongdouble(void *start, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return timsort_(start, num);
+}
+NPY_NO_EXPORT int
+timsort_datetime(void *start, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return timsort_(start, num);
+}
+NPY_NO_EXPORT int
+timsort_timedelta(void *start, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return timsort_(start, num);
+}
+NPY_NO_EXPORT int
+timsort_string(void *start, npy_intp num, void *varr)
+{
+    return string_timsort_(start, num, varr);
+}
+NPY_NO_EXPORT int
+timsort_unicode(void *start, npy_intp num, void *varr)
+{
+    return string_timsort_(start, num, varr);
+}
+
+NPY_NO_EXPORT int
+atimsort_bool(void *v, npy_intp *tosort, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return atimsort_(v, tosort, num);
+}
+NPY_NO_EXPORT int
+atimsort_byte(void *v, npy_intp *tosort, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return atimsort_(v, tosort, num);
+}
+NPY_NO_EXPORT int
+atimsort_ubyte(void *v, npy_intp *tosort, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return atimsort_(v, tosort, num);
+}
+NPY_NO_EXPORT int
+atimsort_short(void *v, npy_intp *tosort, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return atimsort_(v, tosort, num);
+}
+NPY_NO_EXPORT int
+atimsort_ushort(void *v, npy_intp *tosort, npy_intp num,
+                void *NPY_UNUSED(varr))
+{
+    return atimsort_(v, tosort, num);
+}
+NPY_NO_EXPORT int
+atimsort_int(void *v, npy_intp *tosort, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return atimsort_(v, tosort, num);
+}
+NPY_NO_EXPORT int
+atimsort_uint(void *v, npy_intp *tosort, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return atimsort_(v, tosort, num);
+}
+NPY_NO_EXPORT int
+atimsort_long(void *v, npy_intp *tosort, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return atimsort_(v, tosort, num);
+}
+NPY_NO_EXPORT int
+atimsort_ulong(void *v, npy_intp *tosort, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return atimsort_(v, tosort, num);
+}
+NPY_NO_EXPORT int
+atimsort_longlong(void *v, npy_intp *tosort, npy_intp num,
+                  void *NPY_UNUSED(varr))
+{
+    return atimsort_(v, tosort, num);
+}
+NPY_NO_EXPORT int
+atimsort_ulonglong(void *v, npy_intp *tosort, npy_intp num,
+                   void *NPY_UNUSED(varr))
+{
+    return atimsort_(v, tosort, num);
+}
+NPY_NO_EXPORT int
+atimsort_half(void *v, npy_intp *tosort, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return atimsort_(v, tosort, num);
+}
+NPY_NO_EXPORT int
+atimsort_float(void *v, npy_intp *tosort, npy_intp num, void *NPY_UNUSED(varr))
+{
+    return atimsort_(v, tosort, num);
+}
+NPY_NO_EXPORT int
+atimsort_double(void *v, npy_intp *tosort, npy_intp num,
+                void *NPY_UNUSED(varr))
+{
+    return atimsort_(v, tosort, num);
+}
+NPY_NO_EXPORT int
+atimsort_longdouble(void *v, npy_intp *tosort, npy_intp num,
+                    void *NPY_UNUSED(varr))
+{
+    return atimsort_(v, tosort, num);
+}
+NPY_NO_EXPORT int
+atimsort_cfloat(void *v, npy_intp *tosort, npy_intp num,
+                void *NPY_UNUSED(varr))
+{
+    return atimsort_(v, tosort, num);
+}
+NPY_NO_EXPORT int
+atimsort_cdouble(void *v, npy_intp *tosort, npy_intp num,
+                 void *NPY_UNUSED(varr))
+{
+    return atimsort_(v, tosort, num);
+}
+NPY_NO_EXPORT int
+atimsort_clongdouble(void *v, npy_intp *tosort, npy_intp num,
+                     void *NPY_UNUSED(varr))
+{
+    return atimsort_(v, tosort, num);
+}
+NPY_NO_EXPORT int
+atimsort_datetime(void *v, npy_intp *tosort, npy_intp num,
+                  void *NPY_UNUSED(varr))
+{
+    return atimsort_(v, tosort, num);
+}
+NPY_NO_EXPORT int
+atimsort_timedelta(void *v, npy_intp *tosort, npy_intp num,
+                   void *NPY_UNUSED(varr))
+{
+    return atimsort_(v, tosort, num);
+}
+NPY_NO_EXPORT int
+atimsort_string(void *v, npy_intp *tosort, npy_intp num, void *varr)
+{
+    return string_atimsort_(v, tosort, num, varr);
+}
+NPY_NO_EXPORT int
+atimsort_unicode(void *v, npy_intp *tosort, npy_intp num, void *varr)
+{
+    return string_atimsort_(v, tosort, num, varr);
+}
diff --git a/numpy/core/src/npysort/x86-qsort.dispatch.cpp b/numpy/core/src/npysort/x86-qsort.dispatch.cpp
new file mode 100644
index 000000000000..8e88cc667094
--- /dev/null
+++ b/numpy/core/src/npysort/x86-qsort.dispatch.cpp
@@ -0,0 +1,835 @@
+/*@targets
+ * $maxopt $keep_baseline avx512_skx
+ */
+// policy $keep_baseline is used to avoid skip building avx512_skx
+// when its part of baseline features (--cpu-baseline), since
+// 'baseline' option isn't specified within targets.
+
+#include "x86-qsort.h"
+#define NPY_NO_DEPRECATED_API NPY_API_VERSION
+
+#ifdef NPY_HAVE_AVX512_SKX
+#include "numpy/npy_math.h"
+
+#include "npy_sort.h"
+#include "numpy_tag.h"
+
+#include "simd/simd.h"
+#include 
+
+template 
+NPY_NO_EXPORT int
+heapsort_(type *start, npy_intp n);
+
+/*
+ * Quicksort using AVX-512 for int, uint32 and float. The ideas and code are
+ * based on these two research papers:
+ * (1) Fast and Robust Vectorized In-Place Sorting of Primitive Types
+ *     https://drops.dagstuhl.de/opus/volltexte/2021/13775/
+ * (2) A Novel Hybrid Quicksort Algorithm Vectorized using AVX-512 on Intel
+ * Skylake https://arxiv.org/pdf/1704.08579.pdf
+ *
+ * High level idea: Vectorize the quicksort partitioning using AVX-512
+ * compressstore instructions. The algorithm to pick the pivot is to use median
+ * of 72 elements picked at random. If the array size is < 128, then use
+ * Bitonic sorting network. Good resource for bitonic sorting network:
+ * http://mitp-content-server.mit.edu:18180/books/content/sectbyfn?collid=books_pres_0&fn=Chapter%2027.pdf&id=8030
+ *
+ * Refer to https://github.com/numpy/numpy/pull/20133#issuecomment-958110340
+ * for potential problems when converting this code to universal intrinsics
+ * framework.
+ */
+
+/*
+ * Constants used in sorting 16 elements in a ZMM registers. Based on Bitonic
+ * sorting network (see
+ * https://en.wikipedia.org/wiki/Bitonic_sorter#/media/File:BitonicSort.svg)
+ */
+#define NETWORK1 14, 15, 12, 13, 10, 11, 8, 9, 6, 7, 4, 5, 2, 3, 0, 1
+#define NETWORK2 12, 13, 14, 15, 8, 9, 10, 11, 4, 5, 6, 7, 0, 1, 2, 3
+#define NETWORK3 8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 3, 4, 5, 6, 7
+#define NETWORK4 13, 12, 15, 14, 9, 8, 11, 10, 5, 4, 7, 6, 1, 0, 3, 2
+#define NETWORK5 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
+#define NETWORK6 11, 10, 9, 8, 15, 14, 13, 12, 3, 2, 1, 0, 7, 6, 5, 4
+#define NETWORK7 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8
+#define ZMM_MAX_FLOAT _mm512_set1_ps(NPY_INFINITYF)
+#define ZMM_MAX_UINT _mm512_set1_epi32(NPY_MAX_UINT32)
+#define ZMM_MAX_INT _mm512_set1_epi32(NPY_MAX_INT32)
+#define SHUFFLE_MASK(a, b, c, d) (a << 6) | (b << 4) | (c << 2) | d
+#define SHUFFLE_ps(ZMM, MASK) _mm512_shuffle_ps(zmm, zmm, MASK)
+#define SHUFFLE_epi32(ZMM, MASK) _mm512_shuffle_epi32(zmm, MASK)
+
+#define MAX(x, y) (((x) > (y)) ? (x) : (y))
+#define MIN(x, y) (((x) < (y)) ? (x) : (y))
+
+/*
+ * Vectorized random number generator xoroshiro128+. Broken into 2 parts:
+ * (1) vnext generates 2 64-bit random integers
+ * (2) rnd_epu32 converts this to 4 32-bit random integers and bounds it to
+ *     the length of the array
+ */
+#define VROTL(x, k) /* rotate each uint64_t value in vector */ \
+    _mm256_or_si256(_mm256_slli_epi64((x), (k)),               \
+                    _mm256_srli_epi64((x), 64 - (k)))
+
+static inline __m256i
+vnext(__m256i *s0, __m256i *s1)
+{
+    *s1 = _mm256_xor_si256(*s0, *s1); /* modify vectors s1 and s0 */
+    *s0 = _mm256_xor_si256(_mm256_xor_si256(VROTL(*s0, 24), *s1),
+                           _mm256_slli_epi64(*s1, 16));
+    *s1 = VROTL(*s1, 37);
+    return _mm256_add_epi64(*s0, *s1); /* return random vector */
+}
+
+/* transform random numbers to the range between 0 and bound - 1 */
+static inline __m256i
+rnd_epu32(__m256i rnd_vec, __m256i bound)
+{
+    __m256i even = _mm256_srli_epi64(_mm256_mul_epu32(rnd_vec, bound), 32);
+    __m256i odd = _mm256_mul_epu32(_mm256_srli_epi64(rnd_vec, 32), bound);
+    return _mm256_blend_epi32(odd, even, 0b01010101);
+}
+
+template 
+struct vector;
+
+template <>
+struct vector {
+    using tag = npy::int_tag;
+    using type_t = npy_int;
+    using zmm_t = __m512i;
+    using ymm_t = __m256i;
+
+    static type_t type_max() { return NPY_MAX_INT32; }
+    static type_t type_min() { return NPY_MIN_INT32; }
+    static zmm_t zmm_max() { return _mm512_set1_epi32(type_max()); }
+
+    static __mmask16 ge(zmm_t x, zmm_t y)
+    {
+        return _mm512_cmp_epi32_mask(x, y, _MM_CMPINT_NLT);
+    }
+    template 
+    static ymm_t i64gather(__m512i index, void const *base)
+    {
+        return _mm512_i64gather_epi32(index, base, scale);
+    }
+    static zmm_t loadu(void const *mem) { return _mm512_loadu_si512(mem); }
+    static zmm_t max(zmm_t x, zmm_t y) { return _mm512_max_epi32(x, y); }
+    static void mask_compressstoreu(void *mem, __mmask16 mask, zmm_t x)
+    {
+        return _mm512_mask_compressstoreu_epi32(mem, mask, x);
+    }
+    static zmm_t mask_loadu(zmm_t x, __mmask16 mask, void const *mem)
+    {
+        return _mm512_mask_loadu_epi32(x, mask, mem);
+    }
+    static zmm_t mask_mov(zmm_t x, __mmask16 mask, zmm_t y)
+    {
+        return _mm512_mask_mov_epi32(x, mask, y);
+    }
+    static void mask_storeu(void *mem, __mmask16 mask, zmm_t x)
+    {
+        return _mm512_mask_storeu_epi32(mem, mask, x);
+    }
+    static zmm_t min(zmm_t x, zmm_t y) { return _mm512_min_epi32(x, y); }
+    static zmm_t permutexvar(__m512i idx, zmm_t zmm)
+    {
+        return _mm512_permutexvar_epi32(idx, zmm);
+    }
+    static type_t reducemax(zmm_t v) { return npyv_reduce_max_s32(v); }
+    static type_t reducemin(zmm_t v) { return npyv_reduce_min_s32(v); }
+    static zmm_t set1(type_t v) { return _mm512_set1_epi32(v); }
+    template<__mmask16 mask>
+    static zmm_t shuffle(zmm_t zmm)
+    {
+        return _mm512_shuffle_epi32(zmm, (_MM_PERM_ENUM)mask);
+    }
+    static void storeu(void *mem, zmm_t x)
+    {
+        return _mm512_storeu_si512(mem, x);
+    }
+
+    static ymm_t max(ymm_t x, ymm_t y) { return _mm256_max_epi32(x, y); }
+    static ymm_t min(ymm_t x, ymm_t y) { return _mm256_min_epi32(x, y); }
+};
+template <>
+struct vector {
+    using tag = npy::uint_tag;
+    using type_t = npy_uint;
+    using zmm_t = __m512i;
+    using ymm_t = __m256i;
+
+    static type_t type_max() { return NPY_MAX_UINT32; }
+    static type_t type_min() { return 0; }
+    static zmm_t zmm_max() { return _mm512_set1_epi32(type_max()); }
+
+    template
+    static ymm_t i64gather(__m512i index, void const *base)
+    {
+        return _mm512_i64gather_epi32(index, base, scale);
+    }
+    static __mmask16 ge(zmm_t x, zmm_t y)
+    {
+        return _mm512_cmp_epu32_mask(x, y, _MM_CMPINT_NLT);
+    }
+    static zmm_t loadu(void const *mem) { return _mm512_loadu_si512(mem); }
+    static zmm_t max(zmm_t x, zmm_t y) { return _mm512_max_epu32(x, y); }
+    static void mask_compressstoreu(void *mem, __mmask16 mask, zmm_t x)
+    {
+        return _mm512_mask_compressstoreu_epi32(mem, mask, x);
+    }
+    static zmm_t mask_loadu(zmm_t x, __mmask16 mask, void const *mem)
+    {
+        return _mm512_mask_loadu_epi32(x, mask, mem);
+    }
+    static zmm_t mask_mov(zmm_t x, __mmask16 mask, zmm_t y)
+    {
+        return _mm512_mask_mov_epi32(x, mask, y);
+    }
+    static void mask_storeu(void *mem, __mmask16 mask, zmm_t x)
+    {
+        return _mm512_mask_storeu_epi32(mem, mask, x);
+    }
+    static zmm_t min(zmm_t x, zmm_t y) { return _mm512_min_epu32(x, y); }
+    static zmm_t permutexvar(__m512i idx, zmm_t zmm)
+    {
+        return _mm512_permutexvar_epi32(idx, zmm);
+    }
+    static type_t reducemax(zmm_t v) { return npyv_reduce_max_u32(v); }
+    static type_t reducemin(zmm_t v) { return npyv_reduce_min_u32(v); }
+    static zmm_t set1(type_t v) { return _mm512_set1_epi32(v); }
+    template<__mmask16 mask>
+    static zmm_t shuffle(zmm_t zmm)
+    {
+        return _mm512_shuffle_epi32(zmm, (_MM_PERM_ENUM)mask);
+    }
+    static void storeu(void *mem, zmm_t x)
+    {
+        return _mm512_storeu_si512(mem, x);
+    }
+
+    static ymm_t max(ymm_t x, ymm_t y) { return _mm256_max_epu32(x, y); }
+    static ymm_t min(ymm_t x, ymm_t y) { return _mm256_min_epu32(x, y); }
+};
+template <>
+struct vector {
+    using tag = npy::float_tag;
+    using type_t = npy_float;
+    using zmm_t = __m512;
+    using ymm_t = __m256;
+
+    static type_t type_max() { return NPY_INFINITYF; }
+    static type_t type_min() { return -NPY_INFINITYF; }
+    static zmm_t zmm_max() { return _mm512_set1_ps(type_max()); }
+
+    static __mmask16 ge(zmm_t x, zmm_t y)
+    {
+        return _mm512_cmp_ps_mask(x, y, _CMP_GE_OQ);
+    }
+    template
+    static ymm_t i64gather(__m512i index, void const *base)
+    {
+        return _mm512_i64gather_ps(index, base, scale);
+    }
+    static zmm_t loadu(void const *mem) { return _mm512_loadu_ps(mem); }
+    static zmm_t max(zmm_t x, zmm_t y) { return _mm512_max_ps(x, y); }
+    static void mask_compressstoreu(void *mem, __mmask16 mask, zmm_t x)
+    {
+        return _mm512_mask_compressstoreu_ps(mem, mask, x);
+    }
+    static zmm_t mask_loadu(zmm_t x, __mmask16 mask, void const *mem)
+    {
+        return _mm512_mask_loadu_ps(x, mask, mem);
+    }
+    static zmm_t mask_mov(zmm_t x, __mmask16 mask, zmm_t y)
+    {
+        return _mm512_mask_mov_ps(x, mask, y);
+    }
+    static void mask_storeu(void *mem, __mmask16 mask, zmm_t x)
+    {
+        return _mm512_mask_storeu_ps(mem, mask, x);
+    }
+    static zmm_t min(zmm_t x, zmm_t y) { return _mm512_min_ps(x, y); }
+    static zmm_t permutexvar(__m512i idx, zmm_t zmm)
+    {
+        return _mm512_permutexvar_ps(idx, zmm);
+    }
+    static type_t reducemax(zmm_t v) { return npyv_reduce_max_f32(v); }
+    static type_t reducemin(zmm_t v) { return npyv_reduce_min_f32(v); }
+    static zmm_t set1(type_t v) { return _mm512_set1_ps(v); }
+    template<__mmask16 mask>
+    static zmm_t shuffle(zmm_t zmm)
+    {
+        return _mm512_shuffle_ps(zmm, zmm, (_MM_PERM_ENUM)mask);
+    }
+    static void storeu(void *mem, zmm_t x) { return _mm512_storeu_ps(mem, x); }
+
+    static ymm_t max(ymm_t x, ymm_t y) { return _mm256_max_ps(x, y); }
+    static ymm_t min(ymm_t x, ymm_t y) { return _mm256_min_ps(x, y); }
+};
+
+/*
+ * COEX == Compare and Exchange two registers by swapping min and max values
+ */
+template 
+void
+COEX(mm_t &a, mm_t &b)
+{
+    mm_t temp = a;
+    a = vtype::min(a, b);
+    b = vtype::max(temp, b);
+}
+
+template 
+static inline zmm_t
+cmp_merge(zmm_t in1, zmm_t in2, __mmask16 mask)
+{
+    zmm_t min = vtype::min(in2, in1);
+    zmm_t max = vtype::max(in2, in1);
+    return vtype::mask_mov(min, mask, max);  // 0 -> min, 1 -> max
+}
+
+/*
+ * Assumes zmm is random and performs a full sorting network defined in
+ * https://en.wikipedia.org/wiki/Bitonic_sorter#/media/File:BitonicSort.svg
+ */
+template 
+static inline zmm_t
+sort_zmm(zmm_t zmm)
+{
+    zmm = cmp_merge(zmm, vtype::template shuffle(zmm),
+                           0xAAAA);
+    zmm = cmp_merge(zmm, vtype::template shuffle(zmm),
+                           0xCCCC);
+    zmm = cmp_merge(zmm, vtype::template shuffle(zmm),
+                           0xAAAA);
+    zmm = cmp_merge(
+            zmm, vtype::permutexvar(_mm512_set_epi32(NETWORK3), zmm), 0xF0F0);
+    zmm = cmp_merge(zmm, vtype::template shuffle(zmm),
+                           0xCCCC);
+    zmm = cmp_merge(zmm, vtype::template shuffle(zmm),
+                           0xAAAA);
+    zmm = cmp_merge(
+            zmm, vtype::permutexvar(_mm512_set_epi32(NETWORK5), zmm), 0xFF00);
+    zmm = cmp_merge(
+            zmm, vtype::permutexvar(_mm512_set_epi32(NETWORK6), zmm), 0xF0F0);
+    zmm = cmp_merge(zmm, vtype::template shuffle(zmm),
+                           0xCCCC);
+    zmm = cmp_merge(zmm, vtype::template shuffle(zmm),
+                           0xAAAA);
+    return zmm;
+}
+
+// Assumes zmm is bitonic and performs a recursive half cleaner
+template 
+static inline zmm_t
+bitonic_merge_zmm(zmm_t zmm)
+{
+    // 1) half_cleaner[16]: compare 1-9, 2-10, 3-11 etc ..
+    zmm = cmp_merge(
+            zmm, vtype::permutexvar(_mm512_set_epi32(NETWORK7), zmm), 0xFF00);
+    // 2) half_cleaner[8]: compare 1-5, 2-6, 3-7 etc ..
+    zmm = cmp_merge(
+            zmm, vtype::permutexvar(_mm512_set_epi32(NETWORK6), zmm), 0xF0F0);
+    // 3) half_cleaner[4]
+    zmm = cmp_merge(zmm, vtype::template shuffle(zmm),
+                           0xCCCC);
+    // 3) half_cleaner[1]
+    zmm = cmp_merge(zmm, vtype::template shuffle(zmm),
+                           0xAAAA);
+    return zmm;
+}
+
+// Assumes zmm1 and zmm2 are sorted and performs a recursive half cleaner
+template 
+static inline void
+bitonic_merge_two_zmm(zmm_t *zmm1, zmm_t *zmm2)
+{
+    // 1) First step of a merging network: coex of zmm1 and zmm2 reversed
+    *zmm2 = vtype::permutexvar(_mm512_set_epi32(NETWORK5), *zmm2);
+    zmm_t zmm3 = vtype::min(*zmm1, *zmm2);
+    zmm_t zmm4 = vtype::max(*zmm1, *zmm2);
+    // 2) Recursive half cleaner for each
+    *zmm1 = bitonic_merge_zmm(zmm3);
+    *zmm2 = bitonic_merge_zmm(zmm4);
+}
+
+// Assumes [zmm0, zmm1] and [zmm2, zmm3] are sorted and performs a recursive
+// half cleaner
+template 
+static inline void
+bitonic_merge_four_zmm(zmm_t *zmm)
+{
+    zmm_t zmm2r = vtype::permutexvar(_mm512_set_epi32(NETWORK5), zmm[2]);
+    zmm_t zmm3r = vtype::permutexvar(_mm512_set_epi32(NETWORK5), zmm[3]);
+    zmm_t zmm_t1 = vtype::min(zmm[0], zmm3r);
+    zmm_t zmm_t2 = vtype::min(zmm[1], zmm2r);
+    zmm_t zmm_t3 = vtype::permutexvar(_mm512_set_epi32(NETWORK5),
+                                      vtype::max(zmm[1], zmm2r));
+    zmm_t zmm_t4 = vtype::permutexvar(_mm512_set_epi32(NETWORK5),
+                                      vtype::max(zmm[0], zmm3r));
+    zmm_t zmm0 = vtype::min(zmm_t1, zmm_t2);
+    zmm_t zmm1 = vtype::max(zmm_t1, zmm_t2);
+    zmm_t zmm2 = vtype::min(zmm_t3, zmm_t4);
+    zmm_t zmm3 = vtype::max(zmm_t3, zmm_t4);
+    zmm[0] = bitonic_merge_zmm(zmm0);
+    zmm[1] = bitonic_merge_zmm(zmm1);
+    zmm[2] = bitonic_merge_zmm(zmm2);
+    zmm[3] = bitonic_merge_zmm(zmm3);
+}
+
+template 
+static inline void
+bitonic_merge_eight_zmm(zmm_t *zmm)
+{
+    zmm_t zmm4r = vtype::permutexvar(_mm512_set_epi32(NETWORK5), zmm[4]);
+    zmm_t zmm5r = vtype::permutexvar(_mm512_set_epi32(NETWORK5), zmm[5]);
+    zmm_t zmm6r = vtype::permutexvar(_mm512_set_epi32(NETWORK5), zmm[6]);
+    zmm_t zmm7r = vtype::permutexvar(_mm512_set_epi32(NETWORK5), zmm[7]);
+    zmm_t zmm_t1 = vtype::min(zmm[0], zmm7r);
+    zmm_t zmm_t2 = vtype::min(zmm[1], zmm6r);
+    zmm_t zmm_t3 = vtype::min(zmm[2], zmm5r);
+    zmm_t zmm_t4 = vtype::min(zmm[3], zmm4r);
+    zmm_t zmm_t5 = vtype::permutexvar(_mm512_set_epi32(NETWORK5),
+                                      vtype::max(zmm[3], zmm4r));
+    zmm_t zmm_t6 = vtype::permutexvar(_mm512_set_epi32(NETWORK5),
+                                      vtype::max(zmm[2], zmm5r));
+    zmm_t zmm_t7 = vtype::permutexvar(_mm512_set_epi32(NETWORK5),
+                                      vtype::max(zmm[1], zmm6r));
+    zmm_t zmm_t8 = vtype::permutexvar(_mm512_set_epi32(NETWORK5),
+                                      vtype::max(zmm[0], zmm7r));
+    COEX(zmm_t1, zmm_t3);
+    COEX(zmm_t2, zmm_t4);
+    COEX(zmm_t5, zmm_t7);
+    COEX(zmm_t6, zmm_t8);
+    COEX(zmm_t1, zmm_t2);
+    COEX(zmm_t3, zmm_t4);
+    COEX(zmm_t5, zmm_t6);
+    COEX(zmm_t7, zmm_t8);
+    zmm[0] = bitonic_merge_zmm(zmm_t1);
+    zmm[1] = bitonic_merge_zmm(zmm_t2);
+    zmm[2] = bitonic_merge_zmm(zmm_t3);
+    zmm[3] = bitonic_merge_zmm(zmm_t4);
+    zmm[4] = bitonic_merge_zmm(zmm_t5);
+    zmm[5] = bitonic_merge_zmm(zmm_t6);
+    zmm[6] = bitonic_merge_zmm(zmm_t7);
+    zmm[7] = bitonic_merge_zmm(zmm_t8);
+}
+
+template 
+static inline void
+sort_16(type_t *arr, npy_int N)
+{
+    __mmask16 load_mask = (0x0001 << N) - 0x0001;
+    typename vtype::zmm_t zmm =
+            vtype::mask_loadu(vtype::zmm_max(), load_mask, arr);
+    vtype::mask_storeu(arr, load_mask, sort_zmm(zmm));
+}
+
+template 
+static inline void
+sort_32(type_t *arr, npy_int N)
+{
+    if (N <= 16) {
+        sort_16(arr, N);
+        return;
+    }
+    using zmm_t = typename vtype::zmm_t;
+    zmm_t zmm1 = vtype::loadu(arr);
+    __mmask16 load_mask = (0x0001 << (N - 16)) - 0x0001;
+    zmm_t zmm2 = vtype::mask_loadu(vtype::zmm_max(), load_mask, arr + 16);
+    zmm1 = sort_zmm(zmm1);
+    zmm2 = sort_zmm(zmm2);
+    bitonic_merge_two_zmm(&zmm1, &zmm2);
+    vtype::storeu(arr, zmm1);
+    vtype::mask_storeu(arr + 16, load_mask, zmm2);
+}
+
+template 
+static inline void
+sort_64(type_t *arr, npy_int N)
+{
+    if (N <= 32) {
+        sort_32(arr, N);
+        return;
+    }
+    using zmm_t = typename vtype::zmm_t;
+    zmm_t zmm[4];
+    zmm[0] = vtype::loadu(arr);
+    zmm[1] = vtype::loadu(arr + 16);
+    __mmask16 load_mask1 = 0xFFFF, load_mask2 = 0xFFFF;
+    if (N < 48) {
+        load_mask1 = (0x0001 << (N - 32)) - 0x0001;
+        load_mask2 = 0x0000;
+    }
+    else if (N < 64) {
+        load_mask2 = (0x0001 << (N - 48)) - 0x0001;
+    }
+    zmm[2] = vtype::mask_loadu(vtype::zmm_max(), load_mask1, arr + 32);
+    zmm[3] = vtype::mask_loadu(vtype::zmm_max(), load_mask2, arr + 48);
+    zmm[0] = sort_zmm(zmm[0]);
+    zmm[1] = sort_zmm(zmm[1]);
+    zmm[2] = sort_zmm(zmm[2]);
+    zmm[3] = sort_zmm(zmm[3]);
+    bitonic_merge_two_zmm(&zmm[0], &zmm[1]);
+    bitonic_merge_two_zmm(&zmm[2], &zmm[3]);
+    bitonic_merge_four_zmm(zmm);
+    vtype::storeu(arr, zmm[0]);
+    vtype::storeu(arr + 16, zmm[1]);
+    vtype::mask_storeu(arr + 32, load_mask1, zmm[2]);
+    vtype::mask_storeu(arr + 48, load_mask2, zmm[3]);
+}
+
+template 
+static inline void
+sort_128(type_t *arr, npy_int N)
+{
+    if (N <= 64) {
+        sort_64(arr, N);
+        return;
+    }
+    using zmm_t = typename vtype::zmm_t;
+    zmm_t zmm[8];
+    zmm[0] = vtype::loadu(arr);
+    zmm[1] = vtype::loadu(arr + 16);
+    zmm[2] = vtype::loadu(arr + 32);
+    zmm[3] = vtype::loadu(arr + 48);
+    zmm[0] = sort_zmm(zmm[0]);
+    zmm[1] = sort_zmm(zmm[1]);
+    zmm[2] = sort_zmm(zmm[2]);
+    zmm[3] = sort_zmm(zmm[3]);
+    __mmask16 load_mask1 = 0xFFFF, load_mask2 = 0xFFFF;
+    __mmask16 load_mask3 = 0xFFFF, load_mask4 = 0xFFFF;
+    if (N < 80) {
+        load_mask1 = (0x0001 << (N - 64)) - 0x0001;
+        load_mask2 = 0x0000;
+        load_mask3 = 0x0000;
+        load_mask4 = 0x0000;
+    }
+    else if (N < 96) {
+        load_mask2 = (0x0001 << (N - 80)) - 0x0001;
+        load_mask3 = 0x0000;
+        load_mask4 = 0x0000;
+    }
+    else if (N < 112) {
+        load_mask3 = (0x0001 << (N - 96)) - 0x0001;
+        load_mask4 = 0x0000;
+    }
+    else {
+        load_mask4 = (0x0001 << (N - 112)) - 0x0001;
+    }
+    zmm[4] = vtype::mask_loadu(vtype::zmm_max(), load_mask1, arr + 64);
+    zmm[5] = vtype::mask_loadu(vtype::zmm_max(), load_mask2, arr + 80);
+    zmm[6] = vtype::mask_loadu(vtype::zmm_max(), load_mask3, arr + 96);
+    zmm[7] = vtype::mask_loadu(vtype::zmm_max(), load_mask4, arr + 112);
+    zmm[4] = sort_zmm(zmm[4]);
+    zmm[5] = sort_zmm(zmm[5]);
+    zmm[6] = sort_zmm(zmm[6]);
+    zmm[7] = sort_zmm(zmm[7]);
+    bitonic_merge_two_zmm(&zmm[0], &zmm[1]);
+    bitonic_merge_two_zmm(&zmm[2], &zmm[3]);
+    bitonic_merge_two_zmm(&zmm[4], &zmm[5]);
+    bitonic_merge_two_zmm(&zmm[6], &zmm[7]);
+    bitonic_merge_four_zmm(zmm);
+    bitonic_merge_four_zmm(zmm + 4);
+    bitonic_merge_eight_zmm(zmm);
+    vtype::storeu(arr, zmm[0]);
+    vtype::storeu(arr + 16, zmm[1]);
+    vtype::storeu(arr + 32, zmm[2]);
+    vtype::storeu(arr + 48, zmm[3]);
+    vtype::mask_storeu(arr + 64, load_mask1, zmm[4]);
+    vtype::mask_storeu(arr + 80, load_mask2, zmm[5]);
+    vtype::mask_storeu(arr + 96, load_mask3, zmm[6]);
+    vtype::mask_storeu(arr + 112, load_mask4, zmm[7]);
+}
+
+template 
+static inline void
+swap(type_t *arr, npy_intp ii, npy_intp jj)
+{
+    type_t temp = arr[ii];
+    arr[ii] = arr[jj];
+    arr[jj] = temp;
+}
+
+// Median of 3 strategy
+// template
+// static inline
+// npy_intp get_pivot_index(type_t *arr, const npy_intp left, const npy_intp
+// right) {
+//    return (rand() % (right + 1 - left)) + left;
+//    //npy_intp middle = ((right-left)/2) + left;
+//    //type_t a = arr[left], b = arr[middle], c = arr[right];
+//    //if ((b >= a && b <= c) || (b <= a && b >= c))
+//    //    return middle;
+//    //if ((a >= b && a <= c) || (a <= b && a >= c))
+//    //    return left;
+//    //else
+//    //    return right;
+//}
+
+/*
+ * Picking the pivot: Median of 72 array elements chosen at random.
+ */
+
+template 
+static inline type_t
+get_pivot(type_t *arr, const npy_intp left, const npy_intp right)
+{
+    /* seeds for vectorized random number generator */
+    __m256i s0 = _mm256_setr_epi64x(8265987198341093849, 3762817312854612374,
+                                    1324281658759788278, 6214952190349879213);
+    __m256i s1 = _mm256_setr_epi64x(2874178529384792648, 1257248936691237653,
+                                    7874578921548791257, 1998265912745817298);
+    s0 = _mm256_add_epi64(s0, _mm256_set1_epi64x(left));
+    s1 = _mm256_sub_epi64(s1, _mm256_set1_epi64x(right));
+
+    npy_intp arrsize = right - left + 1;
+    __m256i bound =
+            _mm256_set1_epi32(arrsize > INT32_MAX ? INT32_MAX : arrsize);
+    __m512i left_vec = _mm512_set1_epi64(left);
+    __m512i right_vec = _mm512_set1_epi64(right);
+    using ymm_t = typename vtype::ymm_t;
+    ymm_t v[9];
+    /* fill 9 vectors with random numbers */
+    for (npy_int i = 0; i < 9; ++i) {
+        __m256i rand_64 = vnext(&s0, &s1); /* vector with 4 random uint64_t */
+        __m512i rand_32 = _mm512_cvtepi32_epi64(rnd_epu32(
+                rand_64, bound)); /* random numbers between 0 and bound - 1 */
+        __m512i indices;
+        if (i < 5)
+            indices =
+                    _mm512_add_epi64(left_vec, rand_32); /* indices for arr */
+        else
+            indices =
+                    _mm512_sub_epi64(right_vec, rand_32); /* indices for arr */
+
+        v[i] = vtype::template i64gather(indices, arr);
+    }
+
+    /* median network for 9 elements */
+    COEX(v[0], v[1]);
+    COEX(v[2], v[3]);
+    COEX(v[4], v[5]);
+    COEX(v[6], v[7]);
+    COEX(v[0], v[2]);
+    COEX(v[1], v[3]);
+    COEX(v[4], v[6]);
+    COEX(v[5], v[7]);
+    COEX(v[0], v[4]);
+    COEX(v[1], v[2]);
+    COEX(v[5], v[6]);
+    COEX(v[3], v[7]);
+    COEX(v[1], v[5]);
+    COEX(v[2], v[6]);
+    COEX(v[3], v[5]);
+    COEX(v[2], v[4]);
+    COEX(v[3], v[4]);
+    COEX(v[3], v[8]);
+    COEX(v[4], v[8]);
+
+    // technically v[4] needs to be sorted before we pick the correct median,
+    // picking the 4th element works just as well for performance
+    type_t *temp = (type_t *)&v[4];
+
+    return temp[4];
+}
+
+/*
+ * Partition one ZMM register based on the pivot and returns the index of the
+ * last element that is less than equal to the pivot.
+ */
+template 
+static inline npy_int
+partition_vec(type_t *arr, npy_intp left, npy_intp right, const zmm_t curr_vec,
+              const zmm_t pivot_vec, zmm_t *smallest_vec, zmm_t *biggest_vec)
+{
+    /* which elements are larger than the pivot */
+    __mmask16 gt_mask = vtype::ge(curr_vec, pivot_vec);
+    npy_int amount_gt_pivot = _mm_popcnt_u32((npy_int)gt_mask);
+    vtype::mask_compressstoreu(arr + left, _mm512_knot(gt_mask), curr_vec);
+    vtype::mask_compressstoreu(arr + right - amount_gt_pivot, gt_mask,
+                               curr_vec);
+    *smallest_vec = vtype::min(curr_vec, *smallest_vec);
+    *biggest_vec = vtype::max(curr_vec, *biggest_vec);
+    return amount_gt_pivot;
+}
+
+/*
+ * Partition an array based on the pivot and returns the index of the
+ * last element that is less than equal to the pivot.
+ */
+template 
+static inline npy_intp
+partition_avx512(type_t *arr, npy_intp left, npy_intp right, type_t pivot,
+                 type_t *smallest, type_t *biggest)
+{
+    /* make array length divisible by 16 , shortening the array */
+    for (npy_int i = (right - left) % 16; i > 0; --i) {
+        *smallest = MIN(*smallest, arr[left]);
+        *biggest = MAX(*biggest, arr[left]);
+        if (arr[left] > pivot) {
+            swap(arr, left, --right);
+        }
+        else {
+            ++left;
+        }
+    }
+
+    if (left == right)
+        return left; /* less than 16 elements in the array */
+
+    using zmm_t = typename vtype::zmm_t;
+    zmm_t pivot_vec = vtype::set1(pivot);
+    zmm_t min_vec = vtype::set1(*smallest);
+    zmm_t max_vec = vtype::set1(*biggest);
+
+    if (right - left == 16) {
+        zmm_t vec = vtype::loadu(arr + left);
+        npy_int amount_gt_pivot = partition_vec(
+                arr, left, left + 16, vec, pivot_vec, &min_vec, &max_vec);
+        *smallest = vtype::reducemin(min_vec);
+        *biggest = vtype::reducemax(max_vec);
+        return left + (16 - amount_gt_pivot);
+    }
+
+    // first and last 16 values are partitioned at the end
+    zmm_t vec_left = vtype::loadu(arr + left);
+    zmm_t vec_right = vtype::loadu(arr + (right - 16));
+    // store points of the vectors
+    npy_intp r_store = right - 16;
+    npy_intp l_store = left;
+    // indices for loading the elements
+    left += 16;
+    right -= 16;
+    while (right - left != 0) {
+        zmm_t curr_vec;
+        /*
+         * if fewer elements are stored on the right side of the array,
+         * then next elements are loaded from the right side,
+         * otherwise from the left side
+         */
+        if ((r_store + 16) - right < left - l_store) {
+            right -= 16;
+            curr_vec = vtype::loadu(arr + right);
+        }
+        else {
+            curr_vec = vtype::loadu(arr + left);
+            left += 16;
+        }
+        // partition the current vector and save it on both sides of the array
+        npy_int amount_gt_pivot =
+                partition_vec(arr, l_store, r_store + 16, curr_vec,
+                                     pivot_vec, &min_vec, &max_vec);
+        ;
+        r_store -= amount_gt_pivot;
+        l_store += (16 - amount_gt_pivot);
+    }
+
+    /* partition and save vec_left and vec_right */
+    npy_int amount_gt_pivot =
+            partition_vec(arr, l_store, r_store + 16, vec_left,
+                                 pivot_vec, &min_vec, &max_vec);
+    l_store += (16 - amount_gt_pivot);
+    amount_gt_pivot =
+            partition_vec(arr, l_store, l_store + 16, vec_right,
+                                 pivot_vec, &min_vec, &max_vec);
+    l_store += (16 - amount_gt_pivot);
+    *smallest = vtype::reducemin(min_vec);
+    *biggest = vtype::reducemax(max_vec);
+    return l_store;
+}
+
+template 
+static inline void
+qsort_(type_t *arr, npy_intp left, npy_intp right, npy_int max_iters)
+{
+    /*
+     * Resort to heapsort if quicksort isn't making any progress
+     */
+    if (max_iters <= 0) {
+        heapsort_(arr + left, right + 1 - left);
+        return;
+    }
+    /*
+     * Base case: use bitonic networks to sort arrays <= 128
+     */
+    if (right + 1 - left <= 128) {
+        sort_128(arr + left, (npy_int)(right + 1 - left));
+        return;
+    }
+
+    type_t pivot = get_pivot(arr, left, right);
+    type_t smallest = vtype::type_max();
+    type_t biggest = vtype::type_min();
+    npy_intp pivot_index = partition_avx512(arr, left, right + 1, pivot,
+                                                   &smallest, &biggest);
+    if (pivot != smallest)
+        qsort_(arr, left, pivot_index - 1, max_iters - 1);
+    if (pivot != biggest)
+        qsort_(arr, pivot_index, right, max_iters - 1);
+}
+
+static inline npy_intp
+replace_nan_with_inf(npy_float *arr, npy_intp arrsize)
+{
+    npy_intp nan_count = 0;
+    __mmask16 loadmask = 0xFFFF;
+    while (arrsize > 0) {
+        if (arrsize < 16) {
+            loadmask = (0x0001 << arrsize) - 0x0001;
+        }
+        __m512 in_zmm = _mm512_maskz_loadu_ps(loadmask, arr);
+        __mmask16 nanmask = _mm512_cmp_ps_mask(in_zmm, in_zmm, _CMP_NEQ_UQ);
+        nan_count += _mm_popcnt_u32((npy_int)nanmask);
+        _mm512_mask_storeu_ps(arr, nanmask, ZMM_MAX_FLOAT);
+        arr += 16;
+        arrsize -= 16;
+    }
+    return nan_count;
+}
+
+static inline void
+replace_inf_with_nan(npy_float *arr, npy_intp arrsize, npy_intp nan_count)
+{
+    for (npy_intp ii = arrsize - 1; nan_count > 0; --ii) {
+        arr[ii] = NPY_NANF;
+        nan_count -= 1;
+    }
+}
+
+/***************************************
+ * C > C++ dispatch
+ ***************************************/
+
+NPY_NO_EXPORT void
+NPY_CPU_DISPATCH_CURFX(x86_quicksort_int)(void *arr, npy_intp arrsize)
+{
+    if (arrsize > 1) {
+        qsort_, npy_int>((npy_int *)arr, 0, arrsize - 1,
+                                         2 * (npy_int)log2(arrsize));
+    }
+}
+
+NPY_NO_EXPORT void
+NPY_CPU_DISPATCH_CURFX(x86_quicksort_uint)(void *arr, npy_intp arrsize)
+{
+    if (arrsize > 1) {
+        qsort_, npy_uint>((npy_uint *)arr, 0, arrsize - 1,
+                                           2 * (npy_int)log2(arrsize));
+    }
+}
+
+NPY_NO_EXPORT void
+NPY_CPU_DISPATCH_CURFX(x86_quicksort_float)(void *arr, npy_intp arrsize)
+{
+    if (arrsize > 1) {
+        npy_intp nan_count = replace_nan_with_inf((npy_float *)arr, arrsize);
+        qsort_, npy_float>((npy_float *)arr, 0, arrsize - 1,
+                                             2 * (npy_int)log2(arrsize));
+        replace_inf_with_nan((npy_float *)arr, arrsize, nan_count);
+    }
+}
+
+#endif  // NPY_HAVE_AVX512_SKX
diff --git a/numpy/core/src/npysort/x86-qsort.h b/numpy/core/src/npysort/x86-qsort.h
new file mode 100644
index 000000000000..6340e2bc7c31
--- /dev/null
+++ b/numpy/core/src/npysort/x86-qsort.h
@@ -0,0 +1,28 @@
+#include "numpy/npy_common.h"
+
+#include "npy_cpu_dispatch.h"
+
+#ifndef NPY_NO_EXPORT
+#define NPY_NO_EXPORT NPY_VISIBILITY_HIDDEN
+#endif
+
+#ifndef NPY_DISABLE_OPTIMIZATION
+#include "x86-qsort.dispatch.h"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+NPY_CPU_DISPATCH_DECLARE(NPY_NO_EXPORT void x86_quicksort_int,
+                         (void *start, npy_intp num))
+
+NPY_CPU_DISPATCH_DECLARE(NPY_NO_EXPORT void x86_quicksort_uint,
+                         (void *start, npy_intp num))
+
+NPY_CPU_DISPATCH_DECLARE(NPY_NO_EXPORT void x86_quicksort_float,
+                         (void *start, npy_intp num))
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/numpy/core/src/umath/_operand_flag_tests.c.src b/numpy/core/src/umath/_operand_flag_tests.c
similarity index 100%
rename from numpy/core/src/umath/_operand_flag_tests.c.src
rename to numpy/core/src/umath/_operand_flag_tests.c
diff --git a/numpy/core/src/umath/_rational_tests.c.src b/numpy/core/src/umath/_rational_tests.c
similarity index 100%
rename from numpy/core/src/umath/_rational_tests.c.src
rename to numpy/core/src/umath/_rational_tests.c
diff --git a/numpy/core/src/umath/_scaled_float_dtype.c b/numpy/core/src/umath/_scaled_float_dtype.c
index b6c19362a5b4..2d6ba3574e5f 100644
--- a/numpy/core/src/umath/_scaled_float_dtype.c
+++ b/numpy/core/src/umath/_scaled_float_dtype.c
@@ -125,9 +125,9 @@ sfloat_setitem(PyObject *obj, char *data, PyArrayObject *arr)
 
 /* Special DType methods and the descr->f slot storage */
 NPY_DType_Slots sfloat_slots = {
-    .default_descr = &sfloat_default_descr,
     .discover_descr_from_pyobject = &sfloat_discover_from_pyobject,
     .is_known_scalar_type = &sfloat_is_known_scalar_type,
+    .default_descr = &sfloat_default_descr,
     .common_dtype = &sfloat_common_dtype,
     .common_instance = &sfloat_common_instance,
     .f = {
@@ -136,14 +136,13 @@ NPY_DType_Slots sfloat_slots = {
     }
 };
 
-
 static PyArray_SFloatDescr SFloatSingleton = {{
-        .elsize = sizeof(double),
-        .alignment = _ALIGN(double),
+        .byteorder = '|',  /* do not bother with byte-swapping... */
         .flags = NPY_USE_GETITEM|NPY_USE_SETITEM,
         .type_num = -1,
+        .elsize = sizeof(double),
+        .alignment = _ALIGN(double),
         .f = &sfloat_slots.f,
-        .byteorder = '|',  /* do not bother with byte-swapping... */
     },
     .scaling = 1,
 };
@@ -233,11 +232,11 @@ sfloat_repr(PyArray_SFloatDescr *self)
 static PyArray_DTypeMeta PyArray_SFloatDType = {{{
         PyVarObject_HEAD_INIT(NULL, 0)
         .tp_name = "numpy._ScaledFloatTestDType",
-        .tp_methods = sfloat_methods,
-        .tp_new = sfloat_new,
+        .tp_basicsize = sizeof(PyArray_SFloatDescr),
         .tp_repr = (reprfunc)sfloat_repr,
         .tp_str = (reprfunc)sfloat_repr,
-        .tp_basicsize = sizeof(PyArray_SFloatDescr),
+        .tp_methods = sfloat_methods,
+        .tp_new = sfloat_new,
     }},
     .type_num = -1,
     .scalar_type = NULL,
@@ -325,7 +324,8 @@ sfloat_to_sfloat_resolve_descriptors(
             PyArrayMethodObject *NPY_UNUSED(self),
             PyArray_DTypeMeta *NPY_UNUSED(dtypes[2]),
             PyArray_Descr *given_descrs[2],
-            PyArray_Descr *loop_descrs[2])
+            PyArray_Descr *loop_descrs[2],
+            npy_intp *view_offset)
 {
     loop_descrs[0] = given_descrs[0];
     Py_INCREF(loop_descrs[0]);
@@ -341,7 +341,8 @@ sfloat_to_sfloat_resolve_descriptors(
     if (((PyArray_SFloatDescr *)loop_descrs[0])->scaling
             == ((PyArray_SFloatDescr *)loop_descrs[1])->scaling) {
         /* same scaling is just a view */
-        return NPY_NO_CASTING | _NPY_CAST_IS_VIEW;
+        *view_offset = 0;
+        return NPY_NO_CASTING;
     }
     else if (-((PyArray_SFloatDescr *)loop_descrs[0])->scaling
              == ((PyArray_SFloatDescr *)loop_descrs[1])->scaling) {
@@ -384,7 +385,8 @@ float_to_from_sfloat_resolve_descriptors(
         PyArrayMethodObject *NPY_UNUSED(self),
         PyArray_DTypeMeta *dtypes[2],
         PyArray_Descr *NPY_UNUSED(given_descrs[2]),
-        PyArray_Descr *loop_descrs[2])
+        PyArray_Descr *loop_descrs[2],
+        npy_intp *view_offset)
 {
     loop_descrs[0] = NPY_DT_CALL_default_descr(dtypes[0]);
     if (loop_descrs[0] == NULL) {
@@ -394,7 +396,8 @@ float_to_from_sfloat_resolve_descriptors(
     if (loop_descrs[1] == NULL) {
         return -1;
     }
-    return NPY_NO_CASTING | _NPY_CAST_IS_VIEW;
+    *view_offset = 0;
+    return NPY_NO_CASTING;
 }
 
 
@@ -422,7 +425,8 @@ sfloat_to_bool_resolve_descriptors(
         PyArrayMethodObject *NPY_UNUSED(self),
         PyArray_DTypeMeta *NPY_UNUSED(dtypes[2]),
         PyArray_Descr *given_descrs[2],
-        PyArray_Descr *loop_descrs[2])
+        PyArray_Descr *loop_descrs[2],
+        npy_intp *NPY_UNUSED(view_offset))
 {
     Py_INCREF(given_descrs[0]);
     loop_descrs[0] = given_descrs[0];
@@ -443,11 +447,11 @@ init_casts(void)
         .name = "sfloat_to_sfloat_cast",
         .nin = 1,
         .nout = 1,
+        /* minimal guaranteed casting */
+        .casting = NPY_SAME_KIND_CASTING,
         .flags = NPY_METH_SUPPORTS_UNALIGNED,
         .dtypes = dtypes,
         .slots = slots,
-        /* minimal guaranteed casting */
-        .casting = NPY_SAME_KIND_CASTING,
     };
 
     slots[0].slot = NPY_METH_resolve_descriptors;
@@ -541,7 +545,8 @@ multiply_sfloats_resolve_descriptors(
         PyArrayMethodObject *NPY_UNUSED(self),
         PyArray_DTypeMeta *NPY_UNUSED(dtypes[3]),
         PyArray_Descr *given_descrs[3],
-        PyArray_Descr *loop_descrs[3])
+        PyArray_Descr *loop_descrs[3],
+        npy_intp *NPY_UNUSED(view_offset))
 {
     /*
      * Multiply the scaling for the result.  If the result was passed in we
@@ -602,7 +607,8 @@ add_sfloats_resolve_descriptors(
         PyArrayMethodObject *NPY_UNUSED(self),
         PyArray_DTypeMeta *NPY_UNUSED(dtypes[3]),
         PyArray_Descr *given_descrs[3],
-        PyArray_Descr *loop_descrs[3])
+        PyArray_Descr *loop_descrs[3],
+        npy_intp *NPY_UNUSED(view_offset))
 {
     /*
      * Here we accept an output descriptor (the inner loop can deal with it),
diff --git a/numpy/core/src/umath/_struct_ufunc_tests.c.src b/numpy/core/src/umath/_struct_ufunc_tests.c
similarity index 100%
rename from numpy/core/src/umath/_struct_ufunc_tests.c.src
rename to numpy/core/src/umath/_struct_ufunc_tests.c
diff --git a/numpy/core/src/umath/_umath_tests.c.src b/numpy/core/src/umath/_umath_tests.c.src
index ce42fc2711a3..1bf459ce6664 100644
--- a/numpy/core/src/umath/_umath_tests.c.src
+++ b/numpy/core/src/umath/_umath_tests.c.src
@@ -16,6 +16,9 @@
 #include "npy_pycompat.h"
 
 #include "npy_config.h"
+#include "npy_cpu_features.h"
+#include "npy_cpu_dispatch.h"
+#include "numpy/npy_cpu.h"
 
 /*
  *****************************************************************************
diff --git a/numpy/core/src/umath/dispatching.c b/numpy/core/src/umath/dispatching.c
index 8e99c04201a5..077d56f33bc8 100644
--- a/numpy/core/src/umath/dispatching.c
+++ b/numpy/core/src/umath/dispatching.c
@@ -40,25 +40,30 @@
 
 #define PY_SSIZE_T_CLEAN
 #include 
+#include 
 
 #include "numpy/ndarraytypes.h"
 #include "common.h"
 
 #include "dispatching.h"
 #include "dtypemeta.h"
+#include "common_dtype.h"
 #include "npy_hashtable.h"
 #include "legacy_array_method.h"
 #include "ufunc_object.h"
 #include "ufunc_type_resolution.h"
 
 
+#define PROMOTION_DEBUG_TRACING 0
+
+
 /* forward declaration */
 static NPY_INLINE PyObject *
 promote_and_get_info_and_ufuncimpl(PyUFuncObject *ufunc,
         PyArrayObject *const ops[],
         PyArray_DTypeMeta *signature[],
         PyArray_DTypeMeta *op_dtypes[],
-        npy_bool allow_legacy_promotion, npy_bool cache);
+        npy_bool allow_legacy_promotion);
 
 
 /**
@@ -74,7 +79,7 @@ NPY_NO_EXPORT int
 PyUFunc_AddLoop(PyUFuncObject *ufunc, PyObject *info, int ignore_duplicate)
 {
     /*
-     * Validate the info object, this should likely move to to a different
+     * Validate the info object, this should likely move to a different
      * entry-point in the future (and is mostly unnecessary currently).
      */
     if (!PyTuple_CheckExact(info) || PyTuple_GET_SIZE(info) != 2) {
@@ -141,12 +146,61 @@ PyUFunc_AddLoop(PyUFuncObject *ufunc, PyObject *info, int ignore_duplicate)
 }
 
 
+/*
+ * Add loop directly to a ufunc from a given ArrayMethod spec.
+ */
+NPY_NO_EXPORT int
+PyUFunc_AddLoopFromSpec(PyObject *ufunc, PyArrayMethod_Spec *spec)
+{
+    if (!PyObject_TypeCheck(ufunc, &PyUFunc_Type)) {
+        PyErr_SetString(PyExc_TypeError,
+                "ufunc object passed is not a ufunc!");
+        return -1;
+    }
+    PyBoundArrayMethodObject *bmeth =
+            (PyBoundArrayMethodObject *)PyArrayMethod_FromSpec(spec);
+    if (bmeth == NULL) {
+        return -1;
+    }
+    int nargs = bmeth->method->nin + bmeth->method->nout;
+    PyObject *dtypes = PyArray_TupleFromItems(
+            nargs, (PyObject **)bmeth->dtypes, 1);
+    if (dtypes == NULL) {
+        return -1;
+    }
+    PyObject *info = PyTuple_Pack(2, dtypes, bmeth->method);
+    Py_DECREF(bmeth);
+    Py_DECREF(dtypes);
+    if (info == NULL) {
+        return -1;
+    }
+    return PyUFunc_AddLoop((PyUFuncObject *)ufunc, info, 0);
+}
+
+
 /**
  * Resolves the implementation to use, this uses typical multiple dispatching
  * methods of finding the best matching implementation or resolver.
  * (Based on `isinstance()`, the knowledge that non-abstract DTypes cannot
  * be subclassed is used, however.)
  *
+ * NOTE: This currently does not take into account output dtypes which do not
+ *       have to match.  The possible extension here is that if an output
+ *       is given (and thus an output dtype), but not part of the signature
+ *       we could ignore it for matching, but *prefer* a loop that matches
+ *       better.
+ *       Why is this not done currently?  First, it seems a niche feature that
+ *       loops can only be distinguished based on the output dtype.  Second,
+ *       there are some nasty theoretical things because:
+ *
+ *            np.add(f4, f4, out=f8)
+ *            np.add(f4, f4, out=f8, dtype=f8)
+ *
+ *       are different, the first uses the f4 loop, the second the f8 loop.
+ *       The problem is, that the current cache only uses the op_dtypes and
+ *       both are `(f4, f4, f8)`.  The cache would need to store also which
+ *       output was provided by `dtype=`/`signature=`.
+ *
  * @param ufunc
  * @param op_dtypes The DTypes that are either passed in (defined by an
  *        operand) or defined by the `signature` as also passed in as
@@ -159,17 +213,35 @@ PyUFunc_AddLoop(PyUFuncObject *ufunc, PyObject *info, int ignore_duplicate)
  */
 static int
 resolve_implementation_info(PyUFuncObject *ufunc,
-        PyArray_DTypeMeta *op_dtypes[], PyObject **out_info)
+        PyArray_DTypeMeta *op_dtypes[], npy_bool only_promoters,
+        PyObject **out_info)
 {
     int nin = ufunc->nin, nargs = ufunc->nargs;
     Py_ssize_t size = PySequence_Length(ufunc->_loops);
     PyObject *best_dtypes = NULL;
     PyObject *best_resolver_info = NULL;
 
+#if PROMOTION_DEBUG_TRACING
+    printf("Promoting for '%s' promoters only: %d\n",
+            ufunc->name ? ufunc->name : "", (int)only_promoters);
+    printf("    DTypes: ");
+    PyObject *tmp = PyArray_TupleFromItems(ufunc->nargs, op_dtypes, 1);
+    PyObject_Print(tmp, stdout, 0);
+    Py_DECREF(tmp);
+    printf("\n");
+    Py_DECREF(tmp);
+#endif
+
     for (Py_ssize_t res_idx = 0; res_idx < size; res_idx++) {
         /* Test all resolvers  */
         PyObject *resolver_info = PySequence_Fast_GET_ITEM(
                 ufunc->_loops, res_idx);
+
+        if (only_promoters && PyObject_TypeCheck(
+                    PyTuple_GET_ITEM(resolver_info, 1), &PyArrayMethod_Type)) {
+            continue;
+        }
+
         PyObject *curr_dtypes = PyTuple_GET_ITEM(resolver_info, 0);
         /*
          * Test if the current resolver matches, it could make sense to
@@ -179,20 +251,31 @@ resolve_implementation_info(PyUFuncObject *ufunc,
 
         npy_bool matches = NPY_TRUE;
         /*
-         * NOTE: We check also the output DType.  In principle we do not
-         *       have to strictly match it (unless it is provided by the
-         *       `signature`).  This assumes that a (fallback) promoter will
-         *       unset the output DType if no exact match is found.
+         * NOTE: We currently match the output dtype exactly here, this is
+         *       actually only necessary if the signature includes.
+         *       Currently, we rely that op-dtypes[nin:nout] is NULLed if not.
          */
         for (Py_ssize_t i = 0; i < nargs; i++) {
             PyArray_DTypeMeta *given_dtype = op_dtypes[i];
             PyArray_DTypeMeta *resolver_dtype = (
                     (PyArray_DTypeMeta *)PyTuple_GET_ITEM(curr_dtypes, i));
             assert((PyObject *)given_dtype != Py_None);
-            if (given_dtype == NULL && i >= nin) {
-                /* Unspecified out always matches (see below for inputs) */
-                continue;
+            if (given_dtype == NULL) {
+                if (i >= nin) {
+                    /* Unspecified out always matches (see below for inputs) */
+                    continue;
+                }
+                /*
+                 * This is a reduce-like operation, which always have the form
+                 * `(res_DType, op_DType, res_DType)`.  If the first and last
+                 * dtype of the loops match, this should be reduce-compatible.
+                 */
+                if (PyTuple_GET_ITEM(curr_dtypes, 0)
+                        == PyTuple_GET_ITEM(curr_dtypes, 2)) {
+                    continue;
+                }
             }
+
             if (resolver_dtype == (PyArray_DTypeMeta *)Py_None) {
                 /* always matches */
                 continue;
@@ -204,24 +287,7 @@ resolve_implementation_info(PyUFuncObject *ufunc,
                 matches = NPY_FALSE;
                 break;
             }
-            if (given_dtype == NULL) {
-                /*
-                 * If an input was not specified, this is a reduce-like
-                 * operation: reductions use `(operand_DType, NULL, out_DType)`
-                 * as they only have a single operand.  This allows special
-                 * reduce promotion rules useful for example for sum/product.
-                 * E.g. `np.add.reduce([True, True])` promotes to integer.
-                 *
-                 * Continuing here allows a promoter to handle reduce-like
-                 * promotions explicitly if necessary.
-                 * TODO: The `!NPY_DT_is_abstract(resolver_dtype)` currently
-                 *       ensures that this is a promoter.  If we allow
-                 *       `ArrayMethods` to use abstract DTypes, we may have to
-                 *       reject it here or the `ArrayMethod` has to implement
-                 *       the reduce promotion.
-                 */
-                continue;
-            }
+
             int subclass = PyObject_IsSubclass(
                     (PyObject *)given_dtype, (PyObject *)resolver_dtype);
             if (subclass < 0) {
@@ -254,8 +320,12 @@ resolve_implementation_info(PyUFuncObject *ufunc,
              * In all cases, we give up resolution, since it would be
              * necessary to compare to two "best" cases.
              */
-            int unambiguously_equally_good = 1;
             for (Py_ssize_t i = 0; i < nargs; i++) {
+                if (i == ufunc->nin && current_best != -1) {
+                    /* inputs prefer one loop and outputs have lower priority */
+                    break;
+                }
+
                 int best;
 
                 PyObject *prev_dtype = PyTuple_GET_ITEM(best_dtypes, i);
@@ -265,50 +335,18 @@ resolve_implementation_info(PyUFuncObject *ufunc,
                     /* equivalent, so this entry does not matter */
                     continue;
                 }
-                /*
-                 * TODO: Even if the input is not specified, if we have
-                 *       abstract DTypes and one is a subclass of the other,
-                 *       the subclass should be considered a better match
-                 *       (subclasses are always more specific).
-                 */
-                /* Whether this (normally output) dtype was specified at all */
                 if (op_dtypes[i] == NULL) {
                     /*
-                     * When DType is completely unspecified, prefer abstract
-                     * over concrete, assuming it will resolve.
-                     * Furthermore, we cannot decide which abstract/None
-                     * is "better", only concrete ones which are subclasses
-                     * of Abstract ones are defined as worse.
+                     * If an a dtype is NULL it always matches, so there is no
+                     * point in defining one as more precise than the other.
                      */
-                    npy_bool prev_is_concrete = NPY_FALSE;
-                    npy_bool new_is_concrete = NPY_FALSE;
-                    if ((prev_dtype != Py_None) &&
-                            !NPY_DT_is_abstract((PyArray_DTypeMeta *)prev_dtype)) {
-                        prev_is_concrete = NPY_TRUE;
-                    }
-                    if ((new_dtype != Py_None) &&
-                            !NPY_DT_is_abstract((PyArray_DTypeMeta *)new_dtype)) {
-                        new_is_concrete = NPY_TRUE;
-                    }
-                    if (prev_is_concrete == new_is_concrete) {
-                        best = -1;
-                    }
-                    else if (prev_is_concrete) {
-                        unambiguously_equally_good = 0;
-                        best = 1;
-                    }
-                    else {
-                        unambiguously_equally_good = 0;
-                        best = 0;
-                    }
+                    continue;
                 }
                 /* If either is None, the other is strictly more specific */
-                else if (prev_dtype == Py_None) {
-                    unambiguously_equally_good = 0;
+                if (prev_dtype == Py_None) {
                     best = 1;
                 }
                 else if (new_dtype == Py_None) {
-                    unambiguously_equally_good = 0;
                     best = 0;
                 }
                 /*
@@ -318,20 +356,25 @@ resolve_implementation_info(PyUFuncObject *ufunc,
                 else if (!NPY_DT_is_abstract((PyArray_DTypeMeta *)prev_dtype) &&
                          !NPY_DT_is_abstract((PyArray_DTypeMeta *)new_dtype)) {
                     /*
-                     * Ambiguous unless the are identical (checked above),
-                     * but since they are concrete it does not matter which
-                     * best to compare.
+                     * Ambiguous unless they are identical (checked above),
+                     * or one matches exactly.
                      */
-                    best = -1;
+                    if (prev_dtype == (PyObject *)op_dtypes[i]) {
+                        best = 0;
+                    }
+                    else if (new_dtype == (PyObject *)op_dtypes[i]) {
+                        best = 1;
+                    }
+                    else {
+                        best = -1;
+                    }
                 }
                 else if (!NPY_DT_is_abstract((PyArray_DTypeMeta *)prev_dtype)) {
                     /* old is not abstract, so better (both not possible) */
-                    unambiguously_equally_good = 0;
                     best = 0;
                 }
                 else if (!NPY_DT_is_abstract((PyArray_DTypeMeta *)new_dtype)) {
                     /* new is not abstract, so better (both not possible) */
-                    unambiguously_equally_good = 0;
                     best = 1;
                 }
                 /*
@@ -349,6 +392,10 @@ resolve_implementation_info(PyUFuncObject *ufunc,
                     return -1;
                 }
 
+                if (best == -1) {
+                    /* no new info, nothing to update */
+                    continue;
+                }
                 if ((current_best != -1) && (current_best != best)) {
                     /*
                      * We need a clear best, this could be tricky, unless
@@ -367,15 +414,34 @@ resolve_implementation_info(PyUFuncObject *ufunc,
 
             if (current_best == -1) {
                 /*
-                 * TODO: It would be nice to have a "diagnostic mode" that
-                 *       informs if this happens! (An immediate error currently
-                 *       blocks later legacy resolution, but may work in the
-                 *       future.)
+                 * We could not find a best loop, but promoters should be
+                 * designed in a way to disambiguate such scenarios, so we
+                 * retry the whole lookup using only promoters.
+                 * (There is a small chance we already got two promoters.
+                 * We just redo it anyway for simplicity.)
                  */
-                if (unambiguously_equally_good) {
-                    /* unset the best resolver to indicate this */
-                    best_resolver_info = NULL;
-                    continue;
+                if (!only_promoters) {
+                    return resolve_implementation_info(ufunc,
+                            op_dtypes, NPY_TRUE, out_info);
+                }
+                /*
+                 * If this is already the retry, we are out of luck.  Promoters
+                 * should be designed in a way that this cannot happen!
+                 * (It should be noted, that the retry might not find anything
+                 * and we still do a legacy lookup later.)
+                 */
+                PyObject *given = PyArray_TupleFromItems(
+                        ufunc->nargs, (PyObject **)op_dtypes, 1);
+                if (given != NULL) {
+                    PyErr_Format(PyExc_RuntimeError,
+                            "Could not find a loop for the inputs:\n    %S\n"
+                            "The two promoters %S and %S matched the input "
+                            "equally well.  Promoters must be designed "
+                            "to be unambiguous.  NOTE: This indicates an error "
+                            "in NumPy or an extending library and should be "
+                            "reported.",
+                            given, best_dtypes, curr_dtypes);
+                    Py_DECREF(given);
                 }
                 *out_info = NULL;
                 return 0;
@@ -457,10 +523,9 @@ call_promoter_and_recurse(PyUFuncObject *ufunc, PyObject *promoter,
     if (Py_EnterRecursiveCall(" during ufunc promotion.") != 0) {
         goto finish;
     }
-    /* TODO: The caching logic here may need revising: */
     resolved_info = promote_and_get_info_and_ufuncimpl(ufunc,
             operands, signature, new_op_dtypes,
-            /* no legacy promotion */ NPY_FALSE, /* cache */ NPY_TRUE);
+            /* no legacy promotion */ NPY_FALSE);
 
     Py_LeaveRecursiveCall();
 
@@ -531,7 +596,8 @@ _make_new_typetup(
 static int
 legacy_promote_using_legacy_type_resolver(PyUFuncObject *ufunc,
         PyArrayObject *const *ops, PyArray_DTypeMeta *signature[],
-        PyArray_DTypeMeta *operation_DTypes[], int *out_cacheable)
+        PyArray_DTypeMeta *operation_DTypes[], int *out_cacheable,
+        npy_bool check_only)
 {
     int nargs = ufunc->nargs;
     PyArray_Descr *out_descrs[NPY_MAXARGS] = {NULL};
@@ -551,26 +617,65 @@ legacy_promote_using_legacy_type_resolver(PyUFuncObject *ufunc,
             NPY_UNSAFE_CASTING, (PyArrayObject **)ops, type_tuple,
             out_descrs) < 0) {
         Py_XDECREF(type_tuple);
+        /* Not all legacy resolvers clean up on failures: */
+        for (int i = 0; i < nargs; i++) {
+            Py_CLEAR(out_descrs[i]);
+        }
         return -1;
     }
     Py_XDECREF(type_tuple);
 
+    if (NPY_UNLIKELY(check_only)) {
+        /*
+         * When warnings are enabled, we don't replace the DTypes, but only
+         * check whether the old result is the same as the new one.
+         * For noise reason, we do this only on the *output* dtypes which
+         * ignores floating point precision changes for comparisons such as
+         * `np.float32(3.1) < 3.1`.
+         */
+        for (int i = ufunc->nin; i < ufunc->nargs; i++) {
+            /*
+             * If an output was provided and the new dtype matches, we
+             * should (at best) lose a tiny bit of precision, e.g.:
+             * `np.true_divide(float32_arr0d, 1, out=float32_arr0d)`
+             * (which operated on float64 before, although it is probably rare)
+             */
+            if (ops[i] != NULL
+                    && PyArray_EquivTypenums(
+                            operation_DTypes[i]->type_num,
+                            PyArray_DESCR(ops[i])->type_num)) {
+                continue;
+            }
+            /* Otherwise, warn if the dtype doesn't match */
+            if (!PyArray_EquivTypenums(
+                    operation_DTypes[i]->type_num, out_descrs[i]->type_num)) {
+                if (PyErr_WarnFormat(PyExc_UserWarning, 1,
+                        "result dtype changed due to the removal of value-based "
+                        "promotion from NumPy. Changed from %S to %S.",
+                        out_descrs[i], operation_DTypes[i]->singleton) < 0) {
+                    return -1;
+                }
+                return 0;
+            }
+        }
+        return 0;
+    }
+
     for (int i = 0; i < nargs; i++) {
         Py_XSETREF(operation_DTypes[i], NPY_DTYPE(out_descrs[i]));
         Py_INCREF(operation_DTypes[i]);
         Py_DECREF(out_descrs[i]);
     }
-    if (ufunc->type_resolver == &PyUFunc_SimpleBinaryComparisonTypeResolver) {
-        /*
-         * In this one case, the deprecation means that we actually override
-         * the signature.
-         */
-        for (int i = 0; i < nargs; i++) {
-            if (signature[i] != NULL && signature[i] != operation_DTypes[i]) {
-                Py_INCREF(operation_DTypes[i]);
-                Py_SETREF(signature[i], operation_DTypes[i]);
-                *out_cacheable = 0;
-            }
+    /*
+     * datetime legacy resolvers ignore the signature, which should be
+     * warn/raise (when used).  In such cases, the signature is (incorrectly)
+     * mutated, and caching is not possible.
+     */
+    for (int i = 0; i < nargs; i++) {
+        if (signature[i] != NULL && signature[i] != operation_DTypes[i]) {
+            Py_INCREF(operation_DTypes[i]);
+            Py_SETREF(signature[i], operation_DTypes[i]);
+            *out_cacheable = 0;
         }
     }
     return 0;
@@ -607,7 +712,7 @@ add_and_return_legacy_wrapping_ufunc_loop(PyUFuncObject *ufunc,
         Py_DECREF(info);
         return NULL;
     }
-
+    Py_DECREF(info);  /* now borrowed from the ufunc's list of loops */
     return info;
 }
 
@@ -625,7 +730,7 @@ promote_and_get_info_and_ufuncimpl(PyUFuncObject *ufunc,
         PyArrayObject *const ops[],
         PyArray_DTypeMeta *signature[],
         PyArray_DTypeMeta *op_dtypes[],
-        npy_bool allow_legacy_promotion, npy_bool cache)
+        npy_bool allow_legacy_promotion)
 {
     /*
      * Fetch the dispatching info which consists of the implementation and
@@ -644,11 +749,12 @@ promote_and_get_info_and_ufuncimpl(PyUFuncObject *ufunc,
     }
 
     /*
-     * If `info == NULL`, the caching failed, repeat using the full resolution
-     * in `resolve_implementation_info`.
+     * If `info == NULL`, loading from cache failed, use the full resolution
+     * in `resolve_implementation_info` (which caches its result on success).
      */
     if (info == NULL) {
-        if (resolve_implementation_info(ufunc, op_dtypes, &info) < 0) {
+        if (resolve_implementation_info(ufunc,
+                op_dtypes, NPY_FALSE, &info) < 0) {
             return NULL;
         }
         if (info != NULL && PyObject_TypeCheck(
@@ -657,41 +763,12 @@ promote_and_get_info_and_ufuncimpl(PyUFuncObject *ufunc,
              * Found the ArrayMethod and NOT promoter.  Before returning it
              * add it to the cache for faster lookup in the future.
              */
-            if (cache && PyArrayIdentityHash_SetItem(ufunc->_dispatch_cache,
+            if (PyArrayIdentityHash_SetItem(ufunc->_dispatch_cache,
                     (PyObject **)op_dtypes, info, 0) < 0) {
                 return NULL;
             }
             return info;
         }
-        else if (info == NULL && op_dtypes[0] == NULL) {
-            /*
-             * If we have a reduction, fill in the unspecified input/array
-             * assuming it should have the same dtype as the operand input
-             * (or the output one if given).
-             * Then, try again.  In some cases, this will choose different
-             * paths, such as `ll->?` instead of an `??->?` loop for `np.equal`
-             * when the input is `.l->.` (`.` meaning undefined).  This will
-             * then cause an error.  But cast to `?` would always lose
-             * information, and in many cases important information:
-             *
-             * ```python
-             * from operator import eq
-             * from functools import reduce
-             *
-             * reduce(eq, [1, 2, 3]) != reduce(eq, [True, True, True])
-             * ```
-             *
-             * The special cases being `logical_(and|or|xor)` which can always
-             * cast to boolean ahead of time and still give the right answer
-             * (unsafe cast to bool is fine here). We special case these at
-             * the time of this comment (NumPy 1.21).
-             */
-            assert(ufunc->nin == 2 && ufunc->nout == 1);
-            op_dtypes[0] = op_dtypes[2] != NULL ? op_dtypes[2] : op_dtypes[1];
-            Py_INCREF(op_dtypes[0]);
-            return promote_and_get_info_and_ufuncimpl(ufunc,
-                    ops, signature, op_dtypes, allow_legacy_promotion, 1);
-        }
     }
 
     /*
@@ -707,6 +784,11 @@ promote_and_get_info_and_ufuncimpl(PyUFuncObject *ufunc,
             return NULL;
         }
         else if (info != NULL) {
+            /* Add result to the cache using the original types: */
+            if (PyArrayIdentityHash_SetItem(ufunc->_dispatch_cache,
+                    (PyObject **)op_dtypes, info, 0) < 0) {
+                return NULL;
+            }
             return info;
         }
     }
@@ -726,13 +808,53 @@ promote_and_get_info_and_ufuncimpl(PyUFuncObject *ufunc,
     PyArray_DTypeMeta *new_op_dtypes[NPY_MAXARGS] = {NULL};
     int cacheable = 1;  /* TODO: only the comparison deprecation needs this */
     if (legacy_promote_using_legacy_type_resolver(ufunc,
-            ops, signature, new_op_dtypes, &cacheable) < 0) {
+            ops, signature, new_op_dtypes, &cacheable, NPY_FALSE) < 0) {
         return NULL;
     }
     info = promote_and_get_info_and_ufuncimpl(ufunc,
-            ops, signature, new_op_dtypes, NPY_FALSE, cacheable);
+            ops, signature, new_op_dtypes, NPY_FALSE);
+    if (info == NULL) {
+        /*
+         * NOTE: This block exists solely to support numba's DUFuncs which add
+         * new loops dynamically, so our list may get outdated.  Thus, we
+         * have to make sure that the loop exists.
+         *
+         * Before adding a new loop, ensure that it actually exists. There
+         * is a tiny chance that this would not work, but it would require an
+         * extension additionally have a custom loop getter.
+         * This check should ensure a the right error message, but in principle
+         * we could try to call the loop getter here.
+         */
+        char *types = ufunc->types;
+        npy_bool loop_exists = NPY_FALSE;
+        for (int i = 0; i < ufunc->ntypes; ++i) {
+            loop_exists = NPY_TRUE;  /* assume it exists, break if not */
+            for (int j = 0; j < ufunc->nargs; ++j) {
+                if (types[j] != new_op_dtypes[j]->type_num) {
+                    loop_exists = NPY_FALSE;
+                    break;
+                }
+            }
+            if (loop_exists) {
+                break;
+            }
+            types += ufunc->nargs;
+        }
+
+        if (loop_exists) {
+            info = add_and_return_legacy_wrapping_ufunc_loop(
+                    ufunc, new_op_dtypes, 0);
+        }
+    }
+
     for (int i = 0; i < ufunc->nargs; i++) {
-        Py_XDECREF(new_op_dtypes);
+        Py_XDECREF(new_op_dtypes[i]);
+    }
+
+    /* Add this to the cache using the original types: */
+    if (cacheable && PyArrayIdentityHash_SetItem(ufunc->_dispatch_cache,
+            (PyObject **)op_dtypes, info, 0) < 0) {
+        return NULL;
     }
     return info;
 }
@@ -745,6 +867,14 @@ promote_and_get_info_and_ufuncimpl(PyUFuncObject *ufunc,
  * only work with DType (classes/types).  This is because it has to ensure
  * that legacy (value-based promotion) is used when necessary.
  *
+ * NOTE: The machinery here currently ignores output arguments unless
+ *       they are part of the signature.  This slightly limits unsafe loop
+ *       specializations, which is important for the `ensure_reduce_compatible`
+ *       fallback mode.
+ *       To fix this, the caching mechanism (and dispatching) can be extended.
+ *       When/if that happens, the `ensure_reduce_compatible` could be
+ *       deprecated (it should never kick in because promotion kick in first).
+ *
  * @param ufunc The ufunc object, used mainly for the fallback.
  * @param ops The array operands (used only for the fallback).
  * @param signature As input, the DType signature fixed explicitly by the user.
@@ -754,9 +884,21 @@ promote_and_get_info_and_ufuncimpl(PyUFuncObject *ufunc,
  *        either by the `signature` or by an `operand`.
  *        (outputs and the second input can be NULL for reductions).
  *        NOTE: In some cases, the promotion machinery may currently modify
- *        these.
+ *        these including clearing the output.
  * @param force_legacy_promotion If set, we have to use the old type resolution
  *        to implement value-based promotion/casting.
+ * @param promoting_pyscalars Indication that some of the initial inputs were
+ *        int, float, or complex.  In this case weak-scalar promotion is used
+ *        which can lead to a lower result precision even when legacy promotion
+ *        does not kick in: `np.int8(1) + 1` is the example.
+ *        (Legacy promotion is skipped because `np.int8(1)` is also scalar)
+ * @param ensure_reduce_compatible Must be set for reductions, in which case
+ *        the found implementation is checked for reduce-like compatibility.
+ *        If it is *not* compatible and `signature[2] != NULL`, we assume its
+ *        output DType is correct (see NOTE above).
+ *        If removed, promotion may require information about whether this
+ *        is a reduction, so the more likely case is to always keep fixing this
+ *        when necessary, but push down the handling so it can be cached.
  */
 NPY_NO_EXPORT PyArrayMethodObject *
 promote_and_get_ufuncimpl(PyUFuncObject *ufunc,
@@ -764,9 +906,11 @@ promote_and_get_ufuncimpl(PyUFuncObject *ufunc,
         PyArray_DTypeMeta *signature[],
         PyArray_DTypeMeta *op_dtypes[],
         npy_bool force_legacy_promotion,
-        npy_bool allow_legacy_promotion)
+        npy_bool allow_legacy_promotion,
+        npy_bool promoting_pyscalars,
+        npy_bool ensure_reduce_compatible)
 {
-    int nargs = ufunc->nargs;
+    int nin = ufunc->nin, nargs = ufunc->nargs;
 
     /*
      * Get the actual DTypes we operate with by mixing the operand array
@@ -782,9 +926,19 @@ promote_and_get_ufuncimpl(PyUFuncObject *ufunc,
             Py_XSETREF(op_dtypes[i], signature[i]);
             assert(i >= ufunc->nin || !NPY_DT_is_abstract(signature[i]));
         }
+        else if (i >= nin) {
+            /*
+             * We currently just ignore outputs if not in signature, this will
+             * always give the/a correct result (limits registering specialized
+             * loops which include the cast).
+             * (See also comment in resolve_implementation_info.)
+             */
+            Py_CLEAR(op_dtypes[i]);
+        }
     }
 
-    if (force_legacy_promotion) {
+    if (force_legacy_promotion
+            && npy_promotion_state == NPY_USE_LEGACY_PROMOTION) {
         /*
          * We must use legacy promotion for value-based logic. Call the old
          * resolver once up-front to get the "actual" loop dtypes.
@@ -792,13 +946,17 @@ promote_and_get_ufuncimpl(PyUFuncObject *ufunc,
          */
         int cacheable = 1;  /* unused, as we modify the original `op_dtypes` */
         if (legacy_promote_using_legacy_type_resolver(ufunc,
-                ops, signature, op_dtypes, &cacheable) < 0) {
+                ops, signature, op_dtypes, &cacheable, NPY_FALSE) < 0) {
             return NULL;
         }
     }
 
+    /* Pause warnings and always use "new" path */
+    int old_promotion_state = npy_promotion_state;
+    npy_promotion_state = NPY_USE_WEAK_PROMOTION;
     PyObject *info = promote_and_get_info_and_ufuncimpl(ufunc,
-            ops, signature, op_dtypes, allow_legacy_promotion, NPY_TRUE);
+            ops, signature, op_dtypes, allow_legacy_promotion);
+    npy_promotion_state = old_promotion_state;
 
     if (info == NULL) {
         if (!PyErr_Occurred()) {
@@ -808,16 +966,60 @@ promote_and_get_ufuncimpl(PyUFuncObject *ufunc,
     }
 
     PyArrayMethodObject *method = (PyArrayMethodObject *)PyTuple_GET_ITEM(info, 1);
-
-    /* Fill `signature` with final DTypes used by the ArrayMethod/inner-loop */
     PyObject *all_dtypes = PyTuple_GET_ITEM(info, 0);
+
+    /* If necessary, check if the old result would have been different */
+    if (NPY_UNLIKELY(npy_promotion_state == NPY_USE_WEAK_PROMOTION_AND_WARN)
+            && (force_legacy_promotion || promoting_pyscalars)
+            && npy_give_promotion_warnings()) {
+        PyArray_DTypeMeta *check_dtypes[NPY_MAXARGS];
+        for (int i = 0; i < nargs; i++) {
+            check_dtypes[i] = (PyArray_DTypeMeta *)PyTuple_GET_ITEM(
+                    all_dtypes, i);
+        }
+        /* Before calling to the legacy promotion, pretend that is the state: */
+        npy_promotion_state = NPY_USE_LEGACY_PROMOTION;
+        int res = legacy_promote_using_legacy_type_resolver(ufunc,
+                ops, signature, check_dtypes, NULL, NPY_TRUE);
+        /* Reset the promotion state: */
+        npy_promotion_state = NPY_USE_WEAK_PROMOTION_AND_WARN;
+        if (res < 0) {
+            return NULL;
+        }
+    }
+
+    /*
+     * In certain cases (only the logical ufuncs really), the loop we found may
+     * not be reduce-compatible.  Since the machinery can't distinguish a
+     * reduction with an output from a normal ufunc call, we have to assume
+     * the result DType is correct and force it for the input (if not forced
+     * already).
+     * NOTE: This does assume that all loops are "safe" see the NOTE in this
+     *       comment.  That could be relaxed, in which case we may need to
+     *       cache if a call was for a reduction.
+     */
+    if (ensure_reduce_compatible && signature[0] == NULL &&
+            PyTuple_GET_ITEM(all_dtypes, 0) != PyTuple_GET_ITEM(all_dtypes, 2)) {
+        signature[0] = (PyArray_DTypeMeta *)PyTuple_GET_ITEM(all_dtypes, 2);
+        Py_INCREF(signature[0]);
+        return promote_and_get_ufuncimpl(ufunc,
+                ops, signature, op_dtypes,
+                force_legacy_promotion, allow_legacy_promotion,
+                promoting_pyscalars, NPY_FALSE);
+    }
+
     for (int i = 0; i < nargs; i++) {
         if (signature[i] == NULL) {
             signature[i] = (PyArray_DTypeMeta *)PyTuple_GET_ITEM(all_dtypes, i);
             Py_INCREF(signature[i]);
         }
-        else {
-            assert((PyObject *)signature[i] == PyTuple_GET_ITEM(all_dtypes, i));
+        else if ((PyObject *)signature[i] != PyTuple_GET_ITEM(all_dtypes, i)) {
+            /*
+             * If signature is forced the cache may contain an incompatible
+             * loop found via promotion (signature not enforced).  Reject it.
+             */
+            raise_no_loop_found_error(ufunc, (PyObject **)op_dtypes);
+            return NULL;
         }
     }
 
@@ -825,6 +1027,105 @@ promote_and_get_ufuncimpl(PyUFuncObject *ufunc,
 }
 
 
+/*
+ * Generic promoter used by as a final fallback on ufuncs.  Most operations are
+ * homogeneous, so we can try to find the homogeneous dtype on the inputs
+ * and use that.
+ * We need to special case the reduction case, where op_dtypes[0] == NULL
+ * is possible.
+ */
+NPY_NO_EXPORT int
+default_ufunc_promoter(PyUFuncObject *ufunc,
+        PyArray_DTypeMeta *op_dtypes[], PyArray_DTypeMeta *signature[],
+        PyArray_DTypeMeta *new_op_dtypes[])
+{
+    /* If nin < 2 promotion is a no-op, so it should not be registered */
+    assert(ufunc->nin > 1);
+    if (op_dtypes[0] == NULL) {
+        assert(ufunc->nin == 2 && ufunc->nout == 1);  /* must be reduction */
+        Py_INCREF(op_dtypes[1]);
+        new_op_dtypes[0] = op_dtypes[1];
+        Py_INCREF(op_dtypes[1]);
+        new_op_dtypes[1] = op_dtypes[1];
+        Py_INCREF(op_dtypes[1]);
+        new_op_dtypes[2] = op_dtypes[1];
+        return 0;
+    }
+    PyArray_DTypeMeta *common = NULL;
+    /*
+     * If a signature is used and homogeneous in its outputs use that
+     * (Could/should likely be rather applied to inputs also, although outs
+     * only could have some advantage and input dtypes are rarely enforced.)
+     */
+    for (int i = ufunc->nin; i < ufunc->nargs; i++) {
+        if (signature[i] != NULL) {
+            if (common == NULL) {
+                Py_INCREF(signature[i]);
+                common = signature[i];
+            }
+            else if (common != signature[i]) {
+                Py_CLEAR(common);  /* Not homogeneous, unset common */
+                break;
+            }
+        }
+    }
+    /* Otherwise, use the common DType of all input operands */
+    if (common == NULL) {
+        common = PyArray_PromoteDTypeSequence(ufunc->nin, op_dtypes);
+        if (common == NULL) {
+            if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+                PyErr_Clear();  /* Do not propagate normal promotion errors */
+            }
+            return -1;
+        }
+    }
+
+    for (int i = 0; i < ufunc->nargs; i++) {
+        PyArray_DTypeMeta *tmp = common;
+        if (signature[i]) {
+            tmp = signature[i];  /* never replace a fixed one. */
+        }
+        Py_INCREF(tmp);
+        new_op_dtypes[i] = tmp;
+    }
+    for (int i = ufunc->nin; i < ufunc->nargs; i++) {
+        Py_XINCREF(op_dtypes[i]);
+        new_op_dtypes[i] = op_dtypes[i];
+    }
+
+    Py_DECREF(common);
+    return 0;
+}
+
+
+/*
+ * In some cases, we assume that there will only ever be object loops,
+ * and the object loop should *always* be chosen.
+ * (in those cases more specific loops should not really be registered, but
+ * we do not check that.)
+ *
+ * We default to this for "old-style" ufuncs which have exactly one loop
+ * consisting only of objects (during registration time, numba mutates this
+ * but presumably).
+ */
+NPY_NO_EXPORT int
+object_only_ufunc_promoter(PyUFuncObject *ufunc,
+        PyArray_DTypeMeta *NPY_UNUSED(op_dtypes[]),
+        PyArray_DTypeMeta *signature[],
+        PyArray_DTypeMeta *new_op_dtypes[])
+{
+    PyArray_DTypeMeta *object_DType = PyArray_DTypeFromTypeNum(NPY_OBJECT);
+
+    for (int i = 0; i < ufunc->nargs; i++) {
+        if (signature[i] == NULL) {
+            Py_INCREF(object_DType);
+            new_op_dtypes[i] = object_DType;
+        }
+    }
+    Py_DECREF(object_DType);
+    return 0;
+}
+
 /*
  * Special promoter for the logical ufuncs.  The logical ufuncs can always
  * use the ??->? and still get the correct output (as long as the output
@@ -843,6 +1144,17 @@ logical_ufunc_promoter(PyUFuncObject *NPY_UNUSED(ufunc),
      */
     int force_object = 0;
 
+    if (signature[0] == NULL && signature[1] == NULL
+            && signature[2] != NULL && signature[2]->type_num != NPY_BOOL) {
+        /* bail out, this is _only_ to give future/deprecation warning! */
+        return -1;
+    }
+    if ((op_dtypes[0] != NULL && PyTypeNum_ISSTRING(op_dtypes[0]->type_num))
+            || PyTypeNum_ISSTRING(op_dtypes[1]->type_num)) {
+        /* bail out on strings: currently casting them to bool is too weird */
+        return -1;
+    }
+
     for (int i = 0; i < 3; i++) {
         PyArray_DTypeMeta *item;
         if (signature[i] != NULL) {
@@ -913,4 +1225,3 @@ install_logical_ufunc_promoter(PyObject *ufunc)
 
     return PyUFunc_AddLoop((PyUFuncObject *)ufunc, info, 0);
 }
-
diff --git a/numpy/core/src/umath/dispatching.h b/numpy/core/src/umath/dispatching.h
index 2f314615dd5e..513b50d75341 100644
--- a/numpy/core/src/umath/dispatching.h
+++ b/numpy/core/src/umath/dispatching.h
@@ -6,6 +6,9 @@
 #include 
 #include "array_method.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 typedef int promoter_function(PyUFuncObject *ufunc,
         PyArray_DTypeMeta *op_dtypes[], PyArray_DTypeMeta *signature[],
@@ -14,20 +17,39 @@ typedef int promoter_function(PyUFuncObject *ufunc,
 NPY_NO_EXPORT int
 PyUFunc_AddLoop(PyUFuncObject *ufunc, PyObject *info, int ignore_duplicate);
 
+NPY_NO_EXPORT int
+PyUFunc_AddLoopFromSpec(PyObject *ufunc, PyArrayMethod_Spec *spec);
+
 NPY_NO_EXPORT PyArrayMethodObject *
 promote_and_get_ufuncimpl(PyUFuncObject *ufunc,
         PyArrayObject *const ops[],
         PyArray_DTypeMeta *signature[],
         PyArray_DTypeMeta *op_dtypes[],
         npy_bool force_legacy_promotion,
-        npy_bool allow_legacy_promotion);
+        npy_bool allow_legacy_promotion,
+        npy_bool promote_pyscalars,
+        npy_bool ensure_reduce_compatible);
 
 NPY_NO_EXPORT PyObject *
 add_and_return_legacy_wrapping_ufunc_loop(PyUFuncObject *ufunc,
         PyArray_DTypeMeta *operation_dtypes[], int ignore_duplicate);
 
+NPY_NO_EXPORT int
+default_ufunc_promoter(PyUFuncObject *ufunc,
+        PyArray_DTypeMeta *op_dtypes[], PyArray_DTypeMeta *signature[],
+        PyArray_DTypeMeta *new_op_dtypes[]);
+
+NPY_NO_EXPORT int
+object_only_ufunc_promoter(PyUFuncObject *ufunc,
+        PyArray_DTypeMeta *NPY_UNUSED(op_dtypes[]),
+        PyArray_DTypeMeta *signature[],
+        PyArray_DTypeMeta *new_op_dtypes[]);
+
 NPY_NO_EXPORT int
 install_logical_ufunc_promoter(PyObject *ufunc);
 
+#ifdef __cplusplus
+}
+#endif
 
 #endif  /*_NPY_DISPATCHING_H */
diff --git a/numpy/core/src/umath/extobj.c b/numpy/core/src/umath/extobj.c
index 6b9a27e2621a..893429107f77 100644
--- a/numpy/core/src/umath/extobj.c
+++ b/numpy/core/src/umath/extobj.c
@@ -266,6 +266,33 @@ _extract_pyvals(PyObject *ref, const char *name, int *bufsize,
     return 0;
 }
 
+/*
+ * Handler which uses the default `np.errstate` given that `fpe_errors` is
+ * already set.  `fpe_errors` is typically the (nonzero) result of
+ * `npy_get_floatstatus_barrier`.
+ *
+ * Returns -1 on failure (an error was raised) and 0 on success.
+ */
+NPY_NO_EXPORT int
+PyUFunc_GiveFloatingpointErrors(const char *name, int fpe_errors)
+{
+    int bufsize, errmask;
+    PyObject *errobj;
+
+    if (PyUFunc_GetPyValues((char *)name, &bufsize, &errmask,
+                            &errobj) < 0) {
+        return -1;
+    }
+    int first = 1;
+    if (PyUFunc_handlefperr(errmask, errobj, fpe_errors, &first)) {
+        Py_XDECREF(errobj);
+        return -1;
+    }
+    Py_XDECREF(errobj);
+    return 0;
+}
+
+
 /*
  * check the floating point status
  *  - errmask: mask of status to check
diff --git a/numpy/core/src/umath/fast_loop_macros.h b/numpy/core/src/umath/fast_loop_macros.h
index 4a36c9721879..430033d31474 100644
--- a/numpy/core/src/umath/fast_loop_macros.h
+++ b/numpy/core/src/umath/fast_loop_macros.h
@@ -10,6 +10,8 @@
 #ifndef _NPY_UMATH_FAST_LOOP_MACROS_H_
 #define _NPY_UMATH_FAST_LOOP_MACROS_H_
 
+#include 
+
 /*
  * MAX_STEP_SIZE is used to determine if we need to use SIMD version of the ufunc.
  * Very large step size can be as slow as processing it using scalar. The
@@ -99,10 +101,20 @@ abs_ptrdiff(char *a, char *b)
 
 #define IS_OUTPUT_CONT(tout) (steps[1] == sizeof(tout))
 
-#define IS_BINARY_REDUCE ((args[0] == args[2])\
+/*
+ * Make sure dimensions is non-zero with an assert, to allow subsequent code
+ * to ignore problems of accessing invalid memory
+ */
+
+#define IS_BINARY_REDUCE (assert(dimensions[0] != 0), \
+        (args[0] == args[2])\
         && (steps[0] == steps[2])\
         && (steps[0] == 0))
 
+/* input contiguous (for binary reduces only) */
+#define IS_BINARY_REDUCE_INPUT_CONT(tin) (assert(dimensions[0] != 0), \
+         steps[1] == sizeof(tin))
+
 /* binary loop input and output contiguous */
 #define IS_BINARY_CONT(tin, tout) (steps[0] == sizeof(tin) && \
                                    steps[1] == sizeof(tin) && \
@@ -252,6 +264,34 @@ abs_ptrdiff(char *a, char *b)
     TYPE io1 = *(TYPE *)iop1; \
     BINARY_REDUCE_LOOP_INNER
 
+/*
+ * op should be the code working on `TYPE in2` and
+ * reading/storing the result in `TYPE *io1`
+ */
+#define BASE_BINARY_REDUCE_LOOP(TYPE, op) \
+    BINARY_REDUCE_LOOP_INNER { \
+        const TYPE in2 = *(TYPE *)ip2; \
+        op; \
+    }
+
+#define BINARY_REDUCE_LOOP_FAST_INNER(TYPE, op)\
+    /* condition allows compiler to optimize the generic macro */ \
+    if(IS_BINARY_REDUCE_INPUT_CONT(TYPE)) { \
+        BASE_BINARY_REDUCE_LOOP(TYPE, op) \
+    } \
+    else { \
+        BASE_BINARY_REDUCE_LOOP(TYPE, op) \
+    }
+
+#define BINARY_REDUCE_LOOP_FAST(TYPE, op)\
+    do { \
+        char *iop1 = args[0]; \
+        TYPE io1 = *(TYPE *)iop1; \
+        BINARY_REDUCE_LOOP_FAST_INNER(TYPE, op); \
+        *((TYPE *)iop1) = io1; \
+    } \
+    while (0)
+
 #define IS_BINARY_STRIDE_ONE(esize, vsize) \
     ((steps[0] == esize) && \
      (steps[1] == esize) && \
@@ -338,19 +378,6 @@ abs_ptrdiff(char *a, char *b)
 
 #undef abs_ptrdiff
 
-#define IS_BLOCKABLE_BINARY_BOOL(esize, vsize) \
-    (steps[0] == (esize) && steps[0] == steps[1] && steps[2] == (1) && \
-     npy_is_aligned(args[1], (esize)) && \
-     npy_is_aligned(args[0], (esize)))
-
-#define IS_BLOCKABLE_BINARY_SCALAR1_BOOL(esize, vsize) \
-    (steps[0] == 0 && steps[1] == (esize) && steps[2] == (1) && \
-     npy_is_aligned(args[1], (esize)))
-
-#define IS_BLOCKABLE_BINARY_SCALAR2_BOOL(esize, vsize) \
-    (steps[0] == (esize) && steps[1] == 0 && steps[2] == (1) && \
-     npy_is_aligned(args[0], (esize)))
-
 /* align var to alignment */
 #define LOOP_BLOCK_ALIGN_VAR(var, type, alignment)\
     npy_intp i, peel = npy_aligned_block_offset(var, sizeof(type),\
diff --git a/numpy/core/src/umath/legacy_array_method.c b/numpy/core/src/umath/legacy_array_method.c
index a423823d49af..56ac96598690 100644
--- a/numpy/core/src/umath/legacy_array_method.c
+++ b/numpy/core/src/umath/legacy_array_method.c
@@ -103,7 +103,8 @@ NPY_NO_EXPORT NPY_CASTING
 wrapped_legacy_resolve_descriptors(PyArrayMethodObject *NPY_UNUSED(self),
         PyArray_DTypeMeta *NPY_UNUSED(dtypes[]),
         PyArray_Descr *NPY_UNUSED(given_descrs[]),
-        PyArray_Descr *NPY_UNUSED(loop_descrs[]))
+        PyArray_Descr *NPY_UNUSED(loop_descrs[]),
+        npy_intp *NPY_UNUSED(view_offset))
 {
     PyErr_SetString(PyExc_RuntimeError,
             "cannot use legacy wrapping ArrayMethod without calling the ufunc "
@@ -121,14 +122,45 @@ simple_legacy_resolve_descriptors(
         PyArrayMethodObject *method,
         PyArray_DTypeMeta **dtypes,
         PyArray_Descr **given_descrs,
-        PyArray_Descr **output_descrs)
+        PyArray_Descr **output_descrs,
+        npy_intp *NPY_UNUSED(view_offset))
 {
+    int i = 0;
     int nin = method->nin;
     int nout = method->nout;
 
-    for (int i = 0; i < nin + nout; i++) {
+    if (nin == 2 && nout == 1 && given_descrs[2] != NULL
+            && dtypes[0] == dtypes[2]) {
+        /*
+         * Could be a reduction, which requires `descr[0] is descr[2]`
+         * (identity) at least currently. This is because `op[0] is op[2]`.
+         * (If the output descriptor is not passed, the below works.)
+         */
+        output_descrs[2] = NPY_DT_CALL_ensure_canonical(given_descrs[2]);
+        if (output_descrs[2] == NULL) {
+            Py_CLEAR(output_descrs[2]);
+            return -1;
+        }
+        Py_INCREF(output_descrs[2]);
+        output_descrs[0] = output_descrs[2];
+        if (dtypes[1] == dtypes[2]) {
+            /* Same for the second one (accumulation is stricter) */
+            Py_INCREF(output_descrs[2]);
+            output_descrs[1] = output_descrs[2];
+        }
+        else {
+            output_descrs[1] = NPY_DT_CALL_ensure_canonical(given_descrs[1]);
+            if (output_descrs[1] == NULL) {
+                i = 2;
+                goto fail;
+            }
+        }
+        return NPY_NO_CASTING;
+    }
+
+    for (; i < nin + nout; i++) {
         if (given_descrs[i] != NULL) {
-            output_descrs[i] = ensure_dtype_nbo(given_descrs[i]);
+            output_descrs[i] = NPY_DT_CALL_ensure_canonical(given_descrs[i]);
         }
         else if (dtypes[i] == dtypes[0] && i > 0) {
             /* Preserve metadata from the first operand if same dtype */
@@ -146,7 +178,7 @@ simple_legacy_resolve_descriptors(
     return NPY_NO_CASTING;
 
   fail:
-    for (int i = 0; i < nin + nout; i++) {
+    for (; i >= 0; i--) {
         Py_CLEAR(output_descrs[i]);
     }
     return -1;
@@ -160,7 +192,7 @@ simple_legacy_resolve_descriptors(
 NPY_NO_EXPORT int
 get_wrapped_legacy_ufunc_loop(PyArrayMethod_Context *context,
         int aligned, int move_references,
-        npy_intp *NPY_UNUSED(strides),
+        const npy_intp *NPY_UNUSED(strides),
         PyArrayMethod_StridedLoop **out_loop,
         NpyAuxData **out_transferdata,
         NPY_ARRAYMETHOD_FLAGS *flags)
@@ -194,6 +226,10 @@ get_wrapped_legacy_ufunc_loop(PyArrayMethod_Context *context,
     *out_loop = &generic_wrapped_legacy_loop;
     *out_transferdata = get_new_loop_data(
             loop, user_data, (*flags & NPY_METH_REQUIRES_PYAPI) != 0);
+    if (*out_transferdata == NULL) {
+        PyErr_NoMemory();
+        return -1;
+    }
     return 0;
 }
 
@@ -261,10 +297,10 @@ PyArray_NewLegacyWrappingArrayMethod(PyUFuncObject *ufunc,
         .name = method_name,
         .nin = ufunc->nin,
         .nout = ufunc->nout,
-        .dtypes = signature,
+        .casting = NPY_NO_CASTING,
         .flags = flags,
+        .dtypes = signature,
         .slots = slots,
-        .casting = NPY_NO_CASTING,
     };
 
     PyBoundArrayMethodObject *bound_res = PyArrayMethod_FromSpec_int(&spec, 1);
diff --git a/numpy/core/src/umath/legacy_array_method.h b/numpy/core/src/umath/legacy_array_method.h
index 0dec1fb3a485..498fb1aa27c2 100644
--- a/numpy/core/src/umath/legacy_array_method.h
+++ b/numpy/core/src/umath/legacy_array_method.h
@@ -20,14 +20,14 @@ PyArray_NewLegacyWrappingArrayMethod(PyUFuncObject *ufunc,
 NPY_NO_EXPORT int
 get_wrapped_legacy_ufunc_loop(PyArrayMethod_Context *context,
         int aligned, int move_references,
-        npy_intp *NPY_UNUSED(strides),
+        const npy_intp *NPY_UNUSED(strides),
         PyArrayMethod_StridedLoop **out_loop,
         NpyAuxData **out_transferdata,
         NPY_ARRAYMETHOD_FLAGS *flags);
 
 NPY_NO_EXPORT NPY_CASTING
 wrapped_legacy_resolve_descriptors(PyArrayMethodObject *,
-        PyArray_DTypeMeta **, PyArray_Descr **, PyArray_Descr **);
+        PyArray_DTypeMeta **, PyArray_Descr **, PyArray_Descr **, npy_intp *);
 
 
 #endif  /*_NPY_LEGACY_ARRAY_METHOD_H */
diff --git a/numpy/core/src/umath/loops.c.src b/numpy/core/src/umath/loops.c.src
index aaa694f34dbb..fe5aa937474d 100644
--- a/numpy/core/src/umath/loops.c.src
+++ b/numpy/core/src/umath/loops.c.src
@@ -214,6 +214,8 @@ PyUFunc_O_O(char **args, npy_intp const *dimensions, npy_intp const *steps, void
     UNARY_LOOP {
         PyObject *in1 = *(PyObject **)ip1;
         PyObject **out = (PyObject **)op1;
+        /* We allow NULL, but try to guarantee non-NULL to downstream */
+        assert(in1 != NULL);
         PyObject *ret = f(in1 ? in1 : Py_None);
         if (ret == NULL) {
             return;
@@ -231,6 +233,8 @@ PyUFunc_O_O_method(char **args, npy_intp const *dimensions, npy_intp const *step
     UNARY_LOOP {
         PyObject *in1 = *(PyObject **)ip1;
         PyObject **out = (PyObject **)op1;
+        /* We allow NULL, but try to guarantee non-NULL to downstream */
+        assert(in1 != NULL);
         PyObject *ret, *func;
         func = PyObject_GetAttrString(in1 ? in1 : Py_None, meth);
         if (func != NULL && !PyCallable_Check(func)) {
@@ -268,6 +272,9 @@ PyUFunc_OO_O(char **args, npy_intp const *dimensions, npy_intp const *steps, voi
         PyObject *in1 = *(PyObject **)ip1;
         PyObject *in2 = *(PyObject **)ip2;
         PyObject **out = (PyObject **)op1;
+        /* We allow NULL, but try to guarantee non-NULL to downstream */
+        assert(in1 != NULL);
+        assert(in2 != NULL);
         PyObject *ret = f(in1 ? in1 : Py_None, in2 ? in2 : Py_None);
         if (ret == NULL) {
             return;
@@ -286,6 +293,10 @@ PyUFunc_OOO_O(char **args, npy_intp const *dimensions, npy_intp const *steps, vo
         PyObject *in2 = *(PyObject **)ip2;
         PyObject *in3 = *(PyObject **)ip3;
         PyObject **out = (PyObject **)op1;
+        /* We allow NULL, but try to guarantee non-NULL to downstream */
+        assert(in1 != NULL);
+        assert(in2 != NULL);
+        assert(in3 != NULL);
         PyObject *ret = f(
             in1 ? in1 : Py_None,
             in2 ? in2 : Py_None,
@@ -308,6 +319,9 @@ PyUFunc_OO_O_method(char **args, npy_intp const *dimensions, npy_intp const *ste
         PyObject *in1 = *(PyObject **)ip1;
         PyObject *in2 = *(PyObject **)ip2;
         PyObject **out = (PyObject **)op1;
+        /* We allow NULL, but try to guarantee non-NULL to downstream */
+        assert(in1 != NULL);
+        assert(in2 != NULL);
         PyObject *ret = PyObject_CallMethod(in1 ? in1 : Py_None,
                                             meth, "(O)", in2);
         if (ret == NULL) {
@@ -349,6 +363,8 @@ PyUFunc_On_Om(char **args, npy_intp const *dimensions, npy_intp const *steps, vo
         }
         for(j = 0; j < nin; j++) {
             in = *((PyObject **)ptrs[j]);
+            /* We allow NULL, but try to guarantee non-NULL to downstream */
+            assert(in != NULL);
             if (in == NULL) {
                 in = Py_None;
             }
@@ -400,23 +416,6 @@ PyUFunc_On_Om(char **args, npy_intp const *dimensions, npy_intp const *steps, vo
  *****************************************************************************
  */
 
-/**begin repeat
- * #kind = equal, not_equal, greater, greater_equal, less, less_equal#
- * #OP =  ==, !=, >, >=, <, <=#
- **/
-
-NPY_NO_EXPORT void
-BOOL_@kind@(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func))
-{
-    BINARY_LOOP {
-        npy_bool in1 = *((npy_bool *)ip1) != 0;
-        npy_bool in2 = *((npy_bool *)ip2) != 0;
-        *((npy_bool *)op1)= in1 @OP@ in2;
-    }
-}
-/**end repeat**/
-
-
 /**begin repeat
  * #kind = logical_and, logical_or#
  * #OP =  &&, ||#
@@ -572,7 +571,6 @@ NPY_NO_EXPORT void
 
 /**begin repeat1
  * #isa = , _avx2#
- * #ISA = , AVX2#
  * #CHK = 1, defined(HAVE_ATTRIBUTE_TARGET_AVX2)#
  * #ATTR = , NPY_GCC_TARGET_AVX2#
  */
@@ -636,10 +634,7 @@ NPY_NO_EXPORT NPY_GCC_OPT_3 @ATTR@ void
 @TYPE@_@kind@@isa@(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func))
 {
     if (IS_BINARY_REDUCE) {
-        BINARY_REDUCE_LOOP(@type@) {
-            io1 @OP@= *(@type@ *)ip2;
-        }
-        *((@type@ *)iop1) = io1;
+        BINARY_REDUCE_LOOP_FAST(@type@, io1 @OP@= in2);
     }
     else {
         BINARY_LOOP_FAST(@type@, @type@, *out = in1 @OP@ in2);
@@ -662,6 +657,7 @@ NPY_NO_EXPORT NPY_GCC_OPT_3 @ATTR@ void
 #define INT_left_shift_needs_clear_floatstatus
 #define UINT_left_shift_needs_clear_floatstatus
 
+#if @CHK@
 NPY_NO_EXPORT NPY_GCC_OPT_3 void
 @TYPE@_left_shift@isa@(char **args, npy_intp const *dimensions, npy_intp const *steps,
                   void *NPY_UNUSED(func))
@@ -674,10 +670,12 @@ NPY_NO_EXPORT NPY_GCC_OPT_3 void
     npy_clear_floatstatus_barrier((char*)dimensions);
 #endif
 }
+#endif
 
 #undef INT_left_shift_needs_clear_floatstatus
 #undef UINT_left_shift_needs_clear_floatstatus
 
+#if @CHK@
 NPY_NO_EXPORT
 #ifndef NPY_DO_NOT_OPTIMIZE_@TYPE@_right_shift
 NPY_GCC_OPT_3
@@ -688,12 +686,11 @@ void
 {
     BINARY_LOOP_FAST(@type@, @type@, *out = npy_rshift@c@(in1, in2));
 }
-
+#endif
 
 /**begin repeat2
- * #kind = equal, not_equal, greater, greater_equal, less, less_equal,
- *         logical_and, logical_or#
- * #OP =  ==, !=, >, >=, <, <=, &&, ||#
+ * #kind = logical_and, logical_or#
+ * #OP = &&, ||#
  */
 
 #if @CHK@
@@ -724,32 +721,6 @@ NPY_NO_EXPORT NPY_GCC_OPT_3 @ATTR@ void
 
 /**end repeat1**/
 
-/**begin repeat1
- * #kind = maximum, minimum#
- * #OP =  >, <#
- **/
-
-NPY_NO_EXPORT void
-@TYPE@_@kind@(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func))
-{
-    if (IS_BINARY_REDUCE) {
-        BINARY_REDUCE_LOOP(@type@) {
-            const @type@ in2 = *(@type@ *)ip2;
-            io1 = (io1 @OP@ in2) ? io1 : in2;
-        }
-        *((@type@ *)iop1) = io1;
-    }
-    else {
-        BINARY_LOOP {
-            const @type@ in1 = *(@type@ *)ip1;
-            const @type@ in2 = *(@type@ *)ip2;
-            *((@type@ *)op1) = (in1 @OP@ in2) ? in1 : in2;
-        }
-    }
-}
-
-/**end repeat1**/
-
 NPY_NO_EXPORT void
 @TYPE@_power(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func))
 {
@@ -790,23 +761,6 @@ NPY_NO_EXPORT void
     }
 }
 
-NPY_NO_EXPORT void
-@TYPE@_fmod(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func))
-{
-    BINARY_LOOP {
-        const @type@ in1 = *(@type@ *)ip1;
-        const @type@ in2 = *(@type@ *)ip2;
-        if (in2 == 0) {
-            npy_set_floatstatus_divbyzero();
-            *((@type@ *)op1) = 0;
-        }
-        else {
-            *((@type@ *)op1)= in1 % in2;
-        }
-
-    }
-}
-
 /**begin repeat1
  * #kind = isnan, isinf, isfinite#
  * #func = npy_isnan, npy_isinf, npy_isfinite#
@@ -843,57 +797,6 @@ NPY_NO_EXPORT NPY_GCC_OPT_3 void
     UNARY_LOOP_FAST(@type@, @type@, *out = in > 0 ? 1 : (in < 0 ? -1 : 0));
 }
 
-NPY_NO_EXPORT void
-@TYPE@_remainder(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func))
-{
-    BINARY_LOOP {
-        const @type@ in1 = *(@type@ *)ip1;
-        const @type@ in2 = *(@type@ *)ip2;
-        if (in2 == 0) {
-            npy_set_floatstatus_divbyzero();
-            *((@type@ *)op1) = 0;
-        }
-        else {
-            /* handle mixed case the way Python does */
-            const @type@ rem = in1 % in2;
-            if ((in1 > 0) == (in2 > 0) || rem == 0) {
-                *((@type@ *)op1) = rem;
-            }
-            else {
-                *((@type@ *)op1) = rem + in2;
-            }
-        }
-    }
-}
-
-NPY_NO_EXPORT void
-@TYPE@_divmod(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func))
-{
-    BINARY_LOOP_TWO_OUT {
-        const @type@ in1 = *(@type@ *)ip1;
-        const @type@ in2 = *(@type@ *)ip2;
-        /* see FIXME note for divide above */
-        if (in2 == 0 || (in1 == NPY_MIN_@TYPE@ && in2 == -1)) {
-            npy_set_floatstatus_divbyzero();
-            *((@type@ *)op1) = 0;
-            *((@type@ *)op2) = 0;
-        }
-        else {
-            /* handle mixed case the way Python does */
-            const @type@ quo = in1 / in2;
-            const @type@ rem = in1 % in2;
-            if ((in1 > 0) == (in2 > 0) || rem == 0) {
-                *((@type@ *)op1) = quo;
-                *((@type@ *)op2) = rem;
-            }
-            else {
-                *((@type@ *)op1) = quo - 1;
-                *((@type@ *)op2) = rem + in2;
-            }
-        }
-    }
-}
-
 /**begin repeat1
  * #kind = gcd, lcm#
  **/
@@ -928,40 +831,6 @@ NPY_NO_EXPORT NPY_GCC_OPT_3 void
     UNARY_LOOP_FAST(@type@, @type@, *out = in > 0 ? 1 : 0);
 }
 
-NPY_NO_EXPORT void
-@TYPE@_remainder(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func))
-{
-    BINARY_LOOP {
-        const @type@ in1 = *(@type@ *)ip1;
-        const @type@ in2 = *(@type@ *)ip2;
-        if (in2 == 0) {
-            npy_set_floatstatus_divbyzero();
-            *((@type@ *)op1) = 0;
-        }
-        else {
-            *((@type@ *)op1) = in1 % in2;
-        }
-    }
-}
-
-NPY_NO_EXPORT void
-@TYPE@_divmod(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func))
-{
-    BINARY_LOOP_TWO_OUT {
-        const @type@ in1 = *(@type@ *)ip1;
-        const @type@ in2 = *(@type@ *)ip2;
-        if (in2 == 0) {
-            npy_set_floatstatus_divbyzero();
-            *((@type@ *)op1) = 0;
-            *((@type@ *)op2) = 0;
-        }
-        else {
-            *((@type@ *)op1)= in1/in2;
-            *((@type@ *)op2) = in1 % in2;
-        }
-    }
-}
-
 /**begin repeat1
  * #kind = gcd, lcm#
  **/
@@ -1531,62 +1400,6 @@ TIMEDELTA_mm_qm_divmod(char **args, npy_intp const *dimensions, npy_intp const *
  *****************************************************************************
  */
 
-/**begin repeat
- *  #func = rint, floor, trunc#
- *  #scalarf = npy_rint, npy_floor, npy_trunc#
- */
-
-/**begin repeat1
-*  #TYPE = FLOAT, DOUBLE#
-*  #type = npy_float, npy_double#
-*  #typesub = f, #
-*/
-
-NPY_NO_EXPORT NPY_GCC_OPT_3 void
-@TYPE@_@func@(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(data))
-{
-    UNARY_LOOP {
-        const @type@ in1 = *(@type@ *)ip1;
-        *(@type@ *)op1 = @scalarf@@typesub@(in1);
-    }
-}
-
-
-/**end repeat1**/
-/**end repeat**/
-
-/**begin repeat
- * #isa = avx512f, fma#
- * #ISA = AVX512F, FMA#
- * #CHK = HAVE_ATTRIBUTE_TARGET_AVX512F_WITH_INTRINSICS, HAVE_ATTRIBUTE_TARGET_AVX2_WITH_INTRINSICS#
- */
-
-/**begin repeat1
- *  #TYPE = FLOAT, DOUBLE#
- *  #type = npy_float, npy_double#
- *  #typesub = f, #
- */
-
-/**begin repeat2
- *  #func = rint, floor, trunc#
- *  #scalarf = npy_rint, npy_floor, npy_trunc#
- */
-
-NPY_NO_EXPORT NPY_GCC_OPT_3 void
-@TYPE@_@func@_@isa@(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(data))
-{
-    if (!run_unary_@isa@_@func@_@TYPE@(args, dimensions, steps)) {
-        UNARY_LOOP {
-            const @type@ in1 = *(@type@ *)ip1;
-            *(@type@ *)op1 = @scalarf@@typesub@(in1);
-        }
-    }
-}
-
-/**end repeat2**/
-/**end repeat1**/
-/**end repeat**/
-
 /**begin repeat
  * Float types
  *  #type = npy_float, npy_double, npy_longdouble#
@@ -1595,19 +1408,16 @@ NPY_NO_EXPORT NPY_GCC_OPT_3 void
  *  #C = F, , L#
  */
 /**begin repeat1
- * #kind = equal, not_equal, less, less_equal, greater, greater_equal,
- *        logical_and, logical_or#
- * #OP = ==, !=, <, <=, >, >=, &&, ||#
+ * #kind = logical_and, logical_or#
+ * #OP = &&, ||#
  */
 NPY_NO_EXPORT void
 @TYPE@_@kind@(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func))
 {
-    if (!run_binary_simd_@kind@_@TYPE@(args, dimensions, steps)) {
-        BINARY_LOOP {
-            const @type@ in1 = *(@type@ *)ip1;
-            const @type@ in2 = *(@type@ *)ip2;
-            *((npy_bool *)op1) = in1 @OP@ in2;
-        }
+    BINARY_LOOP {
+        const @type@ in1 = *(@type@ *)ip1;
+        const @type@ in2 = *(@type@ *)ip2;
+        *((npy_bool *)op1) = in1 @OP@ in2;
     }
     npy_clear_floatstatus_barrier((char*)dimensions);
 }
@@ -1640,7 +1450,10 @@ NPY_NO_EXPORT void
 /**begin repeat2
  * #ISA  = , _avx512_skx#
  * #isa  = simd, avx512_skx#
+ * #CHK  = 1, defined(HAVE_ATTRIBUTE_TARGET_AVX512_SKX)#
  **/
+
+#if @CHK@
 NPY_NO_EXPORT void
 @TYPE@_@kind@@ISA@(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func))
 {
@@ -1652,6 +1465,7 @@ NPY_NO_EXPORT void
     }
     npy_clear_floatstatus_barrier((char*)dimensions);
 }
+#endif
 /**end repeat2**/
 /**end repeat1**/
 
@@ -1684,93 +1498,6 @@ NPY_NO_EXPORT void
     }
 }
 
-/**begin repeat1
- * #kind = maximum, minimum#
- * #OP =  >=, <=#
- **/
-NPY_NO_EXPORT void
-@TYPE@_@kind@_avx512f(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func))
-{
-    /*  */
-    if (IS_BINARY_REDUCE) {
-        if (!run_unary_reduce_simd_@kind@_@TYPE@(args, dimensions, steps)) {
-            BINARY_REDUCE_LOOP(@type@) {
-                const @type@ in2 = *(@type@ *)ip2;
-                /* Order of operations important for MSVC 2015 */
-                io1 = (io1 @OP@ in2 || npy_isnan(io1)) ? io1 : in2;
-            }
-            *((@type@ *)iop1) = io1;
-        }
-    }
-    else {
-        if (!run_binary_avx512f_@kind@_@TYPE@(args, dimensions, steps)) {
-            BINARY_LOOP {
-                @type@ in1 = *(@type@ *)ip1;
-                const @type@ in2 = *(@type@ *)ip2;
-                /* Order of operations important for MSVC 2015 */
-                in1 = (in1 @OP@ in2 || npy_isnan(in1)) ? in1 : in2;
-                *((@type@ *)op1) = in1;
-            }
-        }
-    }
-    npy_clear_floatstatus_barrier((char*)dimensions);
-}
-
-NPY_NO_EXPORT void
-@TYPE@_@kind@(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func))
-{
-    /*  */
-    if (IS_BINARY_REDUCE) {
-        if (!run_unary_reduce_simd_@kind@_@TYPE@(args, dimensions, steps)) {
-            BINARY_REDUCE_LOOP(@type@) {
-                const @type@ in2 = *(@type@ *)ip2;
-                /* Order of operations important for MSVC 2015 */
-                io1 = (io1 @OP@ in2 || npy_isnan(io1)) ? io1 : in2;
-            }
-            *((@type@ *)iop1) = io1;
-        }
-    }
-    else {
-        BINARY_LOOP {
-            @type@ in1 = *(@type@ *)ip1;
-            const @type@ in2 = *(@type@ *)ip2;
-            /* Order of operations important for MSVC 2015 */
-            in1 = (in1 @OP@ in2 || npy_isnan(in1)) ? in1 : in2;
-            *((@type@ *)op1) = in1;
-        }
-    }
-    npy_clear_floatstatus_barrier((char*)dimensions);
-}
-/**end repeat1**/
-
-/**begin repeat1
- * #kind = fmax, fmin#
- * #OP =  >=, <=#
- **/
-NPY_NO_EXPORT void
-@TYPE@_@kind@(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func))
-{
-    /*  */
-    if (IS_BINARY_REDUCE) {
-        BINARY_REDUCE_LOOP(@type@) {
-            const @type@ in2 = *(@type@ *)ip2;
-            /* Order of operations important for MSVC 2015 */
-            io1 = (io1 @OP@ in2 || npy_isnan(in2)) ? io1 : in2;
-        }
-        *((@type@ *)iop1) = io1;
-    }
-    else {
-        BINARY_LOOP {
-            const @type@ in1 = *(@type@ *)ip1;
-            const @type@ in2 = *(@type@ *)ip2;
-            /* Order of operations important for MSVC 2015 */
-            *((@type@ *)op1) = (in1 @OP@ in2 || npy_isnan(in2)) ? in1 : in2;
-        }
-    }
-    npy_clear_floatstatus_barrier((char*)dimensions);
-}
-/**end repeat1**/
-
 NPY_NO_EXPORT void
 @TYPE@_floor_divide(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func))
 {
@@ -1928,6 +1655,22 @@ LONGDOUBLE_@kind@(char **args, npy_intp const *dimensions, npy_intp const *steps
 }
 /**end repeat**/
 
+/**begin repeat
+ * #kind = equal, not_equal, less, less_equal, greater, greater_equal#
+ * #OP = ==, !=, <, <=, >, >=#
+ */
+NPY_NO_EXPORT void
+LONGDOUBLE_@kind@(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func))
+{
+    BINARY_LOOP {
+        const npy_longdouble in1 = *(npy_longdouble *)ip1;
+        const npy_longdouble in2 = *(npy_longdouble *)ip2;
+        *((npy_bool *)op1) = in1 @OP@ in2;
+    }
+    npy_clear_floatstatus_barrier((char*)dimensions);
+}
+/**end repeat**/
+
 NPY_NO_EXPORT void
 LONGDOUBLE_reciprocal(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(data))
 {
@@ -2552,7 +2295,7 @@ NPY_NO_EXPORT void
     }
 }
 
-#if @SIMD@
+#if @SIMD@ && defined(HAVE_ATTRIBUTE_TARGET_AVX512F)
 /**begin repeat1
  * arithmetic
  * #kind = conjugate, square, absolute#
diff --git a/numpy/core/src/umath/loops.h.src b/numpy/core/src/umath/loops.h.src
index 081ca99571a1..424e204c1890 100644
--- a/numpy/core/src/umath/loops.h.src
+++ b/numpy/core/src/umath/loops.h.src
@@ -22,16 +22,25 @@
 #define BOOL_fmax BOOL_maximum
 #define BOOL_fmin BOOL_minimum
 
-
 /*
  *****************************************************************************
  **                             BOOLEAN LOOPS                               **
  *****************************************************************************
  */
 
+#ifndef NPY_DISABLE_OPTIMIZATION
+    #include "loops_comparison.dispatch.h"
+#endif
+
+/**begin repeat
+ * #kind = equal, not_equal, greater, greater_equal, less, less_equal#
+ */
+NPY_CPU_DISPATCH_DECLARE(NPY_NO_EXPORT void BOOL_@kind@,
+    (char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func)))
+/**end repeat**/
+
 /**begin repeat
- * #kind = equal, not_equal, greater, greater_equal, less, less_equal,
- *         logical_and, logical_or, absolute, logical_not#
+ * #kind = logical_and, logical_or, absolute, logical_not#
  **/
 NPY_NO_EXPORT void
 BOOL_@kind@(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func));
@@ -61,8 +70,40 @@ BOOL_@kind@(char **args, npy_intp const *dimensions, npy_intp const *steps, void
  * #TYPE = UBYTE, USHORT, UINT, ULONG, ULONGLONG,
            BYTE,  SHORT,  INT,  LONG,  LONGLONG#
  */
- NPY_CPU_DISPATCH_DECLARE(NPY_NO_EXPORT void @TYPE@_divide,
-     (char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func)))
+NPY_CPU_DISPATCH_DECLARE(NPY_NO_EXPORT void @TYPE@_divide,
+    (char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func)))
+/**end repeat**/
+
+#ifndef NPY_DISABLE_OPTIMIZATION
+    #include "loops_modulo.dispatch.h"
+#endif
+
+/**begin repeat
+ * #TYPE = UBYTE, USHORT, UINT, ULONG, ULONGLONG,
+           BYTE,  SHORT,  INT,  LONG,  LONGLONG#
+ */
+/**begin repeat1
+ * #kind = divmod, fmod, remainder#
+ */
+NPY_CPU_DISPATCH_DECLARE(NPY_NO_EXPORT void @TYPE@_@kind@,
+    (char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func)))
+/**end repeat1**/
+/**end repeat**/
+
+#ifndef NPY_DISABLE_OPTIMIZATION
+    #include "loops_comparison.dispatch.h"
+#endif
+
+/**begin repeat
+ * #TYPE = UBYTE, USHORT, UINT, ULONG, ULONGLONG,
+           BYTE,  SHORT,  INT,  LONG,  LONGLONG#
+ */
+/**begin repeat1
+ * #kind = equal, not_equal, greater, greater_equal, less, less_equal#
+ */
+NPY_CPU_DISPATCH_DECLARE(NPY_NO_EXPORT void @TYPE@_@kind@,
+    (char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func)))
+/**end repeat1**/
 /**end repeat**/
 
 /**begin repeat
@@ -119,9 +160,8 @@ NPY_NO_EXPORT void
 /**end repeat3**/
 
 /**begin repeat3
- * #kind = equal, not_equal, greater, greater_equal, less, less_equal,
- *         logical_and, logical_or#
- * #OP =  ==, !=, >, >=, <, <=, &&, ||#
+ * #kind = logical_and, logical_or#
+ * #OP = &&, ||#
  */
 NPY_NO_EXPORT void
 @S@@TYPE@_@kind@@isa@(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func));
@@ -143,21 +183,12 @@ NPY_NO_EXPORT void
 NPY_NO_EXPORT void
 @S@@TYPE@_power(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func));
 
-NPY_NO_EXPORT void
-@S@@TYPE@_fmod(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func));
-
 NPY_NO_EXPORT void
 @S@@TYPE@_absolute(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func));
 
 NPY_NO_EXPORT void
 @S@@TYPE@_sign(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func));
 
-NPY_NO_EXPORT void
-@S@@TYPE@_remainder(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func));
-
-NPY_NO_EXPORT void
-@S@@TYPE@_divmod(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func));
-
 NPY_NO_EXPORT void
 @S@@TYPE@_gcd(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func));
 
@@ -187,7 +218,7 @@ NPY_NO_EXPORT void
  *  #TYPE = FLOAT, DOUBLE#
  */
 /**begin repeat1
- * #kind = ceil, sqrt, absolute, square, reciprocal#
+ * #kind = rint, floor, trunc, ceil, sqrt, absolute, square, reciprocal#
  */
 NPY_CPU_DISPATCH_DECLARE(NPY_NO_EXPORT void @TYPE@_@kind@,
    (char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(data)))
@@ -210,6 +241,21 @@ NPY_CPU_DISPATCH_DECLARE(NPY_NO_EXPORT void @TYPE@_@kind@,
 /**end repeat1**/
 /**end repeat**/
 
+#ifndef NPY_DISABLE_OPTIMIZATION
+    #include "loops_hyperbolic.dispatch.h"
+#endif
+/**begin repeat
+ *  #TYPE = FLOAT, DOUBLE#
+ */
+/**begin repeat1
+ * #func = tanh#
+ */
+NPY_CPU_DISPATCH_DECLARE(NPY_NO_EXPORT void @TYPE@_@func@,
+    (char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func)))
+/**end repeat1**/
+/**end repeat**/
+
+// SVML
 #ifndef NPY_DISABLE_OPTIMIZATION
     #include "loops_umath_fp.dispatch.h"
 #endif
@@ -227,6 +273,15 @@ NPY_CPU_DISPATCH_DECLARE(NPY_NO_EXPORT void @TYPE@_@func@,
 /**end repeat1**/
 /**end repeat**/
 
+/**begin repeat
+ * #func = sin, cos, tan, exp, exp2, log, log2, log10, expm1, log1p, cbrt, arcsin, arccos, arctan, sinh, cosh, tanh, arcsinh, arccosh, arctanh#
+ */
+
+NPY_CPU_DISPATCH_DECLARE(NPY_NO_EXPORT void HALF_@func@,
+    (char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func)))
+
+/**end repeat**/
+
 /**begin repeat
  * #func = sin, cos#
  */
@@ -236,6 +291,19 @@ NPY_CPU_DISPATCH_DECLARE(NPY_NO_EXPORT void DOUBLE_@func@,
 
 /**end repeat**/
 
+/**begin repeat
+ *  #TYPE = FLOAT, DOUBLE#
+ */
+/**begin repeat1
+ * #func = power, arctan2#
+ */
+
+NPY_CPU_DISPATCH_DECLARE(NPY_NO_EXPORT void @TYPE@_@func@,
+    (char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func)))
+
+/**end repeat1**/
+/**end repeat**/
+
 /**begin repeat
  *  #TYPE = FLOAT, DOUBLE#
  */
@@ -274,23 +342,18 @@ NPY_CPU_DISPATCH_DECLARE(NPY_NO_EXPORT void @TYPE@_@kind@, (
 /**end repeat1**/
 /**end repeat**/
 
+#ifndef NPY_DISABLE_OPTIMIZATION
+    #include "loops_comparison.dispatch.h"
+#endif
 /**begin repeat
- *  #func = rint, floor, trunc#
+ *  #TYPE = FLOAT, DOUBLE#
  */
-
 /**begin repeat1
-*  #TYPE = FLOAT, DOUBLE#
-*/
-
-NPY_NO_EXPORT NPY_GCC_OPT_3 void
-@TYPE@_@func@(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(data));
-
-/**begin repeat2
- * #isa = avx512f, fma#
+ * #kind = equal, not_equal, less, less_equal, greater, greater_equal#
  */
-NPY_NO_EXPORT NPY_GCC_OPT_3 void
-@TYPE@_@func@_@isa@(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(data));
-/**end repeat2**/
+NPY_CPU_DISPATCH_DECLARE(NPY_NO_EXPORT void @TYPE@_@kind@, (
+  char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func)
+))
 /**end repeat1**/
 /**end repeat**/
 
@@ -301,7 +364,6 @@ NPY_NO_EXPORT NPY_GCC_OPT_3 void
  *  #C = F, F, , L#
  */
 
-
 /**begin repeat1
  * Arithmetic
  * # kind = add, subtract, multiply, divide#
@@ -312,9 +374,8 @@ NPY_NO_EXPORT void
 /**end repeat1**/
 
 /**begin repeat1
- * #kind = equal, not_equal, less, less_equal, greater, greater_equal,
- *        logical_and, logical_or#
- * #OP = ==, !=, <, <=, >, >=, &&, ||#
+ * #kind = logical_and, logical_or#
+ * #OP = &&, ||#
  */
 NPY_NO_EXPORT void
 @TYPE@_@kind@(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func));
@@ -401,6 +462,16 @@ NPY_NO_EXPORT void
 @TYPE@_ldexp_long(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func));
 /**end repeat**/
 
+/**begin repeat
+ * #TYPE = HALF, LONGDOUBLE#
+ */
+/**begin repeat1
+ * #kind = equal, not_equal, less, less_equal, greater, greater_equal#
+ */
+NPY_NO_EXPORT void
+@TYPE@_@kind@(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func));
+/**end repeat1**/
+/**end repeat**/
 
 /*
  *****************************************************************************
@@ -658,6 +729,43 @@ OBJECT_sign(char **args, npy_intp const *dimensions, npy_intp const *steps, void
 NPY_NO_EXPORT void
 PyUFunc_OOO_O(char **args, npy_intp const *dimensions, npy_intp const *steps, void *func);
 
+/*
+ *****************************************************************************
+ **                            MIN/MAX LOOPS                                **
+ *****************************************************************************
+ */
+
+#ifndef NPY_DISABLE_OPTIMIZATION
+    #include "loops_minmax.dispatch.h"
+#endif
+
+//---------- Integers ----------
+
+/**begin repeat
+ * #TYPE = BYTE, UBYTE, SHORT, USHORT, INT, UINT,
+ *         LONG, ULONG, LONGLONG, ULONGLONG#
+ */
+/**begin repeat1
+ * #kind = maximum, minimum#
+ */
+ NPY_CPU_DISPATCH_DECLARE(NPY_NO_EXPORT void @TYPE@_@kind@,
+   (char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(data)))
+/**end repeat1**/
+/**end repeat**/
+
+//---------- Float ----------
+
+ /**begin repeat
+  * #TYPE = FLOAT, DOUBLE, LONGDOUBLE#
+  */
+/**begin repeat1
+ * #kind = maximum, minimum, fmax, fmin#
+ */
+ NPY_CPU_DISPATCH_DECLARE(NPY_NO_EXPORT void @TYPE@_@kind@,
+   (char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(data)))
+/**end repeat1**/
+/**end repeat**/
+
 /*
  *****************************************************************************
  **                              END LOOPS                                  **
diff --git a/numpy/core/src/umath/loops_arithm_fp.dispatch.c.src b/numpy/core/src/umath/loops_arithm_fp.dispatch.c.src
index 51b167844097..bf8142880aa4 100644
--- a/numpy/core/src/umath/loops_arithm_fp.dispatch.c.src
+++ b/numpy/core/src/umath/loops_arithm_fp.dispatch.c.src
@@ -1,6 +1,7 @@
 /*@targets
  ** $maxopt baseline
  ** sse2 avx2 avx512f
+ ** vx vxe
  **/
 #define _UMATHMODULE
 #define _MULTIARRAYMODULE
@@ -364,7 +365,7 @@ sse2_binary_scalar2_@kind@_@TYPE@(@type@ * op, @type@ * ip1, @type@ * ip2, npy_i
  *  #type = npy_float, npy_double#
  *  #TYPE = FLOAT, DOUBLE#
  *  #sfx = f32, f64#
- *  #CHK =    , _F64#
+ *  #CHK = _F32, _F64#
  */
 #if NPY_SIMD@CHK@
 /**begin repeat1
@@ -444,7 +445,7 @@ simd_binary_scalar2_@kind@_@TYPE@(@type@ * op, @type@ * ip1, @type@ * ip2, npy_i
  *  #type = npy_float, npy_double, npy_longdouble#
  *  #TYPE = FLOAT, DOUBLE, LONGDOUBLE#
  *  #vector = 1, 1, 0#
- *  #VECTOR = NPY_SIMD, NPY_SIMD_F64, 0 #
+ *  #VECTOR = NPY_SIMD_F32, NPY_SIMD_F64, 0 #
  */
 /**begin repeat1
  * Arithmetic
diff --git a/numpy/core/src/umath/loops_arithmetic.dispatch.c.src b/numpy/core/src/umath/loops_arithmetic.dispatch.c.src
index 1ddf7c3b1a6f..5b5f13ad1898 100644
--- a/numpy/core/src/umath/loops_arithmetic.dispatch.c.src
+++ b/numpy/core/src/umath/loops_arithmetic.dispatch.c.src
@@ -1,8 +1,9 @@
 /*@targets
  ** $maxopt baseline
  ** sse2 sse41 avx2 avx512f avx512_skx
- ** vsx2
+ ** vsx2 vsx4
  ** neon
+ ** vx
  **/
 #define _UMATHMODULE
 #define _MULTIARRAYMODULE
@@ -51,13 +52,14 @@ simd_divide_by_scalar_contig_@sfx@(char **args, npy_intp len)
     const npyv_@sfx@x3 divisor = npyv_divisor_@sfx@(scalar);
 
     if (scalar == -1) {
-        npyv_b@len@ noverflow = npyv_cvt_b@len@_@sfx@(npyv_setall_@sfx@(-1));
-        npyv_@sfx@ vzero      = npyv_zero_@sfx@();
+        npyv_b@len@ noverflow  = npyv_cvt_b@len@_@sfx@(npyv_setall_@sfx@(-1));
+        const npyv_@sfx@ vzero = npyv_zero_@sfx@();
+        const npyv_@sfx@ vmin  = npyv_setall_@sfx@(NPY_MIN_INT@len@);
         for (; len >= vstep; len -= vstep, src += vstep, dst += vstep) {
             npyv_@sfx@ a       = npyv_load_@sfx@(src);
             npyv_b@len@ gt_min = npyv_cmpgt_@sfx@(a, npyv_setall_@sfx@(NPY_MIN_INT@len@));
             noverflow          = npyv_and_b@len@(noverflow, gt_min);
-            npyv_@sfx@ neg     = npyv_ifsub_@sfx@(gt_min, vzero, a, vzero);
+            npyv_@sfx@ neg     = npyv_ifsub_@sfx@(gt_min, vzero, a, vmin);
             npyv_store_@sfx@(dst, neg);
         }
 
@@ -66,13 +68,13 @@ simd_divide_by_scalar_contig_@sfx@(char **args, npy_intp len)
             npyv_lanetype_@sfx@ a = *src;
             if (a == NPY_MIN_INT@len@) {
                 raise_err = 1;
-                *dst  = 0;
+                *dst  = NPY_MIN_INT@len@;
             } else {
                 *dst = -a;
             }
         }
         if (raise_err) {
-            npy_set_floatstatus_divbyzero();
+            npy_set_floatstatus_overflow();
         }
     } else {
         for (; len >= vstep; len -= vstep, src += vstep, dst += vstep) {
@@ -128,7 +130,192 @@ simd_divide_by_scalar_contig_@sfx@(char **args, npy_intp len)
     npyv_cleanup();
 }
 /**end repeat**/
+
+#if defined(NPY_HAVE_VSX4)
+
+/**begin repeat
+ * #t = u, s#
+ * #signed = 0, 1#
+ */
+/*
+ * Computes division of 2 8-bit signed/unsigned integer vectors
+ *
+ * As Power10 only supports integer vector division for data of 32 bits or
+ * greater, we have to convert npyv_u8 into 4x npyv_u32, execute the integer
+ * vector division instruction, and then, convert the result back to npyv_u8.
+ */
+NPY_FINLINE npyv_@t@8
+vsx4_div_@t@8(npyv_@t@8 a, npyv_@t@8 b)
+{
+#if @signed@
+    npyv_s16x2 ta, tb;
+    npyv_s32x2 ahi, alo, bhi, blo;
+    ta.val[0] = vec_unpackh(a);
+    ta.val[1] = vec_unpackl(a);
+    tb.val[0] = vec_unpackh(b);
+    tb.val[1] = vec_unpackl(b);
+    ahi.val[0] = vec_unpackh(ta.val[0]);
+    ahi.val[1] = vec_unpackl(ta.val[0]);
+    alo.val[0] = vec_unpackh(ta.val[1]);
+    alo.val[1] = vec_unpackl(ta.val[1]);
+    bhi.val[0] = vec_unpackh(tb.val[0]);
+    bhi.val[1] = vec_unpackl(tb.val[0]);
+    blo.val[0] = vec_unpackh(tb.val[1]);
+    blo.val[1] = vec_unpackl(tb.val[1]);
+#else
+    npyv_u16x2 a_expand = npyv_expand_u16_u8(a);
+    npyv_u16x2 b_expand = npyv_expand_u16_u8(b);
+    npyv_u32x2 ahi = npyv_expand_u32_u16(a_expand.val[0]);
+    npyv_u32x2 alo = npyv_expand_u32_u16(a_expand.val[1]);
+    npyv_u32x2 bhi = npyv_expand_u32_u16(b_expand.val[0]);
+    npyv_u32x2 blo = npyv_expand_u32_u16(b_expand.val[1]);
+#endif
+    npyv_@t@32 v1 = vec_div(ahi.val[0], bhi.val[0]);
+    npyv_@t@32 v2 = vec_div(ahi.val[1], bhi.val[1]);
+    npyv_@t@32 v3 = vec_div(alo.val[0], blo.val[0]);
+    npyv_@t@32 v4 = vec_div(alo.val[1], blo.val[1]);
+    npyv_@t@16 hi = vec_pack(v1, v2);
+    npyv_@t@16 lo = vec_pack(v3, v4);
+    return vec_pack(hi, lo);
+}
+
+NPY_FINLINE npyv_@t@16
+vsx4_div_@t@16(npyv_@t@16 a, npyv_@t@16 b)
+{
+#if @signed@
+    npyv_s32x2 a_expand;
+    npyv_s32x2 b_expand;
+    a_expand.val[0] = vec_unpackh(a);
+    a_expand.val[1] = vec_unpackl(a);
+    b_expand.val[0] = vec_unpackh(b);
+    b_expand.val[1] = vec_unpackl(b);
+#else
+    npyv_u32x2 a_expand = npyv_expand_@t@32_@t@16(a);
+    npyv_u32x2 b_expand = npyv_expand_@t@32_@t@16(b);
 #endif
+    npyv_@t@32 v1 = vec_div(a_expand.val[0], b_expand.val[0]);
+    npyv_@t@32 v2 = vec_div(a_expand.val[1], b_expand.val[1]);
+    return vec_pack(v1, v2);
+}
+
+#define vsx4_div_@t@32 vec_div
+#define vsx4_div_@t@64 vec_div
+/**end repeat**/
+
+/**begin repeat
+ * Unsigned types
+ * #sfx = u8, u16, u32, u64#
+ * #len = 8,  16,  32,  64#
+ */
+static NPY_INLINE void
+vsx4_simd_divide_contig_@sfx@(char **args, npy_intp len)
+{
+    npyv_lanetype_@sfx@ *src1 = (npyv_lanetype_@sfx@ *) args[0];
+    npyv_lanetype_@sfx@ *src2 = (npyv_lanetype_@sfx@ *) args[1];
+    npyv_lanetype_@sfx@ *dst1 = (npyv_lanetype_@sfx@ *) args[2];
+    const npyv_@sfx@ vzero    = npyv_zero_@sfx@();
+    const int vstep           = npyv_nlanes_@sfx@;
+
+    for (; len >= vstep; len -= vstep, src1 += vstep, src2 += vstep,
+         dst1 += vstep) {
+        npyv_@sfx@ a = npyv_load_@sfx@(src1);
+        npyv_@sfx@ b = npyv_load_@sfx@(src2);
+        npyv_@sfx@ c = vsx4_div_@sfx@(a, b);
+        npyv_store_@sfx@(dst1, c);
+        if (NPY_UNLIKELY(vec_any_eq(b, vzero))) {
+            npy_set_floatstatus_divbyzero();
+        }
+    }
+
+    for (; len > 0; --len, ++src1, ++src2, ++dst1) {
+        const npyv_lanetype_@sfx@ a = *src1;
+        const npyv_lanetype_@sfx@ b = *src2;
+        if (NPY_UNLIKELY(b == 0)) {
+            npy_set_floatstatus_divbyzero();
+            *dst1 = 0;
+        } else{
+            *dst1 = a / b;
+        }
+    }
+    npyv_cleanup();
+}
+/**end repeat**/
+
+/**begin repeat
+ * Signed types
+ * #sfx = s8, s16, s32, s64#
+ * #len = 8,  16,  32,  64#
+ */
+static NPY_INLINE void
+vsx4_simd_divide_contig_@sfx@(char **args, npy_intp len)
+{
+    npyv_lanetype_@sfx@ *src1 = (npyv_lanetype_@sfx@ *) args[0];
+    npyv_lanetype_@sfx@ *src2 = (npyv_lanetype_@sfx@ *) args[1];
+    npyv_lanetype_@sfx@ *dst1 = (npyv_lanetype_@sfx@ *) args[2];
+    const npyv_@sfx@ vneg_one = npyv_setall_@sfx@(-1);
+    const npyv_@sfx@ vzero    = npyv_zero_@sfx@();
+    const npyv_@sfx@ vmin     = npyv_setall_@sfx@(NPY_MIN_INT@len@);
+    npyv_b@len@ warn_zero     = npyv_cvt_b@len@_@sfx@(npyv_zero_@sfx@());
+    npyv_b@len@ warn_overflow = npyv_cvt_b@len@_@sfx@(npyv_zero_@sfx@());
+    const int vstep           = npyv_nlanes_@sfx@;
+
+    for (; len >= vstep; len -= vstep, src1 += vstep, src2 += vstep,
+         dst1 += vstep) {
+        npyv_@sfx@ a   = npyv_load_@sfx@(src1);
+        npyv_@sfx@ b   = npyv_load_@sfx@(src2);
+        npyv_@sfx@ quo = vsx4_div_@sfx@(a, b);
+        npyv_@sfx@ rem = npyv_sub_@sfx@(a, vec_mul(b, quo));
+        // (b == 0 || (a == NPY_MIN_INT@len@ && b == -1))
+        npyv_b@len@ bzero    = npyv_cmpeq_@sfx@(b, vzero);
+        npyv_b@len@ amin     = npyv_cmpeq_@sfx@(a, vmin);
+        npyv_b@len@ bneg_one = npyv_cmpeq_@sfx@(b, vneg_one);
+        npyv_b@len@ overflow = npyv_and_@sfx@(bneg_one, amin);
+                   warn_zero = npyv_or_@sfx@(bzero, warn_zero);
+               warn_overflow = npyv_or_@sfx@(overflow, warn_overflow);
+        // handle mixed case the way Python does
+        // ((a > 0) == (b > 0) || rem == 0)
+        npyv_b@len@ a_gt_zero  = npyv_cmpgt_@sfx@(a, vzero);
+        npyv_b@len@ b_gt_zero  = npyv_cmpgt_@sfx@(b, vzero);
+        npyv_b@len@ ab_eq_cond = npyv_cmpeq_@sfx@(a_gt_zero, b_gt_zero);
+        npyv_b@len@ rem_zero   = npyv_cmpeq_@sfx@(rem, vzero);
+        npyv_b@len@ or         = npyv_or_@sfx@(ab_eq_cond, rem_zero);
+        npyv_@sfx@ to_sub = npyv_select_@sfx@(or, vzero, vneg_one);
+                      quo = npyv_add_@sfx@(quo, to_sub);
+                      // Divide by zero
+                      quo = npyv_select_@sfx@(bzero, vzero, quo);
+                      // Overflow
+                      quo = npyv_select_@sfx@(overflow, vmin, quo);
+        npyv_store_@sfx@(dst1, quo);
+    }
+
+    if (!vec_all_eq(warn_zero, vzero)) {
+        npy_set_floatstatus_divbyzero();
+    }
+    if (!vec_all_eq(warn_overflow, vzero)) {
+        npy_set_floatstatus_overflow();
+    }
+
+    for (; len > 0; --len, ++src1, ++src2, ++dst1) {
+        const npyv_lanetype_@sfx@ a = *src1;
+        const npyv_lanetype_@sfx@ b = *src2;
+        if (NPY_UNLIKELY(b == 0)) {
+            npy_set_floatstatus_divbyzero();
+            *dst1 = 0;
+        } else if (NPY_UNLIKELY((a == NPY_MIN_INT@len@) && (b == -1))) {
+            npy_set_floatstatus_overflow();
+            *dst1 = NPY_MIN_INT@len@;
+        } else {
+            *dst1 = a / b;
+            if (((a > 0) != (b > 0)) && ((*dst1 * b) != a)) {
+                *dst1 -= 1;
+            }
+        }
+    }
+    npyv_cleanup();
+}
+/**end repeat**/
+#endif // NPY_HAVE_VSX4
+#endif // NPY_SIMD
 
 /********************************************************************************
  ** Defining ufunc inner functions
@@ -163,8 +350,14 @@ NPY_FINLINE @type@ floor_div_@TYPE@(const @type@ n, const @type@ d)
      * (i.e. a different approach than npy_set_floatstatus_divbyzero()).
      */
     if (NPY_UNLIKELY(d == 0 || (n == NPY_MIN_@TYPE@ && d == -1))) {
-        npy_set_floatstatus_divbyzero();
-        return 0;
+        if (d == 0) {
+            npy_set_floatstatus_divbyzero();
+            return 0;
+        }
+        else {
+            npy_set_floatstatus_overflow();
+            return NPY_MIN_@TYPE@;
+        }
     }
     @type@ r = n / d;
     // Negative quotients needs to be rounded down
@@ -184,6 +377,12 @@ NPY_NO_EXPORT void NPY_CPU_DISPATCH_CURFX(@TYPE@_divide)
         *((@type@ *)iop1) = io1;
     }
 #if NPY_SIMD && defined(TO_SIMD_SFX)
+#if defined(NPY_HAVE_VSX4)
+    // both arguments are arrays of the same size
+    else if (IS_BLOCKABLE_BINARY(sizeof(@type@), NPY_SIMD_WIDTH)) {
+        TO_SIMD_SFX(vsx4_simd_divide_contig)(args, dimensions[0]);
+    }
+#endif
     // for contiguous block of memory, divisor is a scalar and not 0
     else if (IS_BLOCKABLE_BINARY_SCALAR2(sizeof(@type@), NPY_SIMD_WIDTH) &&
              (*(@type@ *)args[1]) != 0) {
@@ -218,8 +417,7 @@ NPY_NO_EXPORT void NPY_CPU_DISPATCH_CURFX(@TYPE@_divide)
  * because emulating multiply-high on these architectures is going to be expensive comparing
  * to the native scalar dividers.
  * Therefore it's better to disable NPYV in this special case to avoid any unnecessary shuffles.
- * Power10(VSX4) is an exception here since it has native support for integer vector division,
- * note neither infrastructure nor NPYV has supported VSX4 yet.
+ * Power10(VSX4) is an exception here since it has native support for integer vector division.
  */
 #if NPY_BITSOF_@STYPE@ == 64 && !defined(NPY_HAVE_VSX4) && (defined(NPY_HAVE_VSX) || defined(NPY_HAVE_NEON))
     #undef TO_SIMD_SFX
@@ -240,6 +438,12 @@ NPY_NO_EXPORT void NPY_CPU_DISPATCH_CURFX(@TYPE@_divide)
         *((@type@ *)iop1) = io1;
     }
 #if NPY_SIMD && defined(TO_SIMD_SFX)
+#if defined(NPY_HAVE_VSX4)
+    // both arguments are arrays of the same size
+    else if (IS_BLOCKABLE_BINARY(sizeof(@type@), NPY_SIMD_WIDTH)) {
+        TO_SIMD_SFX(vsx4_simd_divide_contig)(args, dimensions[0]);
+    }
+#endif
     // for contiguous block of memory, divisor is a scalar and not 0
     else if (IS_BLOCKABLE_BINARY_SCALAR2(sizeof(@type@), NPY_SIMD_WIDTH) &&
              (*(@type@ *)args[1]) != 0) {
diff --git a/numpy/core/src/umath/loops_comparison.dispatch.c.src b/numpy/core/src/umath/loops_comparison.dispatch.c.src
new file mode 100644
index 000000000000..4a8eac4b9272
--- /dev/null
+++ b/numpy/core/src/umath/loops_comparison.dispatch.c.src
@@ -0,0 +1,456 @@
+/*@targets
+ ** $maxopt baseline
+ ** sse2 sse42 avx2 avx512f avx512_skx
+ ** vsx2 vsx3
+ ** neon
+ ** vx vxe
+ **/
+#define _UMATHMODULE
+#define _MULTIARRAYMODULE
+#define NPY_NO_DEPRECATED_API NPY_API_VERSION
+
+#include "simd/simd.h"
+#include "loops_utils.h"
+#include "loops.h"
+#include "lowlevel_strided_loops.h"
+// Provides the various *_LOOP macros
+#include "fast_loop_macros.h"
+
+/********************************************************************************
+ ** Defining the SIMD kernels
+ ********************************************************************************/
+/**begin repeat
+ * #sfx    = u8, s8, u16, s16, u32, s32, u64, s64, f32, f64#
+ * #len    =  8,  8,  16,  16,  32,  32,  64,  64,  32,  64#
+ * #signed =  0,  1,   0,   1,   0,   1,   0,   1,   0,   0#
+ * #VECTOR = NPY_SIMD*8, NPY_SIMD_F32, NPY_SIMD_F64#
+ */
+/**begin repeat1
+ * #kind = equal, not_equal, less, less_equal#
+ * #eq = 1, 0, 0, 0#
+ * #neq = 0, 1, 0, 0#
+ * #OP = ==, !=, <, <=#
+ * #VOP = cmpeq, cmpneq, cmplt, cmple#
+ */
+#if @VECTOR@ && !((@eq@ || @neq@) && @signed@)
+static void simd_binary_@kind@_@sfx@(char **args, npy_intp len)
+{
+    npyv_lanetype_@sfx@ *src1 = (npyv_lanetype_@sfx@ *) args[0];
+    npyv_lanetype_@sfx@ *src2 = (npyv_lanetype_@sfx@ *) args[1];
+    npyv_lanetype_u8 *dst     = (npyv_lanetype_u8 *) args[2];
+    const npyv_u8 truemask    = npyv_setall_u8(0x1);
+    const int vstep           = npyv_nlanes_u8;
+
+    // Unroll the loop to get a resultant vector with 'vsteps' elements.
+    for (; len >= vstep;
+         len -= vstep, src1 += vstep, src2 += vstep, dst += vstep) {
+#if @len@ >= 8
+        npyv_@sfx@  a1 = npyv_load_@sfx@(src1 + npyv_nlanes_@sfx@ * 0);
+        npyv_@sfx@  b1 = npyv_load_@sfx@(src2 + npyv_nlanes_@sfx@ * 0);
+        npyv_b@len@ c1 = npyv_@VOP@_@sfx@(a1, b1);
+#if @len@ >= 16
+        npyv_@sfx@  a2 = npyv_load_@sfx@(src1 + npyv_nlanes_@sfx@ * 1);
+        npyv_@sfx@  b2 = npyv_load_@sfx@(src2 + npyv_nlanes_@sfx@ * 1);
+        npyv_b@len@ c2 = npyv_@VOP@_@sfx@(a2, b2);
+#if @len@ >= 32
+        npyv_@sfx@  a3 = npyv_load_@sfx@(src1 + npyv_nlanes_@sfx@ * 2);
+        npyv_@sfx@  b3 = npyv_load_@sfx@(src2 + npyv_nlanes_@sfx@ * 2);
+        npyv_@sfx@  a4 = npyv_load_@sfx@(src1 + npyv_nlanes_@sfx@ * 3);
+        npyv_@sfx@  b4 = npyv_load_@sfx@(src2 + npyv_nlanes_@sfx@ * 3);
+        npyv_b@len@ c3 = npyv_@VOP@_@sfx@(a3, b3);
+        npyv_b@len@ c4 = npyv_@VOP@_@sfx@(a4, b4);
+#if @len@ == 64
+        npyv_@sfx@  a5 = npyv_load_@sfx@(src1 + npyv_nlanes_@sfx@ * 4);
+        npyv_@sfx@  b5 = npyv_load_@sfx@(src2 + npyv_nlanes_@sfx@ * 4);
+        npyv_@sfx@  a6 = npyv_load_@sfx@(src1 + npyv_nlanes_@sfx@ * 5);
+        npyv_@sfx@  b6 = npyv_load_@sfx@(src2 + npyv_nlanes_@sfx@ * 5);
+        npyv_@sfx@  a7 = npyv_load_@sfx@(src1 + npyv_nlanes_@sfx@ * 6);
+        npyv_@sfx@  b7 = npyv_load_@sfx@(src2 + npyv_nlanes_@sfx@ * 6);
+        npyv_@sfx@  a8 = npyv_load_@sfx@(src1 + npyv_nlanes_@sfx@ * 7);
+        npyv_@sfx@  b8 = npyv_load_@sfx@(src2 + npyv_nlanes_@sfx@ * 7);
+        npyv_b@len@ c5 = npyv_@VOP@_@sfx@(a5, b5);
+        npyv_b@len@ c6 = npyv_@VOP@_@sfx@(a6, b6);
+        npyv_b@len@ c7 = npyv_@VOP@_@sfx@(a7, b7);
+        npyv_b@len@ c8 = npyv_@VOP@_@sfx@(a8, b8);
+#endif // @len@ >= 64
+#endif // @len@ >= 32
+#endif // @len@ >= 16
+#endif // @len@ >= 8
+
+        // Pack the 'c' vectors into a single vector 'r'
+#if @len@ == 8
+        npyv_u8 r = npyv_cvt_u8_b8(c1);
+#elif @len@ == 16
+        npyv_u8 r = npyv_cvt_u8_b8(npyv_pack_b8_b16(c1, c2));
+#elif @len@ == 32
+        npyv_u8 r = npyv_cvt_u8_b8(npyv_pack_b8_b32(c1, c2, c3, c4));
+#elif @len@ == 64
+        npyv_u8 r =
+            npyv_cvt_u8_b8(npyv_pack_b8_b64(c1, c2, c3, c4, c5, c6, c7, c8));
+#endif
+        npyv_store_u8(dst, npyv_and_u8(r, truemask));
+    }
+
+    for (; len > 0; --len, ++src1, ++src2, ++dst) {
+        const npyv_lanetype_@sfx@ a = *src1;
+        const npyv_lanetype_@sfx@ b = *src2;
+        *dst = a @OP@ b;
+    }
+}
+
+static void simd_binary_scalar1_@kind@_@sfx@(char **args, npy_intp len)
+{
+    npyv_lanetype_@sfx@ scalar = *(npyv_lanetype_@sfx@ *) args[0];
+    npyv_lanetype_@sfx@ *src   = (npyv_lanetype_@sfx@ *) args[1];
+    npyv_lanetype_u8 *dst      = (npyv_lanetype_u8 *) args[2];
+    const npyv_@sfx@ a         = npyv_setall_@sfx@(scalar);
+    const npyv_u8 truemask     = npyv_setall_u8(0x1);
+    const int vstep            = npyv_nlanes_u8;
+
+    for (; len >= vstep; len -= vstep, src += vstep, dst += vstep) {
+#if @len@ >= 8
+        npyv_@sfx@  b1 = npyv_load_@sfx@(src + npyv_nlanes_@sfx@ * 0);
+        npyv_b@len@ c1 = npyv_@VOP@_@sfx@(a, b1);
+#if @len@ >= 16
+        npyv_@sfx@  b2 = npyv_load_@sfx@(src + npyv_nlanes_@sfx@ * 1);
+        npyv_b@len@ c2 = npyv_@VOP@_@sfx@(a, b2);
+#if @len@ >= 32
+        npyv_@sfx@  b3 = npyv_load_@sfx@(src + npyv_nlanes_@sfx@ * 2);
+        npyv_@sfx@  b4 = npyv_load_@sfx@(src + npyv_nlanes_@sfx@ * 3);
+        npyv_b@len@ c3 = npyv_@VOP@_@sfx@(a, b3);
+        npyv_b@len@ c4 = npyv_@VOP@_@sfx@(a, b4);
+#if @len@ == 64
+        npyv_@sfx@  b5 = npyv_load_@sfx@(src + npyv_nlanes_@sfx@ * 4);
+        npyv_@sfx@  b6 = npyv_load_@sfx@(src + npyv_nlanes_@sfx@ * 5);
+        npyv_@sfx@  b7 = npyv_load_@sfx@(src + npyv_nlanes_@sfx@ * 6);
+        npyv_@sfx@  b8 = npyv_load_@sfx@(src + npyv_nlanes_@sfx@ * 7);
+        npyv_b@len@ c5 = npyv_@VOP@_@sfx@(a, b5);
+        npyv_b@len@ c6 = npyv_@VOP@_@sfx@(a, b6);
+        npyv_b@len@ c7 = npyv_@VOP@_@sfx@(a, b7);
+        npyv_b@len@ c8 = npyv_@VOP@_@sfx@(a, b8);
+#endif // @len@ >= 64
+#endif // @len@ >= 32
+#endif // @len@ >= 16
+#endif // @len@ >= 8
+
+#if @len@ == 8
+        npyv_u8 r = npyv_cvt_u8_b8(c1);
+#elif @len@ == 16
+        npyv_u8 r = npyv_cvt_u8_b8(npyv_pack_b8_b16(c1, c2));
+#elif @len@ == 32
+        npyv_u8 r = npyv_cvt_u8_b8(npyv_pack_b8_b32(c1, c2, c3, c4));
+#elif @len@ == 64
+        npyv_u8 r =
+            npyv_cvt_u8_b8(npyv_pack_b8_b64(c1, c2, c3, c4, c5, c6, c7, c8));
+#endif
+        npyv_store_u8(dst, npyv_and_u8(r, truemask));
+    }
+
+    for (; len > 0; --len, ++src, ++dst) {
+        const npyv_lanetype_@sfx@ b = *src;
+        *dst = scalar @OP@ b;
+    }
+}
+
+static void simd_binary_scalar2_@kind@_@sfx@(char **args, npy_intp len)
+{
+    npyv_lanetype_@sfx@ *src   = (npyv_lanetype_@sfx@ *) args[0];
+    npyv_lanetype_@sfx@ scalar = *(npyv_lanetype_@sfx@ *) args[1];
+    npyv_lanetype_u8 *dst      = (npyv_lanetype_u8 *) args[2];
+    const npyv_@sfx@ b         = npyv_setall_@sfx@(scalar);
+    const npyv_u8 truemask     = npyv_setall_u8(0x1);
+    const int vstep            = npyv_nlanes_u8;
+
+    for (; len >= vstep; len -= vstep, src += vstep, dst += vstep) {
+#if @len@ >= 8
+        npyv_@sfx@  a1 = npyv_load_@sfx@(src + npyv_nlanes_@sfx@ * 0);
+        npyv_b@len@ c1 = npyv_@VOP@_@sfx@(a1, b);
+#if @len@ >= 16
+        npyv_@sfx@  a2 = npyv_load_@sfx@(src + npyv_nlanes_@sfx@ * 1);
+        npyv_b@len@ c2 = npyv_@VOP@_@sfx@(a2, b);
+#if @len@ >= 32
+        npyv_@sfx@  a3 = npyv_load_@sfx@(src + npyv_nlanes_@sfx@ * 2);
+        npyv_@sfx@  a4 = npyv_load_@sfx@(src + npyv_nlanes_@sfx@ * 3);
+        npyv_b@len@ c3 = npyv_@VOP@_@sfx@(a3, b);
+        npyv_b@len@ c4 = npyv_@VOP@_@sfx@(a4, b);
+#if @len@ == 64
+        npyv_@sfx@  a5 = npyv_load_@sfx@(src + npyv_nlanes_@sfx@ * 4);
+        npyv_@sfx@  a6 = npyv_load_@sfx@(src + npyv_nlanes_@sfx@ * 5);
+        npyv_@sfx@  a7 = npyv_load_@sfx@(src + npyv_nlanes_@sfx@ * 6);
+        npyv_@sfx@  a8 = npyv_load_@sfx@(src + npyv_nlanes_@sfx@ * 7);
+        npyv_b@len@ c5 = npyv_@VOP@_@sfx@(a5, b);
+        npyv_b@len@ c6 = npyv_@VOP@_@sfx@(a6, b);
+        npyv_b@len@ c7 = npyv_@VOP@_@sfx@(a7, b);
+        npyv_b@len@ c8 = npyv_@VOP@_@sfx@(a8, b);
+#endif // @len@ >= 64
+#endif // @len@ >= 32
+#endif // @len@ >= 16
+#endif // @len@ >= 8
+
+#if @len@ == 8
+        npyv_u8 r = npyv_cvt_u8_b8(c1);
+#elif @len@ == 16
+        npyv_u8 r = npyv_cvt_u8_b8(npyv_pack_b8_b16(c1, c2));
+#elif @len@ == 32
+        npyv_u8 r = npyv_cvt_u8_b8(npyv_pack_b8_b32(c1, c2, c3, c4));
+#elif @len@ == 64
+        npyv_u8 r =
+            npyv_cvt_u8_b8(npyv_pack_b8_b64(c1, c2, c3, c4, c5, c6, c7, c8));
+#endif
+        npyv_store_u8(dst, npyv_and_u8(r, truemask));
+    }
+
+    for (; len > 0; --len, ++src, ++dst) {
+        const npyv_lanetype_@sfx@ a = *src;
+        *dst = a @OP@ scalar;
+    }
+}
+#endif
+
+/**end repeat1**/
+/**end repeat**/
+
+/**begin repeat
+ * #kind = equal, not_equal, less, less_equal#
+ * #eq = 1, 0, 0, 0#
+ * #neq = 0, 1, 0, 0#
+ * #OP = ==, !=, <, <=#
+ * #VOP = xnor, xor, andc, orc#
+ */
+
+#if NPY_SIMD
+static void simd_binary_@kind@_b8(char **args, npy_intp len)
+{
+    npyv_lanetype_u8 *src1 = (npyv_lanetype_u8 *) args[0];
+    npyv_lanetype_u8 *src2 = (npyv_lanetype_u8 *) args[1];
+    npyv_lanetype_u8 *dst  = (npyv_lanetype_u8 *) args[2];
+    const npyv_u8 truemask = npyv_setall_u8(0x1);
+    const npyv_u8 vzero    = npyv_setall_u8(0x0);
+    const int vstep        = npyv_nlanes_u8;
+
+    for (; len >= vstep;
+         len -= vstep, src1 += vstep, src2 += vstep, dst += vstep) {
+        // Whatever element in src != 0x0 is converted to 0xFF
+        npyv_b8 a = npyv_cmpeq_u8(npyv_load_u8(src1), vzero);
+        npyv_b8 b = npyv_cmpeq_u8(npyv_load_u8(src2), vzero);
+        npyv_b8 c = npyv_@VOP@_b8(a, b);
+        npyv_store_u8(dst, npyv_and_u8(npyv_cvt_u8_b8(c), truemask));
+    }
+
+    for (; len > 0; --len, ++src1, ++src2, ++dst) {
+        const npyv_lanetype_u8 a = *src1 != 0;
+        const npyv_lanetype_u8 b = *src2 != 0;
+        *dst = a @OP@ b;
+    }
+}
+
+static void simd_binary_scalar1_@kind@_b8(char **args, npy_intp len)
+{
+    npyv_lanetype_u8 scalar = *(npyv_lanetype_u8 *) args[0];
+    npyv_lanetype_u8 *src   = (npyv_lanetype_u8 *) args[1];
+    npyv_lanetype_u8 *dst   = (npyv_lanetype_u8 *) args[2];
+    const npyv_u8 vzero     = npyv_setall_u8(0x0);
+    const npyv_u8 vscalar   = npyv_setall_u8(scalar);
+    const npyv_b8 a         = npyv_cmpeq_u8(vscalar, vzero);
+    const npyv_u8 truemask  = npyv_setall_u8(0x1);
+    const int vstep         = npyv_nlanes_u8;
+
+    for (; len >= vstep; len -= vstep, src += vstep, dst += vstep) {
+        npyv_b8 b = npyv_cmpeq_u8(npyv_load_u8(src), vzero);
+        npyv_b8 c = npyv_@VOP@_b8(a, b);
+        npyv_store_u8(dst, npyv_and_u8(npyv_cvt_u8_b8(c), truemask));
+    }
+
+    for (; len > 0; --len, ++src, ++dst) {
+        const npyv_lanetype_u8 b = *src != 0;
+        *dst = scalar @OP@ b;
+    }
+}
+
+static void simd_binary_scalar2_@kind@_b8(char **args, npy_intp len)
+{
+    npyv_lanetype_u8 *src   = (npyv_lanetype_u8 *) args[0];
+    npyv_lanetype_u8 scalar = *(npyv_lanetype_u8 *) args[1];
+    npyv_lanetype_u8 *dst   = (npyv_lanetype_u8 *) args[2];
+    const npyv_u8 vzero     = npyv_setall_u8(0x0);
+    const npyv_u8 vscalar   = npyv_setall_u8(scalar);
+    const npyv_b8 b         = npyv_cmpeq_u8(vscalar, vzero);
+    const npyv_u8 truemask  = npyv_setall_u8(0x1);
+    const int vstep         = npyv_nlanes_u8;
+
+    for (; len >= vstep; len -= vstep, src += vstep, dst += vstep) {
+        npyv_b8 a = npyv_cmpeq_u8(npyv_load_u8(src), vzero);
+        npyv_b8 c = npyv_@VOP@_b8(a, b);
+        npyv_store_u8(dst, npyv_and_u8(npyv_cvt_u8_b8(c), truemask));
+    }
+
+    for (; len > 0; --len, ++src, ++dst) {
+        const npyv_lanetype_u8 a = *src != 0;
+        *dst = a @OP@ scalar;
+    }
+}
+#endif
+/**end repeat**/
+
+/**begin repeat
+ * #type = npy_ubyte*2, npy_byte, npy_ushort, npy_short, npy_uint, npy_int,
+           npy_ulonglong, npy_longlong, npy_float, npy_double#
+ * #sfx = b8, u8, s8, u16, s16, u32, s32, u64, s64, f32, f64#
+ * #bool = 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0#
+ * #fp = 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1#
+ * #signed = 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0#
+ * #VECTOR = NPY_SIMD*9, NPY_SIMD_F32, NPY_SIMD_F64#
+ */
+/**begin repeat1
+ * #kind = equal, not_equal, less, less_equal#
+ * #eq   = 1, 0, 0, 0#
+ * #neq  = 0, 1, 0, 0#
+ * #OP = ==, !=, <, <=#
+ */
+#if !((@eq@ || @neq@) && @signed@)
+static NPY_INLINE void
+run_binary_simd_@kind@_@sfx@(char **args, npy_intp const *dimensions, npy_intp const *steps)
+{
+#if @VECTOR@
+    if (!is_mem_overlap(args[0], steps[0], args[2], steps[2], dimensions[0]) &&
+        !is_mem_overlap(args[1], steps[1], args[2], steps[2], dimensions[0])
+    ) {
+        /* argument one scalar */
+        if (IS_BINARY_CONT_S1(@type@, npy_bool)) {
+            simd_binary_scalar1_@kind@_@sfx@(args, dimensions[0]);
+            return;
+        }
+        /* argument two scalar */
+        else if (IS_BINARY_CONT_S2(@type@, npy_bool)) {
+            simd_binary_scalar2_@kind@_@sfx@(args, dimensions[0]);
+            return;
+        }
+        else if (IS_BINARY_CONT(@type@, npy_bool)) {
+            simd_binary_@kind@_@sfx@(args, dimensions[0]);
+            return;
+        }
+    }
+#endif
+
+    BINARY_LOOP {
+#if @bool@
+        npy_bool in1 = *((npy_bool *)ip1) != 0;
+        npy_bool in2 = *((npy_bool *)ip2) != 0;
+#else
+        const @type@ in1 = *(@type@ *)ip1;
+        const @type@ in2 = *(@type@ *)ip2;
+#endif
+        *((npy_bool *)op1) = in1 @OP@ in2;
+    }
+}
+#endif
+/**end repeat1**/
+/**end repeat**/
+
+/********************************************************************************
+ ** Defining ufunc inner functions
+ ********************************************************************************/
+
+/*
+ * In order to reduce the size of the binary generated from this source, the
+ * following rules are applied: 1) each data type implements its function
+ * 'greater' as a call to the function 'less' but with the arguments swapped,
+ * the same applies to the function 'greater_equal', which is implemented
+ * with a call to the function 'less_equal', and 2) for the integer datatypes
+ * of the same size (eg 8-bit), a single kernel of the functions 'equal' and
+ * 'not_equal' is used to implement both signed and unsigned types.
+ */
+
+/**begin repeat
+ * Signed and Unsigned types
+ *  #TYPE  = UBYTE,     USHORT,     UINT,     ULONG,     ULONGLONG,
+ *           BYTE,      SHORT,      INT,      LONG,      LONGLONG#
+ *  #STYPE = BYTE,      SHORT,      INT,      LONG,      LONGLONG,
+ *           BYTE,      SHORT,      INT,      LONG,      LONGLONG#
+ *  #signed = 0, 0, 0, 0, 0, 1, 1, 1, 1, 1#
+ */
+#undef TO_SIMD_SFX
+#undef TO_SIMD_UTYPE
+#if 0
+/**begin repeat1
+ * #len = 8, 16, 32, 64#
+ */
+#elif NPY_BITSOF_@STYPE@ == @len@
+    #define TO_SIMD_UTYPE(X) X##_u@len@
+    #if @signed@
+        #define TO_SIMD_SFX(X) X##_s@len@
+    #else
+        #define TO_SIMD_SFX(X) X##_u@len@
+    #endif
+/**end repeat1**/
+#endif
+
+/**begin repeat1
+ * #kind = greater, greater_equal#
+ * #kind_to = less, less_equal#
+ */
+NPY_NO_EXPORT void NPY_CPU_DISPATCH_CURFX(@TYPE@_@kind@)
+(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func))
+{
+    char *nargs[3] = {args[1], args[0], args[2]};
+    npy_intp nsteps[3] = {steps[1], steps[0], steps[2]};
+    TO_SIMD_SFX(run_binary_simd_@kind_to@)(nargs, dimensions, nsteps);
+}
+/**end repeat1**/
+
+/**begin repeat1
+ * #kind = less, less_equal#
+ */
+NPY_NO_EXPORT void NPY_CPU_DISPATCH_CURFX(@TYPE@_@kind@)
+(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func))
+{
+    TO_SIMD_SFX(run_binary_simd_@kind@)(args, dimensions, steps);
+}
+/**end repeat1**/
+
+/**begin repeat1
+ * #kind = equal, not_equal#
+ */
+NPY_NO_EXPORT void NPY_CPU_DISPATCH_CURFX(@TYPE@_@kind@)
+(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func))
+{
+    TO_SIMD_UTYPE(run_binary_simd_@kind@)(args, dimensions, steps);
+}
+/**end repeat1**/
+/**end repeat**/
+
+/**begin repeat
+ * Boolean & Float types
+ * #TYPE = BOOL, FLOAT, DOUBLE#
+ * #sfx = b8, f32, f64#
+ * #fp = 0, 1, 1#
+ */
+/**begin repeat1
+ * #kind = greater, greater_equal#
+ * #kind_to = less, less_equal#
+ */
+NPY_NO_EXPORT void NPY_CPU_DISPATCH_CURFX(@TYPE@_@kind@)
+(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func))
+{
+    char *nargs[3] = {args[1], args[0], args[2]};
+    npy_intp nsteps[3] = {steps[1], steps[0], steps[2]};
+    run_binary_simd_@kind_to@_@sfx@(nargs, dimensions, nsteps);
+#if @fp@
+    npy_clear_floatstatus_barrier((char*)dimensions);
+#endif
+}
+/**end repeat1**/
+
+/**begin repeat1
+ * #kind = equal, not_equal, less, less_equal#
+ */
+NPY_NO_EXPORT void NPY_CPU_DISPATCH_CURFX(@TYPE@_@kind@)
+(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func))
+{
+    run_binary_simd_@kind@_@sfx@(args, dimensions, steps);
+#if @fp@
+    npy_clear_floatstatus_barrier((char*)dimensions);
+#endif
+}
+/**end repeat1**/
+/**end repeat**/
diff --git a/numpy/core/src/umath/loops_exponent_log.dispatch.c.src b/numpy/core/src/umath/loops_exponent_log.dispatch.c.src
index 95cce553a166..8f123a48b2f4 100644
--- a/numpy/core/src/umath/loops_exponent_log.dispatch.c.src
+++ b/numpy/core/src/umath/loops_exponent_log.dispatch.c.src
@@ -11,6 +11,7 @@
 
 #include "numpy/npy_math.h"
 #include "simd/simd.h"
+#include "npy_svml.h"
 #include "loops_utils.h"
 #include "loops.h"
 #include "lowlevel_strided_loops.h"
@@ -386,7 +387,7 @@ avx512_permute_x8var_pd(__m512d t0, __m512d t1, __m512d t2, __m512d t3,
  * #and_masks =_mm256_and_ps, _mm512_kand#
  * #xor_masks =_mm256_xor_ps, _mm512_kxor#
  * #fmadd = _mm256_fmadd_ps, _mm512_fmadd_ps#
- * #mask_to_int = _mm256_movemask_ps, #
+ * #mask_to_int = _mm256_movemask_ps, npyv_tobits_b32#
  * #full_mask= 0xFF, 0xFFFF#
  * #masked_store = _mm256_maskstore_ps, _mm512_mask_storeu_ps#
  * #cvtps_epi32 = _mm256_cvtps_epi32, #
@@ -459,11 +460,12 @@ simd_exp_FLOAT(npy_float * op,
     @vtype@ cvt_magic = _mm@vsize@_set1_ps(NPY_RINT_CVT_MAGICf);
     @vtype@ log2e = _mm@vsize@_set1_ps(NPY_LOG2Ef);
     @vtype@ inf = _mm@vsize@_set1_ps(NPY_INFINITYF);
+    @vtype@ ninf = _mm@vsize@_set1_ps(-1*NPY_INFINITYF);
     @vtype@ zeros_f = _mm@vsize@_set1_ps(0.0f);
     @vtype@ poly, num_poly, denom_poly, quadrant;
     @vtype@i vindex = _mm@vsize@_loadu_si@vsize@((@vtype@i*)&indexarr[0]);
 
-    @mask@ xmax_mask, xmin_mask, nan_mask, inf_mask;
+    @mask@ xmax_mask, xmin_mask, nan_mask, inf_mask, ninf_mask;
     @mask@ overflow_mask = @isa@_get_partial_load_mask_ps(0, num_lanes);
     @mask@ underflow_mask = @isa@_get_partial_load_mask_ps(0, num_lanes);
     @mask@ load_mask = @isa@_get_full_load_mask_ps();
@@ -490,9 +492,11 @@ simd_exp_FLOAT(npy_float * op,
         xmax_mask = _mm@vsize@_cmp_ps@vsub@(x, _mm@vsize@_set1_ps(xmax), _CMP_GE_OQ);
         xmin_mask = _mm@vsize@_cmp_ps@vsub@(x, _mm@vsize@_set1_ps(xmin), _CMP_LE_OQ);
         inf_mask = _mm@vsize@_cmp_ps@vsub@(x, inf, _CMP_EQ_OQ);
+        ninf_mask = _mm@vsize@_cmp_ps@vsub@(x, ninf, _CMP_EQ_OQ);
         overflow_mask = @or_masks@(overflow_mask,
                                     @xor_masks@(xmax_mask, inf_mask));
-        underflow_mask = @or_masks@(underflow_mask, xmin_mask);
+        underflow_mask = @or_masks@(underflow_mask,
+                                    @xor_masks@(xmin_mask, ninf_mask));
 
         x = @isa@_set_masked_lanes_ps(x, zeros_f, @or_masks@(
                                     @or_masks@(nan_mask, xmin_mask), xmax_mask));
@@ -688,6 +692,43 @@ simd_log_FLOAT(npy_float * op,
 #endif // @CHK@
 /**end repeat**/
 
+#if NPY_SIMD && defined(NPY_HAVE_AVX512_SKX) && defined(NPY_CAN_LINK_SVML)
+/**begin repeat
+ * #func = exp, log#
+ * #default_val = 0, 1#
+ */
+static void
+simd_@func@_f64(const npyv_lanetype_f64 *src, npy_intp ssrc,
+                      npyv_lanetype_f64 *dst, npy_intp sdst, npy_intp len)
+{
+    const int vstep = npyv_nlanes_f64;
+    for (; len > 0; len -= vstep, src += ssrc*vstep, dst += sdst*vstep) {
+        npyv_f64 x;
+#if @default_val@
+        if (ssrc == 1) {
+            x = npyv_load_till_f64(src, len, @default_val@);
+        } else {
+            x = npyv_loadn_till_f64(src, ssrc, len, @default_val@);
+        }
+#else
+        if (ssrc == 1) {
+            x = npyv_load_tillz_f64(src, len);
+        } else {
+            x = npyv_loadn_tillz_f64(src, ssrc, len);
+        }
+#endif
+        npyv_f64 out = __svml_@func@8(x);
+        if (sdst == 1) {
+            npyv_store_till_f64(dst, len, out);
+        } else {
+            npyv_storen_till_f64(dst, sdst, len, out);
+        }
+    }
+    npyv_cleanup();
+}
+/**end repeat**/
+
+#else
 #ifdef SIMD_AVX512F_NOCLANG_BUG
 /*
  * Vectorized implementation of exp double using AVX512
@@ -732,6 +773,7 @@ AVX512F_exp_DOUBLE(npy_double * op,
     __m512d mTH_max = _mm512_set1_pd(0x1.62e42fefa39efp+9);
     __m512d mTH_min = _mm512_set1_pd(-0x1.74910d52d3053p+9);
     __m512d mTH_inf = _mm512_set1_pd(NPY_INFINITY);
+    __m512d mTH_ninf = _mm512_set1_pd(-NPY_INFINITY);
     __m512d zeros_d = _mm512_set1_pd(0.0f);
     __m512d ones_d = _mm512_set1_pd(1.0f);
     __m256i vindex = _mm256_loadu_si256((__m256i*)&indexarr[0]);
@@ -748,7 +790,7 @@ AVX512F_exp_DOUBLE(npy_double * op,
     __mmask8 overflow_mask = avx512_get_partial_load_mask_pd(0, num_lanes);
     __mmask8 underflow_mask = avx512_get_partial_load_mask_pd(0, num_lanes);
     __mmask8 load_mask = avx512_get_full_load_mask_pd();
-    __mmask8 xmin_mask, xmax_mask, inf_mask, nan_mask, nearzero_mask;
+    __mmask8 xmin_mask, xmax_mask, inf_mask, ninf_mask, nan_mask, nearzero_mask;
 
     while (num_remaining_elements > 0) {
         if (num_remaining_elements < num_lanes) {
@@ -769,6 +811,7 @@ AVX512F_exp_DOUBLE(npy_double * op,
         xmax_mask = _mm512_cmp_pd_mask(x, mTH_max, _CMP_GT_OQ);
         xmin_mask = _mm512_cmp_pd_mask(x, mTH_min, _CMP_LT_OQ);
         inf_mask = _mm512_cmp_pd_mask(x, mTH_inf, _CMP_EQ_OQ);
+        ninf_mask = _mm512_cmp_pd_mask(x, mTH_ninf, _CMP_EQ_OQ);
         __m512i x_abs = _mm512_and_epi64(_mm512_castpd_si512(x),
                                 _mm512_set1_epi64(0x7FFFFFFFFFFFFFFF));
         nearzero_mask = _mm512_cmp_pd_mask(_mm512_castsi512_pd(x_abs),
@@ -776,7 +819,8 @@ AVX512F_exp_DOUBLE(npy_double * op,
         nearzero_mask = _mm512_kxor(nearzero_mask, nan_mask);
         overflow_mask = _mm512_kor(overflow_mask,
                                 _mm512_kxor(xmax_mask, inf_mask));
-        underflow_mask = _mm512_kor(underflow_mask, xmin_mask);
+        underflow_mask = _mm512_kor(underflow_mask,
+                                _mm512_kxor(xmin_mask, ninf_mask));
         x = avx512_set_masked_lanes_pd(x, zeros_d,
                         _mm512_kor(_mm512_kor(nan_mask, xmin_mask),
                             _mm512_kor(xmax_mask, nearzero_mask)));
@@ -833,11 +877,19 @@ AVX512F_exp_DOUBLE(npy_double * op,
         op += num_lanes;
         num_remaining_elements -= num_lanes;
     }
-    if (overflow_mask) {
+    /*
+     * Don't count on the compiler for cast between mask and int registers.
+     * On gcc7 with flags -march>=nocona -O3 can cause FP stack overflow
+     * which may lead to putting NaN into certain HW/FP calculations.
+     *
+     * For more details, please check the comments in:
+     * - https://github.com/numpy/numpy/issues/20356
+     */
+    if (npyv_tobits_b64(overflow_mask)) {
         npy_set_floatstatus_overflow();
     }
 
-    if (underflow_mask) {
+    if (npyv_tobits_b64(underflow_mask)) {
         npy_set_floatstatus_underflow();
     }
 }
@@ -1062,17 +1114,18 @@ AVX512F_log_DOUBLE(npy_double * op,
         num_remaining_elements -= num_lanes;
     }
 
-    if (invalid_mask) {
+    if (npyv_tobits_b64(invalid_mask)) {
         npy_set_floatstatus_invalid();
     }
-    if (divide_by_zero_mask) {
+    if (npyv_tobits_b64(divide_by_zero_mask)) {
         npy_set_floatstatus_divbyzero();
     }
 }
 
 #undef WORKAROUND_LLVM__mm512_mask_mul_pd
 
-#endif // AVX512F_NOCLANG_BUG
+#endif // SIMD_AVX512F_NOCLANG_BUG
+#endif // NPY_CAN_LINK_SVML
 
 #ifdef SIMD_AVX512_SKX
 /**begin repeat
@@ -1285,17 +1338,34 @@ NPY_NO_EXPORT void NPY_CPU_DISPATCH_CURFX(FLOAT_@func@)
 NPY_NO_EXPORT void NPY_CPU_DISPATCH_CURFX(DOUBLE_@func@)
 (char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(data))
 {
+#if NPY_SIMD && defined(NPY_HAVE_AVX512_SKX) && defined(NPY_CAN_LINK_SVML)
+    const npy_double *src = (npy_double*)args[0];
+    npy_double *dst = (npy_double*)args[1];
+    const int lsize = sizeof(src[0]);
+    const npy_intp ssrc = steps[0] / lsize;
+    const npy_intp sdst = steps[1] / lsize;
+    const npy_intp len = dimensions[0];
+    assert(steps[0] % lsize == 0 && steps[1] % lsize == 0);
+    if (!is_mem_overlap(src, steps[0], dst, steps[1], len) &&
+            npyv_loadable_stride_f64(ssrc) &&
+            npyv_storable_stride_f64(sdst)) {
+        simd_@func@_f64(src, ssrc, dst, sdst, len);
+        return;
+    }
+#else
 #ifdef SIMD_AVX512F_NOCLANG_BUG
     if (IS_OUTPUT_BLOCKABLE_UNARY(sizeof(npy_double), sizeof(npy_double), 64)) {
         AVX512F_@func@_DOUBLE((npy_double*)args[1], (npy_double*)args[0], dimensions[0], steps[0]);
         return;
     }
-#endif
+#endif // SIMD_AVX512F_NOCLANG_BUG
+#endif // NPY_CAN_LINK_SVML
     UNARY_LOOP {
         const npy_double in1 = *(npy_double *)ip1;
         *(npy_double *)op1 = @scalar@(in1);
     }
 }
+
 /**end repeat**/
 
 /**begin repeat
diff --git a/numpy/core/src/umath/loops_hyperbolic.dispatch.c.src b/numpy/core/src/umath/loops_hyperbolic.dispatch.c.src
new file mode 100644
index 000000000000..8e09de941168
--- /dev/null
+++ b/numpy/core/src/umath/loops_hyperbolic.dispatch.c.src
@@ -0,0 +1,641 @@
+/*@targets
+ ** $maxopt baseline
+ ** (avx2 fma3) AVX512_SKX
+ ** vsx2 vsx4
+ ** neon_vfpv4
+ ** vx vxe
+ **/
+#include "numpy/npy_math.h"
+#include "simd/simd.h"
+#include "loops_utils.h"
+#include "loops.h"
+
+#if NPY_SIMD_FMA3 // native support
+/*
+ * NOTE: The following implementation of tanh(f32, f64) have been converted from
+ * Intel SVML to universal intrinsics, and the original code can be found in:
+ *
+ * - https://github.com/numpy/SVML/blob/main/linux/avx512/svml_z0_tanh_d_la.s
+ * - https://github.com/numpy/SVML/blob/main/linux/avx512/svml_z0_tanh_s_la.s
+ *
+ * ALGORITHM DESCRIPTION:
+ *
+ *   NOTE: Since the hyperbolic tangent function is odd
+ *         (tanh(x) = -tanh(-x)), below algorithm deals with the absolute
+ *         value of the argument |x|: tanh(x) = sign(x) * tanh(|x|)
+ *
+ *   We use a table lookup method to compute tanh(|x|).
+ *   The basic idea is to split the input range into a number of subintervals
+ *   and to approximate tanh(.) with a polynomial on each of them.
+ *
+ *   IEEE SPECIAL CONDITIONS:
+ *   x = [+,-]0, r = [+,-]0
+ *   x = +Inf,   r = +1
+ *   x = -Inf,   r = -1
+ *   x = QNaN,   r = QNaN
+ *   x = SNaN,   r = QNaN
+ *
+ *
+ *  ALGORITHM DETAILS
+ *
+ *  SVML handle |x| > HUGE_THRESHOLD, INF and NaNs by scalar callout as following:
+ *  1. check special cases
+ *  2. return `+-1` for `|x| > HUGE_THRESHOLD`  otherwise return `x`
+ *
+ *  It wasn't clear to us the reason behind using callout instead of using
+ *  AVX512 directly for single-precision.
+ *  However, we saw it's better to use SIMD instead of following SVML.
+ *
+ *  Main path computations are organized as follows:
+ *  Actually we split the interval [0, SATURATION_THRESHOLD)
+ *  into a number of subintervals.  On each subinterval we approximate tanh(.)
+ *   with a minimax polynomial of pre-defined degree. Polynomial coefficients
+ *  are computed beforehand and stored in table. We also use
+ *
+ *       y := |x| + B,
+ *
+ *  here B depends on subinterval and is used to make argument
+ *   closer to zero.
+ *   We also add large fake interval [SATURATION_THRESHOLD, HUGE_THRESHOLD],
+ *   where 1.0 + 0.0*y + 0.0*y^2 ... coefficients are stored - just to
+ *   preserve main path computation logic but return 1.0 for all arguments.
+ *
+ *   Hence reconstruction looks as follows:
+ *   we extract proper polynomial and range reduction coefficients
+ *        (Pj and B), corresponding to subinterval, to which |x| belongs,
+ *        and return
+ *
+ *       r := sign(x) * (P0 + P1 * y + ... + Pn * y^n)
+ *
+ *   NOTE: we use multiprecision technique to multiply and sum the first
+ *         K terms of the polynomial. So Pj, j = 0..K are stored in
+ *         table each as a pair of target precision numbers (Pj and PLj) to
+ *         achieve wider than target precision.
+ *
+ */
+#if NPY_SIMD_F64
+
+    // For architectures without efficient gather / scatter instructions, it is
+    // better to use a transposed LUT where we can load all coefficients for an
+    // index linearly.  In order to keep the same vertical calculation, we
+    // transpose the coef. into lanes.  2 lane transpose is all that's
+    // implemented so we require `npyv_nlanes_f64` == 2.
+    #if npyv_nlanes_f64 == 2
+    #define TANH_TRANSPOSED_LUT
+    #endif // npyv_nlanes_f64 == 2
+
+static void
+simd_tanh_f64(const double *src, npy_intp ssrc, double *dst, npy_intp sdst, npy_intp len)
+{
+#if defined(TANH_TRANSPOSED_LUT)
+    static const npy_uint64 NPY_DECL_ALIGNED(NPY_SIMD_WIDTH) lut18x16[] = {
+        // 0
+        0x0ull,                0x0ull,                0x3ff0000000000000ull, 0xbbf0b3ea3fdfaa19ull, // b,   c0,  c1,  c2
+        0xbfd5555555555555ull, 0xbce6863ee44ed636ull, 0x3fc1111111112ab5ull, 0xbda1ea19ddddb3b4ull, // c3,  c4,  c5,  c6
+        0xbfaba1ba1990520bull, 0xbe351ca7f096011full, 0x3f9664f94e6ac14eull, 0xbea8c4c1fd7852feull, // c7,  c8,  c9,  c10
+        0xbf822404577aa9ddull, 0xbefdd99a221ed573ull, 0x3f6e3be689423841ull, 0xbf2a1306713a4f3aull, // c11, c12, c13, c14
+        0xbf55d7e76dc56871ull, 0x3f35e67ab76a26e7ull,                                               // c15, c16
+        // 1
+        0x3fcc000000000000ull, 0x3fcb8fd0416a7c92ull, 0x3fee842ca3f08532ull, 0xbfca48aaeb53bc21ull,
+        0xbfd183afc292ba11ull, 0x3fc04dcd0476c75eull, 0x3fb5c19efdfc08adull, 0xbfb0b8df995ce4dfull,
+        0xbf96e37bba52f6fcull, 0x3f9eaaf3320c3851ull, 0xbf94d3343bae39ddull, 0xbfccce16b1046f13ull,
+        0x403d8b07f7a82aa3ull, 0x4070593a3735bab4ull, 0xc0d263511f5baac1ull, 0xc1045e509116b066ull,
+        0x41528c38809c90c7ull, 0x41848ee0627d8206ull,
+        // 2
+        0x3fd4000000000000ull, 0x3fd35f98a0ea650eull, 0x3fed11574af58f1bull, 0xbfd19921f4329916ull,
+        0xbfcc1a4b039c9bfaull, 0x3fc43d3449a80f08ull, 0x3fa74c98dc34fbacull, 0xbfb2955cf41e8164ull,
+        0x3ecff7df18455399ull, 0x3f9cf823fe761fc1ull, 0xbf7bc748e60df843ull, 0xbf81a16f224bb7b6ull,
+        0xbf9f44ab92fbab0aull, 0xbfccab654e44835eull, 0x40169f73b15ebe5cull, 0x4041fab9250984ceull,
+        0xc076d57fb5190b02ull, 0xc0a216d618b489ecull,
+        // 3
+        0x3fdc000000000000ull, 0x3fda5729ee488037ull, 0x3fea945b9c24e4f9ull, 0xbfd5e0f09bef8011ull,
+        0xbfc16e1e6d8d0be6ull, 0x3fc5c26f3699b7e7ull, 0xbf790d6a8eff0a77ull, 0xbfaf9d05c309f7c6ull,
+        0x3f97362834d33a4eull, 0x3f9022271754ff1full, 0xbf8c89372b43ba85ull, 0xbf62cbf00406bc09ull,
+        0x3fb2eac604473d6aull, 0x3fd13ed80037dbacull, 0xc025c1dd41cd6cb5ull, 0xc0458d090ec3de95ull,
+        0x4085f09f888f8adaull, 0x40a5b89107c8af4full,
+        // 4
+        0x3fe4000000000000ull, 0x3fe1bf47eabb8f95ull, 0x3fe6284c3374f815ull, 0xbfd893b59c35c882ull, // b,   c0,  c1,  c2
+        0xbf92426c751e48a2ull, 0x3fc1a686f6ab2533ull, 0xbfac3c021789a786ull, 0xbf987d27ccff4291ull, // c3,  c4,  c5,  c6
+        0x3f9e7f8380184b45ull, 0xbf731fe77c9c60afull, 0xbf8129a092de747aull, 0x3f75b29bb02cf69bull, // c7,  c8,  c9,  c10
+        0x3f45f87d903aaac8ull, 0xbf6045b9076cc487ull, 0xbf58fd89fe05e0d1ull, 0xbf74949d60113d63ull, // c11, c12, c13, c14
+        0x3fa246332a2fcba5ull, 0x3fb69d8374520edaull,                                               // c15, c16
+        // 5
+        0x3fec000000000000ull, 0x3fe686650b8c2015ull, 0x3fe02500a09f8d6eull, 0xbfd6ba7cb7576538ull,
+        0x3fb4f152b2bad124ull, 0x3faf203c316ce730ull, 0xbfae2196b7326859ull, 0x3f8b2ca62572b098ull,
+        0x3f869543e7c420d4ull, 0xbf84a6046865ec7dull, 0x3f60c85b4d538746ull, 0x3f607df0f9f90c17ull,
+        0xbf5e104671036300ull, 0x3f2085ee7e8ac170ull, 0x3f73f7af01d5af7aull, 0x3f7c9fd6200d0adeull,
+        0xbfb29d851a896fcdull, 0xbfbded519f981716ull,
+        // 6
+        0x3ff4000000000000ull, 0x3feb2523bb6b2deeull, 0x3fd1f25131e3a8c0ull, 0xbfce7291743d7555ull,
+        0x3fbbba40cbef72beull, 0xbf89c7a02788557cull, 0xbf93a7a011ff8c2aull, 0x3f8f1cf6c7f5b00aull,
+        0xbf7326bd4914222aull, 0xbf4ca3f1f2b9192bull, 0x3f5be9392199ec18ull, 0xbf4b852a6e0758d5ull,
+        0x3f19bc98ddf0f340ull, 0x3f23524622610430ull, 0xbf1e40bdead17e6bull, 0x3f02cd40e0ad0a9full,
+        0x3ed9065ae369b212ull, 0xbef02d288b5b3371ull,
+        // 7
+        0x3ffc000000000000ull, 0x3fee1fbf97e33527ull, 0x3fbd22ca1c24a139ull, 0xbfbb6d85a01efb80ull,
+        0x3fb01ba038be6a3dull, 0xbf98157e26e0d541ull, 0x3f6e4709c7e8430eull, 0x3f60379811e43dd5ull,
+        0xbf5fc15b0a9d98faull, 0x3f4c77dee0afd227ull, 0xbf2a0c68a4489f10ull, 0xbf0078c63d1b8445ull,
+        0x3f0d4304bc9246e8ull, 0xbeff12a6626911b4ull, 0x3ee224cd6c4513e5ull, 0xbe858ab8e019f311ull,
+        0xbeb8e1ba4c98a030ull, 0x3eb290981209c1a6ull,
+        // 8
+        0x4004000000000000ull, 0x3fef9258260a71c2ull, 0x3f9b3afe1fba5c76ull, 0xbf9addae58c7141aull, // b,   c0,  c1,  c2
+        0x3f916df44871efc8ull, 0xbf807b55c1c7d278ull, 0x3f67682afa611151ull, 0xbf4793826f78537eull, // c3,  c4,  c5,  c6
+        0x3f14cffcfa69fbb6ull, 0x3f04055bce68597aull, 0xbf00462601dc2faaull, 0x3eec12eadd55be7aull, // c7,  c8,  c9,  c10
+        0xbed13c415f7b9d41ull, 0x3eab9008bca408afull, 0xbe24b645e68eeaa3ull, 0xbe792fa6323b7cf8ull, // c11, c12, c13, c14
+        0x3e6ffd0766ad4016ull, 0xbe567e924bf5ff6eull,                                               // c15, c16
+        // 9
+        0x400c000000000000ull, 0x3feff112c63a9077ull, 0x3f6dd37d19b22b21ull, 0xbf6dc59376c7aa19ull,
+        0x3f63c6869dfc8870ull, 0xbf53a18d5843190full, 0x3f3ef2ee77717cbfull, 0xbf2405695e36240full,
+        0x3f057e48e5b79d10ull, 0xbee2bf0cb4a71647ull, 0x3eb7b6a219dea9f4ull, 0xbe6fa600f593181bull,
+        0xbe722b8d9720cdb0ull, 0x3e634df71865f620ull, 0xbe4abfebfb72bc83ull, 0x3e2df04d67876402ull,
+        0xbe0c63c29f505f5bull, 0x3de3f7f7de6b0eb6ull,
+        // 10
+        0x4014000000000000ull, 0x3fefff419668df11ull, 0x3f27ccec13a9ef96ull, 0xbf27cc5e74677410ull,
+        0x3f1fb9aef915d828ull, 0xbf0fb6bbc89b1a5bull, 0x3ef95a4482f180b7ull, 0xbee0e08de39ce756ull,
+        0x3ec33b66d7d77264ull, 0xbea31eaafe73efd5ull, 0x3e80cbcc8d4c5c8aull, 0xbe5a3c935dce3f7dull,
+        0x3e322666d739bec0ull, 0xbe05bb1bcf83ca73ull, 0x3dd51c38f8695ed3ull, 0xbd95c72be95e4d2cull,
+        0xbd7fab216b9e0e49ull, 0x3d69ed18bae3ebbcull,
+        // 11
+        0x401c000000000000ull, 0x3feffffc832750f2ull, 0x3ecbe6c3f33250aeull, 0xbecbe6c0e8b4cc87ull,
+        0x3ec299d1e27c6e11ull, 0xbeb299c9c684a963ull, 0x3e9dc2c27da3b603ull, 0xbe83d709ba5f714eull,
+        0x3e66ac4e578b9b10ull, 0xbe46abb02c4368edull, 0x3e2425bb231a5e29ull, 0xbe001c6d95e3ae96ull,
+        0x3dd76a553d7e7918ull, 0xbdaf2ac143fb6762ull, 0x3d8313ac38c6832bull, 0xbd55a89c30203106ull,
+        0x3d2826b62056aa27ull, 0xbcf7534c4f3dfa71ull,
+        // 12
+        0x4024000000000000ull, 0x3feffffffdc96f35ull, 0x3e41b4865394f75full, 0xbe41b486526b0565ull, // b,   c0,  c1,  c2
+        0x3e379b5ddcca334cull, 0xbe279b5dd4fb3d01ull, 0x3e12e2afd9f7433eull, 0xbdf92e3fc5ee63e0ull, // c3,  c4,  c5,  c6
+        0x3ddcc74b8d3d5c42ull, 0xbdbcc749ca8079ddull, 0x3d9992a4beac8662ull, 0xbd74755a00ea1fd3ull, // c7,  c8,  c9,  c10
+        0x3d4de0fa59416a39ull, 0xbd23eae52a3dbf57ull, 0x3cf7787935626685ull, 0xbccad6b3bb9eff65ull, // c11, c12, c13, c14
+        0x3ca313e31762f523ull, 0xbc730b73f1eaff20ull,                                               // c15, c16
+        // 13
+        0x402c000000000000ull, 0x3fefffffffffcf58ull, 0x3d8853f01bda5f28ull, 0xbd8853f01bef63a4ull, 
+        0x3d8037f57bc62c9aull, 0xbd7037f57ae72aa6ull, 0x3d59f320348679baull, 0xbd414cc030f2110eull,
+        0x3d23c589137f92b4ull, 0xbd03c5883836b9d2ull, 0x3ce191ba5ed3fb67ull, 0xbcbc1c6c063bb7acull,
+        0x3c948716cf3681b4ull, 0xbc6b5e3e9ca0955eull, 0x3c401ffc49c6bc29ull, 0xbc12705ccd3dd884ull,
+        0x3bea37aa21895319ull, 0xbbba2cff8135d462ull,
+        // 14
+        0x4034000000000000ull, 0x3ff0000000000000ull, 0x3c73953c0197ef58ull, 0xbc73955be519be31ull,
+        0x3c6a2d4b50a2cff7ull, 0xbc5a2ca2bba78e86ull, 0x3c44b61d9bbcc940ull, 0xbc2ba022e8d82a87ull,
+        0x3c107f8e2c8707a1ull, 0xbbf07a5416264aecull, 0x3bc892450bad44c4ull, 0xbba3be9a4460fe00ull,
+        0x3b873f9f2d2fda99ull, 0xbb5eca68e2c1ba2eull, 0xbabf0b21acfa52abull, 0xba8e0a4c47ae75f5ull,
+        0x3ae5c7f1fd871496ull, 0xbab5a71b5f7d9035ull,
+        // 15
+        0x0ull,                0x3ff0000000000000ull, 0x0ull,                0x0ull,                
+        0x0ull,                0x0ull,                0x0ull,                0x0ull,               
+        0x0ull,                0x0ull,                0x0ull,                0x0ull,
+        0x0ull,                0x0ull,                0x0ull,                0x0ull,
+        0x0ull,                0x0ull,               
+    };
+#else
+    static const npy_uint64 NPY_DECL_ALIGNED(NPY_SIMD_WIDTH) lut16x18[] = {
+        // 0
+        0x0ull,                0x3fcc000000000000ull, 0x3fd4000000000000ull, 0x3fdc000000000000ull,
+        0x3fe4000000000000ull, 0x3fec000000000000ull, 0x3ff4000000000000ull, 0x3ffc000000000000ull,
+        0x4004000000000000ull, 0x400c000000000000ull, 0x4014000000000000ull, 0x401c000000000000ull,
+        0x4024000000000000ull, 0x402c000000000000ull, 0x4034000000000000ull, 0x0ull,
+        // 1
+        0x0ull,                0x3fcb8fd0416a7c92ull, 0x3fd35f98a0ea650eull, 0x3fda5729ee488037ull,
+        0x3fe1bf47eabb8f95ull, 0x3fe686650b8c2015ull, 0x3feb2523bb6b2deeull, 0x3fee1fbf97e33527ull,
+        0x3fef9258260a71c2ull, 0x3feff112c63a9077ull, 0x3fefff419668df11ull, 0x3feffffc832750f2ull,
+        0x3feffffffdc96f35ull, 0x3fefffffffffcf58ull, 0x3ff0000000000000ull, 0x3ff0000000000000ull,
+        // 2
+        0x3ff0000000000000ull, 0x3fee842ca3f08532ull, 0x3fed11574af58f1bull, 0x3fea945b9c24e4f9ull,
+        0x3fe6284c3374f815ull, 0x3fe02500a09f8d6eull, 0x3fd1f25131e3a8c0ull, 0x3fbd22ca1c24a139ull,
+        0x3f9b3afe1fba5c76ull, 0x3f6dd37d19b22b21ull, 0x3f27ccec13a9ef96ull, 0x3ecbe6c3f33250aeull,
+        0x3e41b4865394f75full, 0x3d8853f01bda5f28ull, 0x3c73953c0197ef58ull, 0x0ull,
+        // 3
+        0xbbf0b3ea3fdfaa19ull, 0xbfca48aaeb53bc21ull, 0xbfd19921f4329916ull, 0xbfd5e0f09bef8011ull,
+        0xbfd893b59c35c882ull, 0xbfd6ba7cb7576538ull, 0xbfce7291743d7555ull, 0xbfbb6d85a01efb80ull,
+        0xbf9addae58c7141aull, 0xbf6dc59376c7aa19ull, 0xbf27cc5e74677410ull, 0xbecbe6c0e8b4cc87ull,
+        0xbe41b486526b0565ull, 0xbd8853f01bef63a4ull, 0xbc73955be519be31ull, 0x0ull,
+        // 4
+        0xbfd5555555555555ull, 0xbfd183afc292ba11ull, 0xbfcc1a4b039c9bfaull, 0xbfc16e1e6d8d0be6ull,
+        0xbf92426c751e48a2ull, 0x3fb4f152b2bad124ull, 0x3fbbba40cbef72beull, 0x3fb01ba038be6a3dull,
+        0x3f916df44871efc8ull, 0x3f63c6869dfc8870ull, 0x3f1fb9aef915d828ull, 0x3ec299d1e27c6e11ull,
+        0x3e379b5ddcca334cull, 0x3d8037f57bc62c9aull, 0x3c6a2d4b50a2cff7ull, 0x0ull,
+        // 5
+        0xbce6863ee44ed636ull, 0x3fc04dcd0476c75eull, 0x3fc43d3449a80f08ull, 0x3fc5c26f3699b7e7ull,
+        0x3fc1a686f6ab2533ull, 0x3faf203c316ce730ull, 0xbf89c7a02788557cull, 0xbf98157e26e0d541ull,
+        0xbf807b55c1c7d278ull, 0xbf53a18d5843190full, 0xbf0fb6bbc89b1a5bull, 0xbeb299c9c684a963ull,
+        0xbe279b5dd4fb3d01ull, 0xbd7037f57ae72aa6ull, 0xbc5a2ca2bba78e86ull, 0x0ull,
+        // 6
+        0x3fc1111111112ab5ull, 0x3fb5c19efdfc08adull, 0x3fa74c98dc34fbacull, 0xbf790d6a8eff0a77ull,
+        0xbfac3c021789a786ull, 0xbfae2196b7326859ull, 0xbf93a7a011ff8c2aull, 0x3f6e4709c7e8430eull,
+        0x3f67682afa611151ull, 0x3f3ef2ee77717cbfull, 0x3ef95a4482f180b7ull, 0x3e9dc2c27da3b603ull,
+        0x3e12e2afd9f7433eull, 0x3d59f320348679baull, 0x3c44b61d9bbcc940ull, 0x0ull,
+        // 7
+        0xbda1ea19ddddb3b4ull, 0xbfb0b8df995ce4dfull, 0xbfb2955cf41e8164ull, 0xbfaf9d05c309f7c6ull,
+        0xbf987d27ccff4291ull, 0x3f8b2ca62572b098ull, 0x3f8f1cf6c7f5b00aull, 0x3f60379811e43dd5ull,
+        0xbf4793826f78537eull, 0xbf2405695e36240full, 0xbee0e08de39ce756ull, 0xbe83d709ba5f714eull,
+        0xbdf92e3fc5ee63e0ull, 0xbd414cc030f2110eull, 0xbc2ba022e8d82a87ull, 0x0ull,
+        // 8
+        0xbfaba1ba1990520bull, 0xbf96e37bba52f6fcull, 0x3ecff7df18455399ull, 0x3f97362834d33a4eull,
+        0x3f9e7f8380184b45ull, 0x3f869543e7c420d4ull, 0xbf7326bd4914222aull, 0xbf5fc15b0a9d98faull,
+        0x3f14cffcfa69fbb6ull, 0x3f057e48e5b79d10ull, 0x3ec33b66d7d77264ull, 0x3e66ac4e578b9b10ull,
+        0x3ddcc74b8d3d5c42ull, 0x3d23c589137f92b4ull, 0x3c107f8e2c8707a1ull, 0x0ull,
+        // 9
+        0xbe351ca7f096011full, 0x3f9eaaf3320c3851ull, 0x3f9cf823fe761fc1ull, 0x3f9022271754ff1full,
+        0xbf731fe77c9c60afull, 0xbf84a6046865ec7dull, 0xbf4ca3f1f2b9192bull, 0x3f4c77dee0afd227ull,
+        0x3f04055bce68597aull, 0xbee2bf0cb4a71647ull, 0xbea31eaafe73efd5ull, 0xbe46abb02c4368edull,
+        0xbdbcc749ca8079ddull, 0xbd03c5883836b9d2ull, 0xbbf07a5416264aecull, 0x0ull,
+        // 10
+        0x3f9664f94e6ac14eull, 0xbf94d3343bae39ddull, 0xbf7bc748e60df843ull, 0xbf8c89372b43ba85ull,
+        0xbf8129a092de747aull, 0x3f60c85b4d538746ull, 0x3f5be9392199ec18ull, 0xbf2a0c68a4489f10ull,
+        0xbf00462601dc2faaull, 0x3eb7b6a219dea9f4ull, 0x3e80cbcc8d4c5c8aull, 0x3e2425bb231a5e29ull,
+        0x3d9992a4beac8662ull, 0x3ce191ba5ed3fb67ull, 0x3bc892450bad44c4ull, 0x0ull,
+        // 11
+        0xbea8c4c1fd7852feull, 0xbfccce16b1046f13ull, 0xbf81a16f224bb7b6ull, 0xbf62cbf00406bc09ull,
+        0x3f75b29bb02cf69bull, 0x3f607df0f9f90c17ull, 0xbf4b852a6e0758d5ull, 0xbf0078c63d1b8445ull,
+        0x3eec12eadd55be7aull, 0xbe6fa600f593181bull, 0xbe5a3c935dce3f7dull, 0xbe001c6d95e3ae96ull,
+        0xbd74755a00ea1fd3ull, 0xbcbc1c6c063bb7acull, 0xbba3be9a4460fe00ull, 0x0ull,
+        // 12
+        0xbf822404577aa9ddull, 0x403d8b07f7a82aa3ull, 0xbf9f44ab92fbab0aull, 0x3fb2eac604473d6aull,
+        0x3f45f87d903aaac8ull, 0xbf5e104671036300ull, 0x3f19bc98ddf0f340ull, 0x3f0d4304bc9246e8ull,
+        0xbed13c415f7b9d41ull, 0xbe722b8d9720cdb0ull, 0x3e322666d739bec0ull, 0x3dd76a553d7e7918ull,
+        0x3d4de0fa59416a39ull, 0x3c948716cf3681b4ull, 0x3b873f9f2d2fda99ull, 0x0ull,
+        // 13
+        0xbefdd99a221ed573ull, 0x4070593a3735bab4ull, 0xbfccab654e44835eull, 0x3fd13ed80037dbacull,
+        0xbf6045b9076cc487ull, 0x3f2085ee7e8ac170ull, 0x3f23524622610430ull, 0xbeff12a6626911b4ull,
+        0x3eab9008bca408afull, 0x3e634df71865f620ull, 0xbe05bb1bcf83ca73ull, 0xbdaf2ac143fb6762ull,
+        0xbd23eae52a3dbf57ull, 0xbc6b5e3e9ca0955eull, 0xbb5eca68e2c1ba2eull, 0x0ull,
+        // 14
+        0x3f6e3be689423841ull, 0xc0d263511f5baac1ull, 0x40169f73b15ebe5cull, 0xc025c1dd41cd6cb5ull,
+        0xbf58fd89fe05e0d1ull, 0x3f73f7af01d5af7aull, 0xbf1e40bdead17e6bull, 0x3ee224cd6c4513e5ull,
+        0xbe24b645e68eeaa3ull, 0xbe4abfebfb72bc83ull, 0x3dd51c38f8695ed3ull, 0x3d8313ac38c6832bull,
+        0x3cf7787935626685ull, 0x3c401ffc49c6bc29ull, 0xbabf0b21acfa52abull, 0x0ull,
+        // 15
+        0xbf2a1306713a4f3aull, 0xc1045e509116b066ull, 0x4041fab9250984ceull, 0xc0458d090ec3de95ull,
+        0xbf74949d60113d63ull, 0x3f7c9fd6200d0adeull, 0x3f02cd40e0ad0a9full, 0xbe858ab8e019f311ull,
+        0xbe792fa6323b7cf8ull, 0x3e2df04d67876402ull, 0xbd95c72be95e4d2cull, 0xbd55a89c30203106ull,
+        0xbccad6b3bb9eff65ull, 0xbc12705ccd3dd884ull, 0xba8e0a4c47ae75f5ull, 0x0ull,
+        // 16
+        0xbf55d7e76dc56871ull, 0x41528c38809c90c7ull, 0xc076d57fb5190b02ull, 0x4085f09f888f8adaull,
+        0x3fa246332a2fcba5ull, 0xbfb29d851a896fcdull, 0x3ed9065ae369b212ull, 0xbeb8e1ba4c98a030ull,
+        0x3e6ffd0766ad4016ull, 0xbe0c63c29f505f5bull, 0xbd7fab216b9e0e49ull, 0x3d2826b62056aa27ull,
+        0x3ca313e31762f523ull, 0x3bea37aa21895319ull, 0x3ae5c7f1fd871496ull, 0x0ull,
+        // 17
+        0x3f35e67ab76a26e7ull, 0x41848ee0627d8206ull, 0xc0a216d618b489ecull, 0x40a5b89107c8af4full,
+        0x3fb69d8374520edaull, 0xbfbded519f981716ull, 0xbef02d288b5b3371ull, 0x3eb290981209c1a6ull,
+        0xbe567e924bf5ff6eull, 0x3de3f7f7de6b0eb6ull, 0x3d69ed18bae3ebbcull, 0xbcf7534c4f3dfa71ull,
+        0xbc730b73f1eaff20ull, 0xbbba2cff8135d462ull, 0xbab5a71b5f7d9035ull, 0x0ull
+    };
+#endif // defined(TANH_TRANSPOSED_LUT)
+
+    const int nlanes = npyv_nlanes_f64;
+    const npyv_f64 qnan = npyv_setall_f64(NPY_NAN);
+    for (; len > 0; len -= nlanes, src += ssrc*nlanes, dst += sdst*nlanes) {
+        npyv_f64 x;
+        if (ssrc == 1) {
+            x = npyv_load_tillz_f64(src, len);
+        } else {
+            x = npyv_loadn_tillz_f64(src, ssrc, len);
+        }
+        npyv_s64 ndnan = npyv_and_s64(npyv_reinterpret_s64_f64(x), npyv_setall_s64(0x7ff8000000000000ll));
+        // |x| > HUGE_THRESHOLD, INF and NaNs.
+        npyv_b64 special_m = npyv_cmple_s64(ndnan, npyv_setall_s64(0x7fe0000000000000ll));
+        npyv_b64 nnan_m = npyv_notnan_f64(x);
+        npyv_s64 idxs = npyv_sub_s64(ndnan, npyv_setall_s64(0x3fc0000000000000ll));
+        // no native 64-bit for max/min and its fine to use 32-bit max/min
+        // since we're not crossing 32-bit edge
+        npyv_s32 idxl = npyv_max_s32(npyv_reinterpret_s32_s64(idxs), npyv_zero_s32());
+                 idxl = npyv_min_s32(idxl, npyv_setall_s32(0x780000));
+        npyv_u64 idx  = npyv_shri_u64(npyv_reinterpret_u64_s32(idxl), 51);
+
+#if defined(TANH_TRANSPOSED_LUT)
+        npyv_f64 e0e1[npyv_nlanes_f64];
+        npyv_lanetype_u64 index[npyv_nlanes_f64];
+        npyv_store_u64(index, idx);
+
+        /**begin repeat
+         * #off= 0, 2,  4,  6,  8,  10, 12,  14,  16#
+         * #e0 = b, c1, c3, c5, c7, c9, c11, c13, c15#
+         * #e1 = c0,c2, c4, c6, c8, c10,c12, c14, c16#
+         */
+        /**begin repeat1
+         * #lane = 0, 1#
+         */
+        e0e1[@lane@] = npyv_reinterpret_f64_u64(npyv_load_u64(lut18x16 + index[@lane@] * 18 + @off@));
+        /**end repeat1**/
+        npyv_f64 @e0@ = npyv_combinel_f64(e0e1[0], e0e1[1]);
+        npyv_f64 @e1@ = npyv_combineh_f64(e0e1[0], e0e1[1]);
+        /**end repeat**/
+#else
+        npyv_f64 b = npyv_lut16_f64((const double*)lut16x18 + 16*0, idx);
+        npyv_f64 c0 = npyv_lut16_f64((const double*)lut16x18 + 1*16, idx);
+        npyv_f64 c1 = npyv_lut16_f64((const double*)lut16x18 + 2*16, idx);
+        npyv_f64 c2 = npyv_lut16_f64((const double*)lut16x18 + 3*16, idx);
+        npyv_f64 c3 = npyv_lut16_f64((const double*)lut16x18 + 4*16, idx);
+        npyv_f64 c4 = npyv_lut16_f64((const double*)lut16x18 + 5*16, idx);
+        npyv_f64 c5 = npyv_lut16_f64((const double*)lut16x18 + 6*16, idx);
+        npyv_f64 c6 = npyv_lut16_f64((const double*)lut16x18 + 7*16, idx);
+        npyv_f64 c7 = npyv_lut16_f64((const double*)lut16x18 + 8*16, idx);
+        npyv_f64 c8 = npyv_lut16_f64((const double*)lut16x18 + 9*16, idx);
+        npyv_f64 c9 = npyv_lut16_f64((const double*)lut16x18 + 10*16, idx);
+        npyv_f64 c10 = npyv_lut16_f64((const double*)lut16x18 + 11*16, idx);
+        npyv_f64 c11 = npyv_lut16_f64((const double*)lut16x18 + 12*16, idx);
+        npyv_f64 c12 = npyv_lut16_f64((const double*)lut16x18 + 13*16, idx);
+        npyv_f64 c13 = npyv_lut16_f64((const double*)lut16x18 + 14*16, idx);
+        npyv_f64 c14 = npyv_lut16_f64((const double*)lut16x18 + 15*16, idx);
+        npyv_f64 c15 = npyv_lut16_f64((const double*)lut16x18 + 16*16, idx);
+        npyv_f64 c16 = npyv_lut16_f64((const double*)lut16x18 + 17*16, idx);
+#endif // defined(TANH_TRANSPOSED_LUT)
+
+        // no need to zerofy nans or avoid FP exceptions by NO_EXC like SVML does
+        // since we're clearing the FP status anyway.
+        npyv_f64 sign = npyv_and_f64(x, npyv_reinterpret_f64_s64(npyv_setall_s64(0x8000000000000000ull)));
+        npyv_f64 y = npyv_sub_f64(npyv_abs_f64(x), b);
+        npyv_f64 r = npyv_muladd_f64(c16, y, c15);
+        r = npyv_muladd_f64(r, y, c14);
+        r = npyv_muladd_f64(r, y, c13);
+        r = npyv_muladd_f64(r, y, c12);
+        r = npyv_muladd_f64(r, y, c11);
+        r = npyv_muladd_f64(r, y, c10);
+        r = npyv_muladd_f64(r, y, c9);
+        r = npyv_muladd_f64(r, y, c8);
+        r = npyv_muladd_f64(r, y, c7);
+        r = npyv_muladd_f64(r, y, c6);
+        r = npyv_muladd_f64(r, y, c5);
+        r = npyv_muladd_f64(r, y, c4);
+        r = npyv_muladd_f64(r, y, c3);
+        r = npyv_muladd_f64(r, y, c2);
+        r = npyv_muladd_f64(r, y, c1);
+        r = npyv_muladd_f64(r, y, c0);
+        // 1.0 if |x| > HUGE_THRESHOLD || INF
+        r = npyv_select_f64(special_m, r, npyv_setall_f64(1.0));
+        r = npyv_or_f64(r, sign);
+        // qnan if nan
+        r = npyv_select_f64(nnan_m, r, qnan);
+        if (sdst == 1) {
+            npyv_store_till_f64(dst, len, r);
+        } else {
+            npyv_storen_till_f64(dst, sdst, len, r);
+        }
+    }
+}
+
+#undef TANH_TRANSPOSED_LUT
+
+#endif // NPY_SIMD_F64
+
+#if NPY_SIMD_F32
+
+
+    // For architectures without efficient gather / scatter instructions, it is
+    // better to use a transposed LUT where we can load all coefficients for an
+    // index linearly.  In order to keep the same vertical calculation, we
+    // transpose the coef. into lanes.  A 4x4 transpose is all that's
+    // supported so we require `npyv_nlanes_f32` == 4.
+    #if npyv_nlanes_f32 == 4
+    #define TANHF_TRANSPOSED_LUT
+    // Define missing universal intrinsics used below
+    #if !defined(npyv_get_lane_u32)
+        #if defined(NPY_HAVE_ASIMD)
+            #define UNDEF_npyv_get_lane_u32
+            #define npyv_get_lane_u32 vgetq_lane_u32
+        #elif defined(NPY_HAVE_SSE41)
+            #define UNDEF_npyv_get_lane_u32
+            #define npyv_get_lane_u32 _mm_extract_epi32
+        #else
+            #undef TANHF_TRANSPOSED_LUT
+        #endif
+    #endif // !defined(npyv_get_lane_u32)
+    #endif // npyv_nlanes_f32 == 4
+
+static void
+simd_tanh_f32(const float *src, npy_intp ssrc, float *dst, npy_intp sdst, npy_intp len)
+{
+#if defined(TANHF_TRANSPOSED_LUT)
+    static const npy_uint32 NPY_DECL_ALIGNED(NPY_SIMD_WIDTH) lut8x32[] = {
+        // c6       c5          c4          c3          c2          c1          c0          b
+        0xbc0e2f66, 0x3e0910e9, 0xb76dd6b9, 0xbeaaaaa5, 0xb0343c7b, 0x3f800000, 0x0,        0x0,       
+        0x460bda12, 0x43761143, 0xbe1c276d, 0xbeab0612, 0xbd6ee69d, 0x3f7f1f84, 0x3d6fb9c9, 0x3d700000,
+        0x43d638ef, 0x4165ecdc, 0x3c1dcf2f, 0xbea7f01f, 0xbd8f0da7, 0x3f7ebd11, 0x3d8fc35f, 0x3d900000,
+        0xc3e11c3e, 0xc190f756, 0x3dc1a78d, 0xbea4e120, 0xbdae477d, 0x3f7e1e5f, 0x3daf9169, 0x3db00000,
+        // 4
+        0xc2baa4e9, 0xc08c097d, 0x3d96f985, 0xbea387b7, 0xbdcd2a1f, 0x3f7d609f, 0x3dcf49ab, 0x3dd00000,
+        0xc249da2d, 0xc02ba813, 0x3da2b61b, 0xbea15962, 0xbdeba80d, 0x3f7c842d, 0x3deee849, 0x3df00000,
+        0xc1859b82, 0xbf7f6bda, 0x3dc13397, 0xbe9d57f7, 0xbe0c443b, 0x3f7b00e5, 0x3e0f0ee8, 0x3e100000,
+        0x40dd5b57, 0x3f2b1dc0, 0x3dd2f670, 0xbe976b5a, 0xbe293cf3, 0x3f789580, 0x3e2e4984, 0x3e300000,
+        // 8
+        0x40494640, 0x3ece105d, 0x3df48a0a, 0xbe90230d, 0xbe44f282, 0x3f75b8ad, 0x3e4d2f8e, 0x3e500000,
+        0x40c730a8, 0x3f426a94, 0x3e06c5a8, 0xbe880dff, 0xbe5f3651, 0x3f726fd9, 0x3e6bb32e, 0x3e700000,
+        0xbf0f160e, 0xbadb0dc4, 0x3e1a3aba, 0xbe7479b3, 0xbe81c7c0, 0x3f6cc59b, 0x3e8c51cd, 0x3e900000,
+        0x3e30e76f, 0x3da43b17, 0x3e27c405, 0xbe4c3d88, 0xbe96d7ca, 0x3f63fb92, 0x3ea96163, 0x3eb00000,
+        // 12
+        0xbea81387, 0xbd51ab88, 0x3e2e78d0, 0xbe212482, 0xbea7fb8e, 0x3f59ff97, 0x3ec543f1, 0x3ed00000,
+        0xbdb26a1c, 0xbcaea23d, 0x3e2c3e44, 0xbdeb8cba, 0xbeb50e9e, 0x3f4f11d7, 0x3edfd735, 0x3ef00000,
+        0xbd351e57, 0xbd3b6d8d, 0x3e1d3097, 0xbd5e78ad, 0xbec12efe, 0x3f3d7573, 0x3f028438, 0x3f100000,
+        0xbb4c01a0, 0xbd6caaad, 0x3df4a8f4, 0x3c6b5e6e, 0xbec4be92, 0x3f24f360, 0x3f18abf0, 0x3f300000,
+        // 16
+        0x3c1d7bfb, 0xbd795bed, 0x3da38508, 0x3d839143, 0xbebce070, 0x3f0cbfe7, 0x3f2bc480, 0x3f500000,
+        0x3c722cd1, 0xbd5fddda, 0x3d31416a, 0x3dc21ee1, 0xbead510e, 0x3eec1a69, 0x3f3bec1c, 0x3f700000,
+        0x3c973f1c, 0xbd038f3b, 0x3b562657, 0x3de347af, 0xbe8ef7d6, 0x3eb0a801, 0x3f4f2e5b, 0x3f900000,
+        0x3c33a31b, 0xbc1cad63, 0xbcaeeac9, 0x3dcbec96, 0xbe4b8704, 0x3e6753a2, 0x3f613c53, 0x3fb00000,
+        // 20
+        0x3b862ef4, 0x3abb4766, 0xbcce9419, 0x3d99ef2d, 0xbe083237, 0x3e132f1a, 0x3f6ce37d, 0x3fd00000,
+        0x3a27b3d0, 0x3b95f10b, 0xbcaaeac4, 0x3d542ea1, 0xbdaf7449, 0x3db7e7d3, 0x3f743c4f, 0x3ff00000,
+        0xba3b5907, 0x3b825873, 0xbc49e7d0, 0x3cdde701, 0xbd2e1ec4, 0x3d320845, 0x3f7a5feb, 0x40100000,
+        0xba0efc22, 0x3afaea66, 0xbba71ddd, 0x3c2cca67, 0xbc83bf06, 0x3c84d3d4, 0x3f7dea85, 0x40300000,
+        // 24
+        0xb97f9f0f, 0x3a49f878, 0xbb003b0e, 0x3b81cb27, 0xbbc3e0b5, 0x3bc477b7, 0x3f7f3b3d, 0x40500000,
+        0xb8c8af50, 0x39996bf3, 0xba3f9a05, 0x3ac073a1, 0xbb10aadc, 0x3b10d3da, 0x3f7fb78c, 0x40700000,
+        0xb7bdddfb, 0x388f3e6c, 0xb92c08a7, 0x39ac3032, 0xba0157db, 0x3a01601e, 0x3f7fefd4, 0x40900000,
+        0xb64f2950, 0x371bb0e3, 0xb7ba9232, 0x383a94d9, 0xb88c18f2, 0x388c1a3b, 0x3f7ffdd0, 0x40b00000,
+        // 28
+        0xb4e085b1, 0x35a8a5e6, 0xb64a0b0f, 0x36ca081d, 0xb717b096, 0x3717b0da, 0x3f7fffb4, 0x40d00000,
+        0xb3731dfa, 0x34369b17, 0xb4dac169, 0x355abd4c, 0xb5a43bae, 0x35a43bce, 0x3f7ffff6, 0x40f00000,
+        0xb15a1f04, 0x322487b0, 0xb2ab78ac, 0x332b3cb6, 0xb383012c, 0x338306c6, 0x3f7fffff, 0x41100000,
+        0x0,        0x0,        0x0,        0x0,        0x0,        0x0,        0x3f800000, 0x0,       
+    };
+#else
+    static const npy_uint32 NPY_DECL_ALIGNED(NPY_SIMD_WIDTH) lut32x8[] = {
+        // 0
+        0x0,        0x3d700000, 0x3d900000, 0x3db00000, 0x3dd00000, 0x3df00000, 0x3e100000, 0x3e300000,
+        0x3e500000, 0x3e700000, 0x3e900000, 0x3eb00000, 0x3ed00000, 0x3ef00000, 0x3f100000, 0x3f300000,
+        0x3f500000, 0x3f700000, 0x3f900000, 0x3fb00000, 0x3fd00000, 0x3ff00000, 0x40100000, 0x40300000,
+        0x40500000, 0x40700000, 0x40900000, 0x40b00000, 0x40d00000, 0x40f00000, 0x41100000, 0x0,
+        // 1
+        0x0,        0x3d6fb9c9, 0x3d8fc35f, 0x3daf9169, 0x3dcf49ab, 0x3deee849, 0x3e0f0ee8, 0x3e2e4984,
+        0x3e4d2f8e, 0x3e6bb32e, 0x3e8c51cd, 0x3ea96163, 0x3ec543f1, 0x3edfd735, 0x3f028438, 0x3f18abf0,
+        0x3f2bc480, 0x3f3bec1c, 0x3f4f2e5b, 0x3f613c53, 0x3f6ce37d, 0x3f743c4f, 0x3f7a5feb, 0x3f7dea85,
+        0x3f7f3b3d, 0x3f7fb78c, 0x3f7fefd4, 0x3f7ffdd0, 0x3f7fffb4, 0x3f7ffff6, 0x3f7fffff, 0x3f800000,
+        // 2
+        0x3f800000, 0x3f7f1f84, 0x3f7ebd11, 0x3f7e1e5f, 0x3f7d609f, 0x3f7c842d, 0x3f7b00e5, 0x3f789580,
+        0x3f75b8ad, 0x3f726fd9, 0x3f6cc59b, 0x3f63fb92, 0x3f59ff97, 0x3f4f11d7, 0x3f3d7573, 0x3f24f360,
+        0x3f0cbfe7, 0x3eec1a69, 0x3eb0a801, 0x3e6753a2, 0x3e132f1a, 0x3db7e7d3, 0x3d320845, 0x3c84d3d4,
+        0x3bc477b7, 0x3b10d3da, 0x3a01601e, 0x388c1a3b, 0x3717b0da, 0x35a43bce, 0x338306c6, 0x0,
+        // 3
+        0xb0343c7b, 0xbd6ee69d, 0xbd8f0da7, 0xbdae477d, 0xbdcd2a1f, 0xbdeba80d, 0xbe0c443b, 0xbe293cf3,
+        0xbe44f282, 0xbe5f3651, 0xbe81c7c0, 0xbe96d7ca, 0xbea7fb8e, 0xbeb50e9e, 0xbec12efe, 0xbec4be92,
+        0xbebce070, 0xbead510e, 0xbe8ef7d6, 0xbe4b8704, 0xbe083237, 0xbdaf7449, 0xbd2e1ec4, 0xbc83bf06,
+        0xbbc3e0b5, 0xbb10aadc, 0xba0157db, 0xb88c18f2, 0xb717b096, 0xb5a43bae, 0xb383012c, 0x0,
+        // 4
+        0xbeaaaaa5, 0xbeab0612, 0xbea7f01f, 0xbea4e120, 0xbea387b7, 0xbea15962, 0xbe9d57f7, 0xbe976b5a,
+        0xbe90230d, 0xbe880dff, 0xbe7479b3, 0xbe4c3d88, 0xbe212482, 0xbdeb8cba, 0xbd5e78ad, 0x3c6b5e6e,
+        0x3d839143, 0x3dc21ee1, 0x3de347af, 0x3dcbec96, 0x3d99ef2d, 0x3d542ea1, 0x3cdde701, 0x3c2cca67,
+        0x3b81cb27, 0x3ac073a1, 0x39ac3032, 0x383a94d9, 0x36ca081d, 0x355abd4c, 0x332b3cb6, 0x0,
+        // 5
+        0xb76dd6b9, 0xbe1c276d, 0x3c1dcf2f, 0x3dc1a78d, 0x3d96f985, 0x3da2b61b, 0x3dc13397, 0x3dd2f670,
+        0x3df48a0a, 0x3e06c5a8, 0x3e1a3aba, 0x3e27c405, 0x3e2e78d0, 0x3e2c3e44, 0x3e1d3097, 0x3df4a8f4,
+        0x3da38508, 0x3d31416a, 0x3b562657, 0xbcaeeac9, 0xbcce9419, 0xbcaaeac4, 0xbc49e7d0, 0xbba71ddd,
+        0xbb003b0e, 0xba3f9a05, 0xb92c08a7, 0xb7ba9232, 0xb64a0b0f, 0xb4dac169, 0xb2ab78ac, 0x0,
+        // 6
+        0x3e0910e9, 0x43761143, 0x4165ecdc, 0xc190f756, 0xc08c097d, 0xc02ba813, 0xbf7f6bda, 0x3f2b1dc0,
+        0x3ece105d, 0x3f426a94, 0xbadb0dc4, 0x3da43b17, 0xbd51ab88, 0xbcaea23d, 0xbd3b6d8d, 0xbd6caaad,
+        0xbd795bed, 0xbd5fddda, 0xbd038f3b, 0xbc1cad63, 0x3abb4766, 0x3b95f10b, 0x3b825873, 0x3afaea66,
+        0x3a49f878, 0x39996bf3, 0x388f3e6c, 0x371bb0e3, 0x35a8a5e6, 0x34369b17, 0x322487b0, 0x0,
+        // 7
+        0xbc0e2f66, 0x460bda12, 0x43d638ef, 0xc3e11c3e, 0xc2baa4e9, 0xc249da2d, 0xc1859b82, 0x40dd5b57,
+        0x40494640, 0x40c730a8, 0xbf0f160e, 0x3e30e76f, 0xbea81387, 0xbdb26a1c, 0xbd351e57, 0xbb4c01a0,
+        0x3c1d7bfb, 0x3c722cd1, 0x3c973f1c, 0x3c33a31b, 0x3b862ef4, 0x3a27b3d0, 0xba3b5907, 0xba0efc22,
+        0xb97f9f0f, 0xb8c8af50, 0xb7bdddfb, 0xb64f2950, 0xb4e085b1, 0xb3731dfa, 0xb15a1f04, 0x0
+    };
+#endif // defined(TANHF_TRANSPOSED_LUT)
+
+    const int nlanes = npyv_nlanes_f32;
+    const npyv_f32 qnan = npyv_setall_f32(NPY_NANF);
+    for (; len > 0; len -= nlanes, src += ssrc*nlanes, dst += sdst*nlanes) {
+        npyv_f32 x;
+        if (ssrc == 1) {
+            x = npyv_load_tillz_f32(src, len);
+        } else {
+            x = npyv_loadn_tillz_f32(src, ssrc, len);
+        }
+        npyv_s32 ndnan = npyv_and_s32(npyv_reinterpret_s32_f32(x), npyv_setall_s32(0x7fe00000));
+        // check |x| > HUGE_THRESHOLD, INF and NaNs.
+        npyv_b32 special_m = npyv_cmple_s32(ndnan, npyv_setall_s32(0x7f000000));
+        npyv_b32 nnan_m = npyv_notnan_f32(x);
+        npyv_s32 idxs = npyv_sub_s32(ndnan, npyv_setall_s32(0x3d400000));
+                 idxs = npyv_max_s32(idxs, npyv_zero_s32());
+                 idxs = npyv_min_s32(idxs, npyv_setall_s32(0x3e00000));
+        npyv_u32 idx  = npyv_shri_u32(npyv_reinterpret_u32_s32(idxs), 21);
+
+#if defined(TANHF_TRANSPOSED_LUT)
+        npyv_f32 c6543[npyv_nlanes_f32];
+        npyv_f32 c210b[npyv_nlanes_f32];
+        npyv_lanetype_u32 index[npyv_nlanes_f32];
+
+        /**begin repeat
+         * #lane = 0, 1, 2, 3#
+         */
+        index[@lane@] = npyv_get_lane_u32(idx, @lane@);
+        c6543[@lane@] = npyv_reinterpret_f32_u32(npyv_load_u32(lut8x32 + index[@lane@] * 8));
+        c210b[@lane@] = npyv_reinterpret_f32_u32(npyv_load_u32(lut8x32 + index[@lane@] * 8 + 4));
+        /**end repeat**/
+
+        // lane0: {c6, c5, c4, c3},  {c2, c1, c0, b}
+        // lane1: {c6, c5, c4, c3},  {c2, c1, c0, b}
+        // lane2: {c6, c5, c4, c3},  {c2, c1, c0, b}
+        // lane3: {c6, c5, c4, c3},  {c2, c1, c0, b}
+        //
+        // transposed:
+        // c6: {lane0, lane1, lane2, lane3}
+        // c5: {lane0, lane1, lane2, lane3}
+        // c4: {lane0, lane1, lane2, lane3}
+        // c3: {lane0, lane1, lane2, lane3}
+        // c2: {lane0, lane1, lane2, lane3}
+        // c1: {lane0, lane1, lane2, lane3}
+        // c0: {lane0, lane1, lane2, lane3}
+        // b : {lane0, lane1, lane2, lane3}
+
+        npyv_f32x2 c6543_l01 = npyv_zip_f32(c6543[0], c6543[1]);
+        npyv_f32x2 c6543_l23 = npyv_zip_f32(c6543[2], c6543[3]);
+        npyv_f32 c6 = npyv_combinel_f32(c6543_l01.val[0], c6543_l23.val[0]);
+        npyv_f32 c5 = npyv_combineh_f32(c6543_l01.val[0], c6543_l23.val[0]);
+        npyv_f32 c4 = npyv_combinel_f32(c6543_l01.val[1], c6543_l23.val[1]);
+        npyv_f32 c3 = npyv_combineh_f32(c6543_l01.val[1], c6543_l23.val[1]);
+
+        npyv_f32x2 c210b_l01 = npyv_zip_f32(c210b[0], c210b[1]);
+        npyv_f32x2 c210b_l23 = npyv_zip_f32(c210b[2], c210b[3]);
+        npyv_f32 c2 = npyv_combinel_f32(c210b_l01.val[0], c210b_l23.val[0]);
+        npyv_f32 c1 = npyv_combineh_f32(c210b_l01.val[0], c210b_l23.val[0]);
+        npyv_f32 c0 = npyv_combinel_f32(c210b_l01.val[1], c210b_l23.val[1]);
+        npyv_f32 b  = npyv_combineh_f32(c210b_l01.val[1], c210b_l23.val[1]);
+#else
+        npyv_f32 b  = npyv_lut32_f32((const float*)lut32x8 + 32*0, idx);
+        npyv_f32 c0 = npyv_lut32_f32((const float*)lut32x8 + 32*1, idx);
+        npyv_f32 c1 = npyv_lut32_f32((const float*)lut32x8 + 32*2, idx);
+        npyv_f32 c2 = npyv_lut32_f32((const float*)lut32x8 + 32*3, idx);
+        npyv_f32 c3 = npyv_lut32_f32((const float*)lut32x8 + 32*4, idx);
+        npyv_f32 c4 = npyv_lut32_f32((const float*)lut32x8 + 32*5, idx);
+        npyv_f32 c5 = npyv_lut32_f32((const float*)lut32x8 + 32*6, idx);
+        npyv_f32 c6 = npyv_lut32_f32((const float*)lut32x8 + 32*7, idx);
+#endif // defined(TANHF_TRANSPOSED_LUT)
+
+        // no need to zerofy nans or avoid FP exceptions by NO_EXC like SVML does
+        // since we're clearing the FP status anyway.
+        npyv_f32 sign = npyv_and_f32(x, npyv_reinterpret_f32_u32(npyv_setall_u32(0x80000000)));
+        npyv_f32 y = npyv_sub_f32(npyv_abs_f32(x), b);
+        npyv_f32 r = npyv_muladd_f32(c6, y, c5);
+        r = npyv_muladd_f32(r, y, c4);
+        r = npyv_muladd_f32(r, y, c3);
+        r = npyv_muladd_f32(r, y, c2);
+        r = npyv_muladd_f32(r, y, c1);
+        r = npyv_muladd_f32(r, y, c0);
+        // 1.0 if |x| > HUGE_THRESHOLD || INF
+        r = npyv_select_f32(special_m, r, npyv_setall_f32(1.0f));
+        r = npyv_or_f32(r, sign);
+        // qnan if nan
+        r = npyv_select_f32(nnan_m, r, qnan);
+        if (sdst == 1) {
+            npyv_store_till_f32(dst, len, r);
+        } else {
+            npyv_storen_till_f32(dst, sdst, len, r);
+        }
+    }
+}
+
+#undef TANHF_TRANSPOSED_LUT
+#if defined(UNDEF_npyv_get_lane_u32)
+#undef UNDEF_npyv_get_lane_u32
+#undef npyv_get_lane_u32
+#endif
+
+#endif // NPY_SIMD_F32
+#endif // NPY_SIMD_FMA3
+
+/**begin repeat
+ * #TYPE = FLOAT, DOUBLE#
+ * #type = float, double#
+ * #sfx  = f32,   f64#
+ * #ssfx = f,     #
+ * #simd = NPY_SIMD_FMA3 && NPY_SIMD_F32, NPY_SIMD_FMA3 && NPY_SIMD_F64#
+ */
+/**begin repeat1
+ *  #func = tanh#
+ *  #simd_req_clear = 1#
+ */
+NPY_NO_EXPORT void NPY_CPU_DISPATCH_CURFX(@TYPE@_@func@)
+(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(data))
+{
+    const @type@ *src = (@type@*)args[0];
+          @type@ *dst = (@type@*)args[1];
+
+    const int lsize = sizeof(src[0]);
+    const npy_intp ssrc = steps[0] / lsize;
+    const npy_intp sdst = steps[1] / lsize;
+    npy_intp len = dimensions[0];
+    assert(len <= 1 || (steps[0] % lsize == 0 && steps[1] % lsize == 0));
+#if @simd@
+    if (is_mem_overlap(src, steps[0], dst, steps[1], len) ||
+        !npyv_loadable_stride_@sfx@(ssrc) || !npyv_storable_stride_@sfx@(sdst)
+    ) {
+        for (; len > 0; --len, src += ssrc, dst += sdst) {
+            simd_@func@_@sfx@(src, 1, dst, 1, 1);
+        }
+    } else {
+        simd_@func@_@sfx@(src, ssrc, dst, sdst, len);
+    }
+    npyv_cleanup();
+    #if @simd_req_clear@
+        npy_clear_floatstatus_barrier((char*)dimensions);
+    #endif
+#else
+    for (; len > 0; --len, src += ssrc, dst += sdst) {
+        const @type@ src0 = *src;
+        *dst = npy_@func@@ssfx@(src0);
+    }
+#endif
+}
+/**end repeat1**/
+/**end repeat**/
diff --git a/numpy/core/src/umath/loops_minmax.dispatch.c.src b/numpy/core/src/umath/loops_minmax.dispatch.c.src
new file mode 100644
index 000000000000..237c8e933b40
--- /dev/null
+++ b/numpy/core/src/umath/loops_minmax.dispatch.c.src
@@ -0,0 +1,459 @@
+/*@targets
+ ** $maxopt baseline
+ ** neon asimd
+ ** sse2 avx2 avx512_skx
+ ** vsx2
+ ** vx vxe
+ **/
+#define _UMATHMODULE
+#define _MULTIARRAYMODULE
+#define NPY_NO_DEPRECATED_API NPY_API_VERSION
+
+#include "simd/simd.h"
+#include "loops_utils.h"
+#include "loops.h"
+#include "lowlevel_strided_loops.h"
+// Provides the various *_LOOP macros
+#include "fast_loop_macros.h"
+
+/*******************************************************************************
+ ** Scalar intrinsics
+ ******************************************************************************/
+// signed/unsigned int
+#define scalar_max_i(A, B) ((A > B) ? A : B)
+#define scalar_min_i(A, B) ((A < B) ? A : B)
+// fp, propagates NaNs
+#define scalar_max(A, B) ((A >= B || npy_isnan(A)) ? A : B)
+#define scalar_max_f scalar_max
+#define scalar_max_d scalar_max
+#define scalar_max_l scalar_max
+#define scalar_min(A, B) ((A <= B || npy_isnan(A)) ? A : B)
+#define scalar_min_f scalar_min
+#define scalar_min_d scalar_min
+#define scalar_min_l scalar_min
+// fp, ignores NaNs
+#define scalar_maxp_f fmaxf
+#define scalar_maxp_d fmax
+#define scalar_maxp_l fmaxl
+#define scalar_minp_f fminf
+#define scalar_minp_d fmin
+#define scalar_minp_l fminl
+
+// special optimization for fp scalars propagates NaNs
+// since there're no C99 support for it
+#ifndef NPY_DISABLE_OPTIMIZATION
+/**begin repeat
+ * #type = npy_float, npy_double#
+ * #sfx = f32, f64#
+ * #c_sfx = f, d#
+ * #isa_sfx = s, d#
+ * #sse_type = __m128, __m128d#
+ */
+/**begin repeat1
+ * #op = max, min#
+ * #neon_instr = fmax, fmin#
+ */
+#ifdef NPY_HAVE_SSE2
+#undef scalar_@op@_@c_sfx@
+NPY_FINLINE @type@ scalar_@op@_@c_sfx@(@type@ a, @type@ b) {
+    @sse_type@ va = _mm_set_s@isa_sfx@(a);
+    @sse_type@ vb = _mm_set_s@isa_sfx@(b);
+    @sse_type@ rv = _mm_@op@_s@isa_sfx@(va, vb);
+    // X86 handle second operand
+    @sse_type@ nn = _mm_cmpord_s@isa_sfx@(va, va);
+    #ifdef NPY_HAVE_SSE41
+    rv = _mm_blendv_p@isa_sfx@(va, rv, nn);
+    #else
+    rv = _mm_xor_p@isa_sfx@(va, _mm_and_p@isa_sfx@(_mm_xor_p@isa_sfx@(va, rv), nn));
+    #endif
+    return _mm_cvts@isa_sfx@_@sfx@(rv);
+}
+#endif // SSE2
+#ifdef __aarch64__
+#undef scalar_@op@_@c_sfx@
+NPY_FINLINE @type@ scalar_@op@_@c_sfx@(@type@ a, @type@ b) {
+    @type@ result = 0;
+    __asm(
+        "@neon_instr@ %@isa_sfx@[result], %@isa_sfx@[a], %@isa_sfx@[b]"
+        : [result] "=w" (result)
+        : [a] "w" (a), [b] "w" (b)
+    );
+    return result;
+}
+#endif // __aarch64__
+/**end repeat1**/
+/**end repeat**/
+#endif // NPY_DISABLE_OPTIMIZATION
+// mapping to double if its possible
+#if NPY_BITSOF_DOUBLE == NPY_BITSOF_LONGDOUBLE
+/**begin repeat
+ * #op = max, min, maxp, minp#
+ */
+    #undef scalar_@op@_l
+    #define scalar_@op@_l scalar_@op@_d
+/**end repeat**/
+#endif
+
+/*******************************************************************************
+ ** Defining the SIMD kernels
+ ******************************************************************************/
+/**begin repeat
+ * #sfx = s8, u8, s16, u16, s32, u32, s64, u64, f32, f64#
+ * #simd_chk = NPY_SIMD*8, NPY_SIMD_F32, NPY_SIMD_F64#
+ * #is_fp = 0*8, 1, 1#
+ * #scalar_sfx = i*8, f, d#
+ */
+/**begin repeat1
+ * # intrin = max, min, maxp, minp#
+ * # fp_only = 0, 0, 1, 1#
+ */
+#define SCALAR_OP scalar_@intrin@_@scalar_sfx@
+#if @simd_chk@ && (!@fp_only@ || (@is_fp@ && @fp_only@))
+
+#if @is_fp@ && !@fp_only@
+    #define V_INTRIN npyv_@intrin@n_@sfx@ // propagates NaNs
+    #define V_REDUCE_INTRIN npyv_reduce_@intrin@n_@sfx@
+#else
+    #define V_INTRIN npyv_@intrin@_@sfx@
+    #define V_REDUCE_INTRIN npyv_reduce_@intrin@_@sfx@
+#endif
+
+// contiguous input.
+static inline void
+simd_reduce_c_@intrin@_@sfx@(const npyv_lanetype_@sfx@ *ip, npyv_lanetype_@sfx@ *op1, npy_intp len)
+{
+    if (len < 1) {
+        return;
+    }
+    const int vstep = npyv_nlanes_@sfx@;
+    const int wstep = vstep*8;
+    npyv_@sfx@ acc = npyv_setall_@sfx@(op1[0]);
+    for (; len >= wstep; len -= wstep, ip += wstep) {
+    #ifdef NPY_HAVE_SSE2
+        NPY_PREFETCH(ip + wstep, 0, 3);
+    #endif
+        npyv_@sfx@ v0 = npyv_load_@sfx@(ip + vstep * 0);
+        npyv_@sfx@ v1 = npyv_load_@sfx@(ip + vstep * 1);
+        npyv_@sfx@ v2 = npyv_load_@sfx@(ip + vstep * 2);
+        npyv_@sfx@ v3 = npyv_load_@sfx@(ip + vstep * 3);
+
+        npyv_@sfx@ v4 = npyv_load_@sfx@(ip + vstep * 4);
+        npyv_@sfx@ v5 = npyv_load_@sfx@(ip + vstep * 5);
+        npyv_@sfx@ v6 = npyv_load_@sfx@(ip + vstep * 6);
+        npyv_@sfx@ v7 = npyv_load_@sfx@(ip + vstep * 7);
+
+        npyv_@sfx@ r01 = V_INTRIN(v0, v1);
+        npyv_@sfx@ r23 = V_INTRIN(v2, v3);
+        npyv_@sfx@ r45 = V_INTRIN(v4, v5);
+        npyv_@sfx@ r67 = V_INTRIN(v6, v7);
+        acc = V_INTRIN(acc, V_INTRIN(V_INTRIN(r01, r23), V_INTRIN(r45, r67)));
+    }
+    for (; len >= vstep; len -= vstep, ip += vstep) {
+        acc = V_INTRIN(acc, npyv_load_@sfx@(ip));
+    }
+    npyv_lanetype_@sfx@ r = V_REDUCE_INTRIN(acc);
+    // Scalar - finish up any remaining iterations
+    for (; len > 0; --len, ++ip) {
+        const npyv_lanetype_@sfx@ in2 = *ip;
+        r = SCALAR_OP(r, in2);
+    }
+    op1[0] = r;
+}
+
+// contiguous inputs and output.
+static inline void
+simd_binary_ccc_@intrin@_@sfx@(const npyv_lanetype_@sfx@ *ip1, const npyv_lanetype_@sfx@ *ip2,
+                                     npyv_lanetype_@sfx@ *op1, npy_intp len)
+{
+#if NPY_SIMD_WIDTH == 128
+    // Note, 6x unroll was chosen for best results on Apple M1
+    const int vectorsPerLoop = 6;
+#else
+    // To avoid memory bandwidth bottleneck
+    const int vectorsPerLoop = 2;
+#endif
+    const int elemPerVector = npyv_nlanes_@sfx@;
+    int elemPerLoop = vectorsPerLoop * elemPerVector;
+
+    npy_intp i = 0;
+
+    for (; (i+elemPerLoop) <= len; i += elemPerLoop) {
+        npyv_@sfx@ v0 = npyv_load_@sfx@(&ip1[i + 0 * elemPerVector]);
+        npyv_@sfx@ v1 = npyv_load_@sfx@(&ip1[i + 1 * elemPerVector]);
+    #if NPY_SIMD_WIDTH == 128
+        npyv_@sfx@ v2 = npyv_load_@sfx@(&ip1[i + 2 * elemPerVector]);
+        npyv_@sfx@ v3 = npyv_load_@sfx@(&ip1[i + 3 * elemPerVector]);
+        npyv_@sfx@ v4 = npyv_load_@sfx@(&ip1[i + 4 * elemPerVector]);
+        npyv_@sfx@ v5 = npyv_load_@sfx@(&ip1[i + 5 * elemPerVector]);
+    #endif
+        npyv_@sfx@ u0 = npyv_load_@sfx@(&ip2[i + 0 * elemPerVector]);
+        npyv_@sfx@ u1 = npyv_load_@sfx@(&ip2[i + 1 * elemPerVector]);
+    #if NPY_SIMD_WIDTH == 128
+        npyv_@sfx@ u2 = npyv_load_@sfx@(&ip2[i + 2 * elemPerVector]);
+        npyv_@sfx@ u3 = npyv_load_@sfx@(&ip2[i + 3 * elemPerVector]);
+        npyv_@sfx@ u4 = npyv_load_@sfx@(&ip2[i + 4 * elemPerVector]);
+        npyv_@sfx@ u5 = npyv_load_@sfx@(&ip2[i + 5 * elemPerVector]);
+    #endif
+        npyv_@sfx@ m0 = V_INTRIN(v0, u0);
+        npyv_@sfx@ m1 = V_INTRIN(v1, u1);
+    #if NPY_SIMD_WIDTH == 128
+        npyv_@sfx@ m2 = V_INTRIN(v2, u2);
+        npyv_@sfx@ m3 = V_INTRIN(v3, u3);
+        npyv_@sfx@ m4 = V_INTRIN(v4, u4);
+        npyv_@sfx@ m5 = V_INTRIN(v5, u5);
+    #endif
+        npyv_store_@sfx@(&op1[i + 0 * elemPerVector], m0);
+        npyv_store_@sfx@(&op1[i + 1 * elemPerVector], m1);
+    #if NPY_SIMD_WIDTH == 128
+        npyv_store_@sfx@(&op1[i + 2 * elemPerVector], m2);
+        npyv_store_@sfx@(&op1[i + 3 * elemPerVector], m3);
+        npyv_store_@sfx@(&op1[i + 4 * elemPerVector], m4);
+        npyv_store_@sfx@(&op1[i + 5 * elemPerVector], m5);
+    #endif
+    }
+    for (; (i+elemPerVector) <= len; i += elemPerVector) {
+        npyv_@sfx@ v0 = npyv_load_@sfx@(ip1 + i);
+        npyv_@sfx@ u0 = npyv_load_@sfx@(ip2 + i);
+        npyv_@sfx@ m0 = V_INTRIN(v0, u0);
+        npyv_store_@sfx@(op1 + i, m0);
+    }
+    // Scalar - finish up any remaining iterations
+    for (; i < len; ++i) {
+        const npyv_lanetype_@sfx@ in1 = ip1[i];
+        const npyv_lanetype_@sfx@ in2 = ip2[i];
+        op1[i] = SCALAR_OP(in1, in2);
+    }
+}
+// non-contiguous for float 32/64-bit memory access
+#if @is_fp@
+static inline void
+simd_binary_@intrin@_@sfx@(const npyv_lanetype_@sfx@ *ip1, npy_intp sip1,
+                           const npyv_lanetype_@sfx@ *ip2, npy_intp sip2,
+                                 npyv_lanetype_@sfx@ *op1, npy_intp sop1,
+                                 npy_intp len)
+{
+    const int vstep = npyv_nlanes_@sfx@;
+    for (; len >= vstep; len -= vstep, ip1 += sip1*vstep,
+                         ip2 += sip2*vstep, op1 += sop1*vstep
+    ) {
+        npyv_@sfx@ a, b;
+        if (sip1 == 1) {
+            a = npyv_load_@sfx@(ip1);
+        } else {
+            a = npyv_loadn_@sfx@(ip1, sip1);
+        }
+        if (sip2 == 1) {
+            b = npyv_load_@sfx@(ip2);
+        } else {
+            b = npyv_loadn_@sfx@(ip2, sip2);
+        }
+        npyv_@sfx@ r = V_INTRIN(a, b);
+        if (sop1 == 1) {
+            npyv_store_@sfx@(op1, r);
+        } else {
+            npyv_storen_@sfx@(op1, sop1, r);
+        }
+    }
+    for (; len > 0; --len, ip1 += sip1, ip2 += sip2, op1 += sop1) {
+        const npyv_lanetype_@sfx@ a = *ip1;
+        const npyv_lanetype_@sfx@ b = *ip2;
+        *op1 = SCALAR_OP(a, b);
+    }
+}
+#endif
+
+#undef V_INTRIN
+#undef V_REDUCE_INTRIN
+
+#endif // simd_chk && (!fp_only || (is_fp && fp_only))
+
+#undef SCALAR_OP
+/**end repeat1**/
+/**end repeat**/
+
+/*******************************************************************************
+ ** Defining ufunc inner functions
+ ******************************************************************************/
+/**begin repeat
+ * #TYPE = UBYTE, USHORT, UINT, ULONG, ULONGLONG,
+ *         BYTE, SHORT, INT, LONG, LONGLONG,
+ *         FLOAT, DOUBLE, LONGDOUBLE#
+ *
+ * #BTYPE = BYTE, SHORT, INT,  LONG, LONGLONG,
+ *          BYTE, SHORT, INT, LONG, LONGLONG,
+ *          FLOAT, DOUBLE, LONGDOUBLE#
+ * #type = npy_ubyte, npy_ushort, npy_uint, npy_ulong, npy_ulonglong,
+ *         npy_byte, npy_short, npy_int, npy_long, npy_longlong,
+ *         npy_float, npy_double, npy_longdouble#
+ *
+ * #is_fp = 0*10, 1*3#
+ * #is_unsigned = 1*5, 0*5, 0*3#
+ * #scalar_sfx = i*10, f, d, l#
+ */
+#undef TO_SIMD_SFX
+#if 0
+/**begin repeat1
+ * #len = 8, 16, 32, 64#
+ */
+#elif NPY_SIMD && NPY_BITSOF_@BTYPE@ == @len@
+    #if @is_fp@
+        #define TO_SIMD_SFX(X) X##_f@len@
+        #if NPY_BITSOF_@BTYPE@ == 32 && !NPY_SIMD_F32
+            #undef TO_SIMD_SFX
+        #endif
+        #if NPY_BITSOF_@BTYPE@ == 64 && !NPY_SIMD_F64
+            #undef TO_SIMD_SFX
+        #endif
+    #elif @is_unsigned@
+        #define TO_SIMD_SFX(X) X##_u@len@
+    #else
+        #define TO_SIMD_SFX(X) X##_s@len@
+    #endif
+/**end repeat1**/
+#endif
+
+/**begin repeat1
+ * # kind = maximum, minimum, fmax, fmin#
+ * # intrin = max, min, maxp, minp#
+ * # fp_only = 0, 0, 1, 1#
+ */
+#if !@fp_only@ || (@is_fp@ && @fp_only@)
+#define SCALAR_OP scalar_@intrin@_@scalar_sfx@
+
+NPY_NO_EXPORT void NPY_CPU_DISPATCH_CURFX(@TYPE@_@kind@)
+(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func))
+{
+    char *ip1 = args[0], *ip2 = args[1], *op1 = args[2];
+    npy_intp is1 = steps[0], is2 = steps[1], os1 = steps[2],
+             len = dimensions[0];
+    npy_intp i = 0;
+#ifdef TO_SIMD_SFX
+    #undef STYPE
+    #define STYPE TO_SIMD_SFX(npyv_lanetype)
+    if (IS_BINARY_REDUCE) {
+        // reduce and contiguous
+        if (is2 == sizeof(@type@)) {
+            TO_SIMD_SFX(simd_reduce_c_@intrin@)(
+                (STYPE*)ip2, (STYPE*)op1, len
+            );
+            goto clear_fp;
+        }
+    }
+    else if (!is_mem_overlap(ip1, is1, op1, os1, len) &&
+        !is_mem_overlap(ip2, is2, op1, os1, len)
+    ) {
+        // no overlap and operands are binary contiguous
+        if (IS_BINARY_CONT(@type@, @type@)) {
+            TO_SIMD_SFX(simd_binary_ccc_@intrin@)(
+                (STYPE*)ip1, (STYPE*)ip2, (STYPE*)op1, len
+            );
+            goto clear_fp;
+        }
+    // unroll scalars faster than non-contiguous vector load/store on Arm
+    #if !defined(NPY_HAVE_NEON) && @is_fp@
+        if (TO_SIMD_SFX(npyv_loadable_stride)(is1/sizeof(STYPE)) &&
+            TO_SIMD_SFX(npyv_loadable_stride)(is2/sizeof(STYPE)) &&
+            TO_SIMD_SFX(npyv_storable_stride)(os1/sizeof(STYPE))
+        ) {
+            TO_SIMD_SFX(simd_binary_@intrin@)(
+                (STYPE*)ip1, is1/sizeof(STYPE),
+                (STYPE*)ip2, is2/sizeof(STYPE),
+                (STYPE*)op1, os1/sizeof(STYPE), len
+            );
+            goto clear_fp;
+        }
+    #endif
+    }
+#endif // TO_SIMD_SFX
+#ifndef NPY_DISABLE_OPTIMIZATION
+    // scalar unrolls
+    if (IS_BINARY_REDUCE) {
+        // Note, 8x unroll was chosen for best results on Apple M1
+        npy_intp elemPerLoop = 8;
+        if((i+elemPerLoop) <= len){
+            @type@ m0 = *((@type@ *)(ip2 + (i + 0) * is2));
+            @type@ m1 = *((@type@ *)(ip2 + (i + 1) * is2));
+            @type@ m2 = *((@type@ *)(ip2 + (i + 2) * is2));
+            @type@ m3 = *((@type@ *)(ip2 + (i + 3) * is2));
+            @type@ m4 = *((@type@ *)(ip2 + (i + 4) * is2));
+            @type@ m5 = *((@type@ *)(ip2 + (i + 5) * is2));
+            @type@ m6 = *((@type@ *)(ip2 + (i + 6) * is2));
+            @type@ m7 = *((@type@ *)(ip2 + (i + 7) * is2));
+
+            i += elemPerLoop;
+            for(; (i+elemPerLoop)<=len; i+=elemPerLoop){
+                @type@ v0 = *((@type@ *)(ip2 + (i + 0) * is2));
+                @type@ v1 = *((@type@ *)(ip2 + (i + 1) * is2));
+                @type@ v2 = *((@type@ *)(ip2 + (i + 2) * is2));
+                @type@ v3 = *((@type@ *)(ip2 + (i + 3) * is2));
+                @type@ v4 = *((@type@ *)(ip2 + (i + 4) * is2));
+                @type@ v5 = *((@type@ *)(ip2 + (i + 5) * is2));
+                @type@ v6 = *((@type@ *)(ip2 + (i + 6) * is2));
+                @type@ v7 = *((@type@ *)(ip2 + (i + 7) * is2));
+
+                m0 = SCALAR_OP(m0, v0);
+                m1 = SCALAR_OP(m1, v1);
+                m2 = SCALAR_OP(m2, v2);
+                m3 = SCALAR_OP(m3, v3);
+                m4 = SCALAR_OP(m4, v4);
+                m5 = SCALAR_OP(m5, v5);
+                m6 = SCALAR_OP(m6, v6);
+                m7 = SCALAR_OP(m7, v7);
+            }
+
+            m0 = SCALAR_OP(m0, m1);
+            m2 = SCALAR_OP(m2, m3);
+            m4 = SCALAR_OP(m4, m5);
+            m6 = SCALAR_OP(m6, m7);
+
+            m0 = SCALAR_OP(m0, m2);
+            m4 = SCALAR_OP(m4, m6);
+
+            m0 = SCALAR_OP(m0, m4);
+
+             *((@type@ *)op1) = SCALAR_OP(*((@type@ *)op1), m0);
+        }
+    } else{
+        // Note, 4x unroll was chosen for best results on Apple M1
+        npy_intp elemPerLoop = 4;
+        for(; (i+elemPerLoop)<=len; i+=elemPerLoop){
+            /* Note, we can't just load all, do all ops, then store all here.
+             * Sometimes ufuncs are called with `accumulate`, which makes the
+             * assumption that previous iterations have finished before next
+             * iteration.  For example, the output of iteration 2 depends on the
+             * result of iteration 1.
+             */
+
+            /**begin repeat2
+             * #unroll = 0, 1, 2, 3#
+             */
+            @type@ v@unroll@ = *((@type@ *)(ip1 + (i + @unroll@) * is1));
+            @type@ u@unroll@ = *((@type@ *)(ip2 + (i + @unroll@) * is2));
+            *((@type@ *)(op1 + (i + @unroll@) * os1)) = SCALAR_OP(v@unroll@, u@unroll@);
+            /**end repeat2**/
+        }
+    }
+#endif // NPY_DISABLE_OPTIMIZATION
+    ip1 += is1 * i;
+    ip2 += is2 * i;
+    op1 += os1 * i;
+    for (; i < len; ++i, ip1 += is1, ip2 += is2, op1 += os1) {
+        const @type@ in1 = *(@type@ *)ip1;
+        const @type@ in2 = *(@type@ *)ip2;
+        *((@type@ *)op1) = SCALAR_OP(in1, in2);
+    }
+#ifdef TO_SIMD_SFX
+clear_fp:
+    npyv_cleanup();
+#endif
+#if @is_fp@
+    npy_clear_floatstatus_barrier((char*)dimensions);
+#endif
+}
+
+#undef SCALAR_OP
+
+#endif // !fp_only || (is_fp && fp_only)
+/**end repeat1**/
+/**end repeat**/
+
diff --git a/numpy/core/src/umath/loops_modulo.dispatch.c.src b/numpy/core/src/umath/loops_modulo.dispatch.c.src
new file mode 100644
index 000000000000..53b7da2892b0
--- /dev/null
+++ b/numpy/core/src/umath/loops_modulo.dispatch.c.src
@@ -0,0 +1,676 @@
+/*@targets
+ ** baseline vsx4
+ **/
+#define _UMATHMODULE
+#define _MULTIARRAYMODULE
+#define NPY_NO_DEPRECATED_API NPY_API_VERSION
+
+#include "simd/simd.h"
+#include "loops_utils.h"
+#include "loops.h"
+#include "lowlevel_strided_loops.h"
+// Provides the various *_LOOP macros
+#include "fast_loop_macros.h"
+
+
+#define DIVIDEBYZERO_OVERFLOW_CHECK(x, y, min_val, signed) \
+    (NPY_UNLIKELY(                                         \
+        (signed)                                    ?      \
+        ((y == 0) || ((x == min_val) && (y == -1))) :      \
+        (y == 0))                                          \
+    )
+
+#define FLAG_IF_DIVIDEBYZERO(x) do {     \
+    if (NPY_UNLIKELY(x == 0)) {          \
+        npy_set_floatstatus_divbyzero(); \
+    }                                    \
+} while (0)
+
+
+#if NPY_SIMD && defined(NPY_HAVE_VSX4)
+typedef struct {
+    npyv_u32x2 hi;
+    npyv_u32x2 lo;
+} vsx4_u32x4;
+
+typedef struct {
+    npyv_s32x2 hi;
+    npyv_s32x2 lo;
+} vsx4_s32x4;
+
+// Converts 1 8-bit vector into 2 16-bit vectors
+NPY_FINLINE npyv_s16x2
+vsx4_expand_s16_s8(npyv_s8 data)
+{
+    npyv_s16x2 r;
+    r.val[0] = vec_unpackh(data);
+    r.val[1] = vec_unpackl(data);
+    return r;
+}
+
+// Converts 1 16-bit vector into 2 32-bit vectors
+NPY_FINLINE npyv_s32x2
+vsx4_expand_s32_s16(npyv_s16 data)
+{
+    npyv_s32x2 r;
+    r.val[0] = vec_unpackh(data);
+    r.val[1] = vec_unpackl(data);
+    return r;
+}
+
+/**begin repeat
+ * #t = u, s#
+ * #expand = npyv_expand, vsx4_expand#
+ */
+// Converts 1 8-bit vector into 4 32-bit vectors
+NPY_FINLINE vsx4_@t@32x4
+vsx4_expand_@t@32_@t@8(npyv_@t@8 data)
+{
+    vsx4_@t@32x4 r;
+    npyv_@t@16x2 expand = @expand@_@t@16_@t@8(data);
+    r.hi = @expand@_@t@32_@t@16(expand.val[0]);
+    r.lo = @expand@_@t@32_@t@16(expand.val[1]);
+    return r;
+}
+
+/**begin repeat1
+ * #simd = div, mod##
+ */
+/*
+ * Computes division/modulo of 2 8-bit signed/unsigned integer vectors
+ *
+ * As Power10 only supports integer vector division/modulo for data of 32 bits
+ * or greater, we have to convert npyv_u8 into 4x npyv_u32, execute the integer
+ * vector division/modulo instruction, and then, convert the result back to
+ * npyv_u8.
+ */
+NPY_FINLINE npyv_@t@8
+vsx4_@simd@_@t@8(npyv_@t@8 a, npyv_@t@8 b)
+{
+    vsx4_@t@32x4 a_expand = vsx4_expand_@t@32_@t@8(a);
+    vsx4_@t@32x4 b_expand = vsx4_expand_@t@32_@t@8(b);
+    npyv_@t@32 v1 = vec_@simd@(a_expand.hi.val[0], b_expand.hi.val[0]);
+    npyv_@t@32 v2 = vec_@simd@(a_expand.hi.val[1], b_expand.hi.val[1]);
+    npyv_@t@32 v3 = vec_@simd@(a_expand.lo.val[0], b_expand.lo.val[0]);
+    npyv_@t@32 v4 = vec_@simd@(a_expand.lo.val[1], b_expand.lo.val[1]);
+    npyv_@t@16 hi = vec_pack(v1, v2);
+    npyv_@t@16 lo = vec_pack(v3, v4);
+    return vec_pack(hi, lo);
+}
+
+NPY_FINLINE npyv_@t@8
+vsx4_@simd@_scalar_@t@8(npyv_@t@8 a, const vsx4_@t@32x4 b_expand)
+{
+    vsx4_@t@32x4 a_expand = vsx4_expand_@t@32_@t@8(a);
+    npyv_@t@32 v1 = vec_@simd@(a_expand.hi.val[0], b_expand.hi.val[0]);
+    npyv_@t@32 v2 = vec_@simd@(a_expand.hi.val[1], b_expand.hi.val[1]);
+    npyv_@t@32 v3 = vec_@simd@(a_expand.lo.val[0], b_expand.lo.val[0]);
+    npyv_@t@32 v4 = vec_@simd@(a_expand.lo.val[1], b_expand.lo.val[1]);
+    npyv_@t@16 hi = vec_pack(v1, v2);
+    npyv_@t@16 lo = vec_pack(v3, v4);
+    return vec_pack(hi, lo);
+}
+
+NPY_FINLINE npyv_@t@16
+vsx4_@simd@_@t@16(npyv_@t@16 a, npyv_@t@16 b)
+{
+    npyv_@t@32x2 a_expand = @expand@_@t@32_@t@16(a);
+    npyv_@t@32x2 b_expand = @expand@_@t@32_@t@16(b);
+    npyv_@t@32 v1 = vec_@simd@(a_expand.val[0], b_expand.val[0]);
+    npyv_@t@32 v2 = vec_@simd@(a_expand.val[1], b_expand.val[1]);
+    return vec_pack(v1, v2);
+}
+
+NPY_FINLINE npyv_@t@16
+vsx4_@simd@_scalar_@t@16(npyv_@t@16 a, const npyv_@t@32x2 b_expand)
+{
+    npyv_@t@32x2 a_expand = @expand@_@t@32_@t@16(a);
+    npyv_@t@32 v1 = vec_@simd@(a_expand.val[0], b_expand.val[0]);
+    npyv_@t@32 v2 = vec_@simd@(a_expand.val[1], b_expand.val[1]);
+    return vec_pack(v1, v2);
+}
+
+#define vsx4_@simd@_@t@32 vec_@simd@
+#define vsx4_@simd@_@t@64 vec_@simd@
+#define vsx4_@simd@_scalar_@t@32 vec_@simd@
+#define vsx4_@simd@_scalar_@t@64 vec_@simd@
+/**end repeat1**/
+/**end repeat**/
+
+/**begin repeat
+ * #sfx  = u8,  u16, s8,  s16#
+ * #osfx = u32, u32, s32, s32#
+ * #otype  = vsx4_u32x4,  npyv_u32x2,  vsx4_s32x4,  npyv_s32x2#
+ * #expand = vsx4_expand, npyv_expand, vsx4_expand, vsx4_expand#
+ */
+// Generates the divisor for the division/modulo operations
+NPY_FINLINE @otype@
+vsx4_divisor_@sfx@(const npyv_@sfx@ vscalar)
+{
+    return @expand@_@osfx@_@sfx@(vscalar);
+}
+/**end repeat**/
+
+/**begin repeat
+ * #sfx = u32, u64, s32, s64#
+ */
+NPY_FINLINE npyv_@sfx@
+vsx4_divisor_@sfx@(const npyv_@sfx@ vscalar)
+{
+    return vscalar;
+}
+/**end repeat**/
+
+/**begin repeat
+ * Unsigned types
+ * #sfx = u8, u16, u32, u64#
+ * #len = 8,  16,  32,  64#
+ * #divtype = vsx4_u32x4, npyv_u32x2,  npyv_u32,  npyv_u64#
+ */
+/**begin repeat1
+ * #func = fmod, remainder, divmod#
+ * #id = 0, 1, 2#
+ */
+static NPY_INLINE void
+vsx4_simd_@func@_contig_@sfx@(char **args, npy_intp len)
+{
+    npyv_lanetype_@sfx@ *src1 = (npyv_lanetype_@sfx@ *) args[0];
+    npyv_lanetype_@sfx@ *src2 = (npyv_lanetype_@sfx@ *) args[1];
+    npyv_lanetype_@sfx@ *dst1 = (npyv_lanetype_@sfx@ *) args[2];
+    const npyv_@sfx@ vzero    = npyv_zero_@sfx@();
+    const int vstep           = npyv_nlanes_@sfx@;
+#if @id@ == 2 /* divmod */
+    npyv_lanetype_@sfx@ *dst2 = (npyv_lanetype_@sfx@ *) args[3];
+    npyv_b@len@ warn          = npyv_cvt_b@len@_@sfx@(npyv_zero_@sfx@());
+
+    for (; len >= vstep; len -= vstep, src1 += vstep, src2 += vstep,
+         dst1 += vstep, dst2 += vstep) {
+        npyv_@sfx@ a        = npyv_load_@sfx@(src1);
+        npyv_@sfx@ b        = npyv_load_@sfx@(src2);
+        npyv_@sfx@ quo      = vsx4_div_@sfx@(a, b);
+        npyv_@sfx@ rem      = npyv_sub_@sfx@(a, vec_mul(b, quo));
+        npyv_b@len@ bzero   = npyv_cmpeq_@sfx@(b, vzero);
+        // when b is 0, forces the remainder to be 0 too
+                        rem = npyv_select_@sfx@(bzero, vzero, rem);
+                       warn = npyv_or_@sfx@(bzero, warn);
+        npyv_store_@sfx@(dst1, quo);
+        npyv_store_@sfx@(dst2, rem);
+    }
+
+    if (!vec_all_eq(warn, vzero)) {
+        npy_set_floatstatus_divbyzero();
+    }
+
+    for (; len > 0; --len, ++src1, ++src2, ++dst1, ++dst2) {
+        const npyv_lanetype_@sfx@ a = *src1;
+        const npyv_lanetype_@sfx@ b = *src2;
+        if (NPY_UNLIKELY(b == 0)) {
+            npy_set_floatstatus_divbyzero();
+            *dst1 = 0;
+            *dst2 = 0;
+        } else{
+            *dst1 = a / b;
+            *dst2 = a % b;
+        }
+    }
+#else /* fmod and remainder */
+    for (; len >= vstep; len -= vstep, src1 += vstep, src2 += vstep,
+         dst1 += vstep) {
+        npyv_@sfx@ a = npyv_load_@sfx@(src1);
+        npyv_@sfx@ b = npyv_load_@sfx@(src2);
+        npyv_@sfx@ c = vsx4_mod_@sfx@(a, b);
+        npyv_store_@sfx@(dst1, c);
+        if (NPY_UNLIKELY(vec_any_eq(b, vzero))) {
+            npy_set_floatstatus_divbyzero();
+        }
+    }
+
+    for (; len > 0; --len, ++src1, ++src2, ++dst1) {
+        const npyv_lanetype_@sfx@ a = *src1;
+        const npyv_lanetype_@sfx@ b = *src2;
+        if (NPY_UNLIKELY(b == 0)) {
+            npy_set_floatstatus_divbyzero();
+            *dst1 = 0;
+        } else{
+            *dst1 = a % b;
+        }
+    }
+#endif
+    npyv_cleanup();
+}
+
+static NPY_INLINE void
+vsx4_simd_@func@_by_scalar_contig_@sfx@(char **args, npy_intp len)
+{
+    npyv_lanetype_@sfx@ *src1  = (npyv_lanetype_@sfx@ *) args[0];
+    npyv_lanetype_@sfx@ scalar = *(npyv_lanetype_@sfx@ *) args[1];
+    npyv_lanetype_@sfx@ *dst1  = (npyv_lanetype_@sfx@ *) args[2];
+    const int vstep            = npyv_nlanes_@sfx@;
+    const npyv_@sfx@ vscalar   = npyv_setall_@sfx@(scalar);
+    const @divtype@ divisor    = vsx4_divisor_@sfx@(vscalar);
+#if @id@ == 2 /* divmod */
+    npyv_lanetype_@sfx@ *dst2 = (npyv_lanetype_@sfx@ *) args[3];
+
+    for (; len >= vstep; len -= vstep, src1 += vstep, dst1 += vstep,
+         dst2 += vstep) {
+        npyv_@sfx@ a   = npyv_load_@sfx@(src1);
+        npyv_@sfx@ quo = vsx4_div_scalar_@sfx@(a, divisor);
+        npyv_@sfx@ rem = npyv_sub_@sfx@(a, vec_mul(vscalar, quo));
+        npyv_store_@sfx@(dst1, quo);
+        npyv_store_@sfx@(dst2, rem);
+    }
+
+    for (; len > 0; --len, ++src1, ++dst1, ++dst2) {
+        const npyv_lanetype_@sfx@ a = *src1;
+        *dst1 = a / scalar;
+        *dst2 = a % scalar;
+    }
+#else /* fmod and remainder */
+    for (; len >= vstep; len -= vstep, src1 += vstep, dst1 += vstep) {
+        npyv_@sfx@ a = npyv_load_@sfx@(src1);
+        npyv_@sfx@ c = vsx4_mod_scalar_@sfx@(a, divisor);
+        npyv_store_@sfx@(dst1, c);
+    }
+
+    for (; len > 0; --len, ++src1, ++dst1) {
+        const npyv_lanetype_@sfx@ a = *src1;
+        *dst1 = a % scalar;
+    }
+#endif
+    npyv_cleanup();
+}
+/**end repeat1**/
+/**end repeat**/
+
+/**begin repeat
+ * Signed types
+ * #sfx = s8, s16, s32, s64#
+ * #len = 8,  16,  32,  64#
+ * #divtype = vsx4_s32x4, npyv_s32x2,  npyv_s32,  npyv_s64#
+ */
+/**begin repeat1
+ * #func = fmod, remainder, divmod#
+ * #id = 0, 1, 2#
+ */
+static NPY_INLINE void
+vsx4_simd_@func@_contig_@sfx@(char **args, npy_intp len)
+{
+    npyv_lanetype_@sfx@ *src1 = (npyv_lanetype_@sfx@ *) args[0];
+    npyv_lanetype_@sfx@ *src2 = (npyv_lanetype_@sfx@ *) args[1];
+    npyv_lanetype_@sfx@ *dst1 = (npyv_lanetype_@sfx@ *) args[2];
+    const npyv_@sfx@ vzero    = npyv_zero_@sfx@();
+    const int vstep           = npyv_nlanes_@sfx@;
+#if @id@ == 2 /* divmod */
+    npyv_lanetype_@sfx@ *dst2 = (npyv_lanetype_@sfx@ *) args[3];
+    const npyv_@sfx@ vneg_one = npyv_setall_@sfx@(-1);
+    const npyv_@sfx@ vmin     = npyv_setall_@sfx@(NPY_MIN_INT@len@);
+    npyv_b@len@ warn_zero     = npyv_cvt_b@len@_@sfx@(npyv_zero_@sfx@());
+    npyv_b@len@ warn_overflow = npyv_cvt_b@len@_@sfx@(npyv_zero_@sfx@());
+
+    for (; len >= vstep; len -= vstep, src1 += vstep, src2 += vstep,
+         dst1 += vstep, dst2 += vstep) {
+#else /* fmod and remainder */
+    for (; len >= vstep; len -= vstep, src1 += vstep, src2 += vstep,
+         dst1 += vstep) {
+#endif
+        npyv_@sfx@ a = npyv_load_@sfx@(src1);
+        npyv_@sfx@ b = npyv_load_@sfx@(src2);
+#if @id@ <= 1 /* fmod and remainder */
+        npyv_@sfx@ rem       = vsx4_mod_@sfx@(a, b);
+#else /* divmod */
+        npyv_@sfx@ quo       = vsx4_div_@sfx@(a, b);
+        npyv_@sfx@ rem       = npyv_sub_@sfx@(a, vec_mul(b, quo));
+        // (b == 0 || (a == NPY_MIN_INT@len@ && b == -1))
+        npyv_b@len@ bzero    = npyv_cmpeq_@sfx@(b, vzero);
+        npyv_b@len@ amin     = npyv_cmpeq_@sfx@(a, vmin);
+        npyv_b@len@ bneg_one = npyv_cmpeq_@sfx@(b, vneg_one);
+        npyv_b@len@ overflow = npyv_and_@sfx@(bneg_one, amin);
+                warn_zero = npyv_or_@sfx@(bzero, warn_zero);
+               warn_overflow = npyv_or_@sfx@(overflow, warn_overflow);
+#endif
+#if @id@ >= 1 /* remainder and divmod */
+        // handle mixed case the way Python does
+        // ((a > 0) == (b > 0) || rem == 0)
+        npyv_b@len@ a_gt_zero  = npyv_cmpgt_@sfx@(a, vzero);
+        npyv_b@len@ b_gt_zero  = npyv_cmpgt_@sfx@(b, vzero);
+        npyv_b@len@ ab_eq_cond = npyv_cmpeq_@sfx@(a_gt_zero, b_gt_zero);
+        npyv_b@len@ rem_zero   = npyv_cmpeq_@sfx@(rem, vzero);
+        npyv_b@len@ or         = npyv_or_@sfx@(ab_eq_cond, rem_zero);
+        npyv_@sfx@ to_add      = npyv_select_@sfx@(or, vzero, b);
+                           rem = npyv_add_@sfx@(rem, to_add);
+#endif
+#if @id@ == 2 /* divmod */
+        npyv_@sfx@ to_sub = npyv_select_@sfx@(or, vzero, vneg_one);
+                      quo = npyv_add_@sfx@(quo, to_sub);
+                      // Divide by zero
+                      quo = npyv_select_@sfx@(bzero, vzero, quo);
+                      rem = npyv_select_@sfx@(bzero, vzero, rem);
+                      // Overflow
+                      quo = npyv_select_@sfx@(overflow, vmin, quo);
+                      rem = npyv_select_@sfx@(overflow, vzero, rem);
+        npyv_store_@sfx@(dst1, quo);
+        npyv_store_@sfx@(dst2, rem);
+#else /* fmod and remainder */
+        npyv_store_@sfx@(dst1, rem);
+        if (NPY_UNLIKELY(vec_any_eq(b, vzero))) {
+            npy_set_floatstatus_divbyzero();
+        }
+#endif
+    }
+
+#if @id@ == 2 /* divmod */
+    if (!vec_all_eq(warn_zero, vzero)) {
+        npy_set_floatstatus_divbyzero();
+    }
+    if (!vec_all_eq(warn_overflow, vzero)) {
+        npy_set_floatstatus_overflow();
+    }
+
+    for (; len > 0; --len, ++src1, ++src2, ++dst1, ++dst2) {
+        const npyv_lanetype_@sfx@ a = *src1;
+        const npyv_lanetype_@sfx@ b = *src2;
+        if (DIVIDEBYZERO_OVERFLOW_CHECK(a, b, NPY_MIN_INT@len@, NPY_TRUE)) {
+            if (b == 0) {
+                npy_set_floatstatus_divbyzero();
+                *dst1 = 0;
+                *dst2 = 0;
+            }
+            else {
+                npy_set_floatstatus_overflow();
+                *dst1 = NPY_MIN_INT@len@;
+                *dst2 = 0;
+            }
+        }
+        else {
+            *dst1 = a / b;
+            *dst2 = a % b;
+            if (!((a > 0) == (b > 0) || *dst2 == 0)) {
+                *dst1 -= 1;
+                *dst2 += b;
+            }
+        }
+    }
+#else /* fmod and remainder */
+    for (; len > 0; --len, ++src1, ++src2, ++dst1) {
+        const npyv_lanetype_@sfx@ a = *src1;
+        const npyv_lanetype_@sfx@ b = *src2;
+        if (DIVIDEBYZERO_OVERFLOW_CHECK(a, b, NPY_MIN_INT@len@, NPY_TRUE)) {
+            FLAG_IF_DIVIDEBYZERO(b);
+            *dst1 = 0;
+        } else{
+            *dst1 = a % b;
+#if @id@ == 1 /* remainder */
+            if (!((a > 0) == (b > 0) || *dst1 == 0)) {
+                *dst1 += b;
+            }
+#endif
+        }
+    }
+#endif
+    npyv_cleanup();
+}
+
+static NPY_INLINE void
+vsx4_simd_@func@_by_scalar_contig_@sfx@(char **args, npy_intp len)
+{
+    npyv_lanetype_@sfx@ *src1  = (npyv_lanetype_@sfx@ *) args[0];
+    npyv_lanetype_@sfx@ scalar = *(npyv_lanetype_@sfx@ *) args[1];
+    npyv_lanetype_@sfx@ *dst1  = (npyv_lanetype_@sfx@ *) args[2];
+    const npyv_@sfx@ vscalar   = npyv_setall_@sfx@(scalar);
+    const @divtype@ divisor    = vsx4_divisor_@sfx@(vscalar);
+    const int vstep            = npyv_nlanes_@sfx@;
+#if @id@ >= 1 /* remainder and divmod */
+    const npyv_@sfx@ vzero     = npyv_zero_@sfx@();
+    npyv_b@len@ b_gt_zero      = npyv_cmpgt_@sfx@(vscalar, vzero);
+#endif
+#if @id@ == 2 /* divmod */
+    npyv_b@len@ warn          = npyv_cvt_b@len@_@sfx@(npyv_zero_@sfx@());
+    const npyv_@sfx@ vmin     = npyv_setall_@sfx@(NPY_MIN_INT@len@);
+    const npyv_@sfx@ vneg_one = npyv_setall_@sfx@(-1);
+    npyv_b@len@ bneg_one      = npyv_cmpeq_@sfx@(vscalar, vneg_one);
+    npyv_lanetype_@sfx@ *dst2 = (npyv_lanetype_@sfx@ *) args[3];
+
+    for (; len >= vstep; len -= vstep, src1 += vstep, dst1 += vstep,
+         dst2 += vstep) {
+#else /* fmod and remainder */
+    for (; len >= vstep; len -= vstep, src1 += vstep, dst1 += vstep) {
+#endif
+        npyv_@sfx@ a = npyv_load_@sfx@(src1);
+#if @id@ <= 1 /* fmod and remainder */
+        npyv_@sfx@ rem       = vsx4_mod_scalar_@sfx@(a, divisor);
+#else /* divmod */
+        npyv_@sfx@ quo       = vsx4_div_scalar_@sfx@(a, divisor);
+        npyv_@sfx@ rem       = npyv_sub_@sfx@(a, vec_mul(vscalar, quo));
+        // (a == NPY_MIN_INT@len@ && b == -1)
+        npyv_b@len@ amin     = npyv_cmpeq_@sfx@(a, vmin);
+        npyv_b@len@ overflow = npyv_and_@sfx@(bneg_one, amin);
+                        warn = npyv_or_@sfx@(overflow, warn);
+#endif
+#if @id@ >= 1 /* remainder and divmod */
+        // handle mixed case the way Python does
+        // ((a > 0) == (b > 0) || rem == 0)
+        npyv_b@len@ a_gt_zero  = npyv_cmpgt_@sfx@(a, vzero);
+        npyv_b@len@ ab_eq_cond = npyv_cmpeq_@sfx@(a_gt_zero, b_gt_zero);
+        npyv_b@len@ rem_zero   = npyv_cmpeq_@sfx@(rem, vzero);
+        npyv_b@len@ or         = npyv_or_@sfx@(ab_eq_cond, rem_zero);
+        npyv_@sfx@ to_add      = npyv_select_@sfx@(or, vzero, vscalar);
+                           rem = npyv_add_@sfx@(rem, to_add);
+#endif
+#if @id@ == 2 /* divmod */
+        npyv_@sfx@ to_sub = npyv_select_@sfx@(or, vzero, vneg_one);
+        quo               = npyv_add_@sfx@(quo, to_sub);
+        // Overflow: set quo to minimum and rem to 0
+        quo               = npyv_select_@sfx@(overflow, vmin, quo);
+        rem               = npyv_select_@sfx@(overflow, vzero, rem);
+        npyv_store_@sfx@(dst1, quo);
+        npyv_store_@sfx@(dst2, rem);
+#else /* fmod and remainder */
+        npyv_store_@sfx@(dst1, rem);
+#endif
+    }
+
+#if @id@ == 2 /* divmod */
+    if (!vec_all_eq(warn, vzero)) {
+        npy_set_floatstatus_overflow();
+    }
+
+    for (; len > 0; --len, ++src1, ++dst1, ++dst2) {
+        const npyv_lanetype_@sfx@ a = *src1;
+        if (NPY_UNLIKELY(a == NPY_MIN_INT@len@ && scalar == -1)) {
+            npy_set_floatstatus_overflow();
+            *dst1 = NPY_MIN_INT@len@;
+            *dst2 = 0;
+        }
+        else {
+            *dst1 = a / scalar;
+            *dst2 = a % scalar;
+            if (!((a > 0) == (scalar > 0) || *dst2 == 0)) {
+                *dst1 -= 1;
+                *dst2 += scalar;
+            }
+        }
+    }
+#else /* fmod and remainder */
+    for (; len > 0; --len, ++src1, ++dst1) {
+        const npyv_lanetype_@sfx@ a = *src1;
+        *dst1 = a % scalar;
+#if @id@ == 1 /* remainder */
+        if (!((a > 0) == (scalar > 0) || *dst1 == 0)) {
+            *dst1 += scalar;
+        }
+#endif
+    }
+#endif
+    npyv_cleanup();
+}
+/**end repeat1**/
+/**end repeat**/
+#endif // NPY_SIMD && defined(NPY_HAVE_VSX4)
+
+/*****************************************************************************
+ ** Defining ufunc inner functions
+ *****************************************************************************/
+
+/**begin repeat
+ * Signed and Unsigned types
+ *  #type  = npy_ubyte, npy_ushort, npy_uint, npy_ulong, npy_ulonglong,
+ *           npy_byte,  npy_short,  npy_int,  npy_long,  npy_longlong#
+ *  #TYPE  = UBYTE,     USHORT,     UINT,     ULONG,     ULONGLONG,
+ *           BYTE,      SHORT,      INT,      LONG,      LONGLONG#
+ *  #STYPE = BYTE,      SHORT,      INT,      LONG,      LONGLONG,
+ *           BYTE,      SHORT,      INT,      LONG,      LONGLONG#
+ *  #signed = 0, 0, 0, 0, 0, 1, 1, 1, 1, 1#
+ */
+#undef TO_SIMD_SFX
+#if 0
+/**begin repeat1
+ * #len = 8, 16, 32, 64#
+ */
+#elif NPY_BITSOF_@STYPE@ == @len@
+    #if @signed@
+        #define TO_SIMD_SFX(X) X##_s@len@
+    #else
+        #define TO_SIMD_SFX(X) X##_u@len@
+    #endif
+/**end repeat1**/
+#endif
+
+NPY_NO_EXPORT void NPY_CPU_DISPATCH_CURFX(@TYPE@_fmod)
+(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func))
+{
+#if defined(NPY_HAVE_VSX4) && NPY_SIMD && defined(TO_SIMD_SFX)
+    // both arguments are arrays of the same size
+    if (IS_BLOCKABLE_BINARY(sizeof(@type@), NPY_SIMD_WIDTH)) {
+        TO_SIMD_SFX(vsx4_simd_fmod_contig)(args, dimensions[0]);
+        return;
+    }
+    // for contiguous block of memory, divisor is a scalar and not 0
+    else if (IS_BLOCKABLE_BINARY_SCALAR2(sizeof(@type@), NPY_SIMD_WIDTH) &&
+             (*(@type@ *)args[1]) != 0) {
+        TO_SIMD_SFX(vsx4_simd_fmod_by_scalar_contig)(args, dimensions[0]);
+        return ;
+    }
+#endif
+    BINARY_LOOP {
+        const @type@ in1 = *(@type@ *)ip1;
+        const @type@ in2 = *(@type@ *)ip2;
+#if @signed@
+        if (DIVIDEBYZERO_OVERFLOW_CHECK(in1, in2, NPY_MIN_@TYPE@, NPY_TRUE)) {
+#else
+        if (DIVIDEBYZERO_OVERFLOW_CHECK(in1, in2, 0, NPY_FALSE)) {
+#endif
+            FLAG_IF_DIVIDEBYZERO(in2);
+            *((@type@ *)op1) = 0;
+        } else{
+            *((@type@ *)op1)= in1 % in2;
+        }
+    }
+}
+
+NPY_NO_EXPORT void NPY_CPU_DISPATCH_CURFX(@TYPE@_remainder)
+(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func))
+{
+#if defined(NPY_HAVE_VSX4) && NPY_SIMD && defined(TO_SIMD_SFX)
+    // both arguments are arrays of the same size
+    if (IS_BLOCKABLE_BINARY(sizeof(@type@), NPY_SIMD_WIDTH)) {
+        TO_SIMD_SFX(vsx4_simd_remainder_contig)(args, dimensions[0]);
+        return;
+    }
+    // for contiguous block of memory, divisor is a scalar and not 0
+    else if (IS_BLOCKABLE_BINARY_SCALAR2(sizeof(@type@), NPY_SIMD_WIDTH) &&
+             (*(@type@ *)args[1]) != 0) {
+        TO_SIMD_SFX(vsx4_simd_remainder_by_scalar_contig)(args, dimensions[0]);
+        return ;
+    }
+#endif
+    BINARY_LOOP {
+        const @type@ in1 = *(@type@ *)ip1;
+        const @type@ in2 = *(@type@ *)ip2;
+#if @signed@
+        if (DIVIDEBYZERO_OVERFLOW_CHECK(in1, in2, NPY_MIN_@TYPE@, NPY_TRUE)) {
+#else
+        if (DIVIDEBYZERO_OVERFLOW_CHECK(in1, in2, 0, NPY_FALSE)) {
+#endif
+            FLAG_IF_DIVIDEBYZERO(in2);
+            *((@type@ *)op1) = 0;
+        } else{
+#if @signed@
+            /* handle mixed case the way Python does */
+            const @type@ rem = in1 % in2;
+            if ((in1 > 0) == (in2 > 0) || rem == 0) {
+                *((@type@ *)op1) = rem;
+            }
+            else {
+                *((@type@ *)op1) = rem + in2;
+            }
+#else
+            *((@type@ *)op1)= in1 % in2;
+#endif
+        }
+    }
+}
+
+NPY_NO_EXPORT void NPY_CPU_DISPATCH_CURFX(@TYPE@_divmod)
+(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func))
+{
+#if defined(NPY_HAVE_VSX4) && NPY_SIMD && defined(TO_SIMD_SFX)
+    // both arguments are arrays of the same size
+    if (IS_BLOCKABLE_BINARY(sizeof(@type@), NPY_SIMD_WIDTH)) {
+        TO_SIMD_SFX(vsx4_simd_divmod_contig)(args, dimensions[0]);
+        return;
+    }
+    // for contiguous block of memory, divisor is a scalar and not 0
+    else if (IS_BLOCKABLE_BINARY_SCALAR2(sizeof(@type@), NPY_SIMD_WIDTH) &&
+             (*(@type@ *)args[1]) != 0) {
+        TO_SIMD_SFX(vsx4_simd_divmod_by_scalar_contig)(args, dimensions[0]);
+        return ;
+    }
+#endif
+#if @signed@
+    BINARY_LOOP_TWO_OUT {
+        const @type@ in1 = *(@type@ *)ip1;
+        const @type@ in2 = *(@type@ *)ip2;
+        /* see FIXME note for divide above */
+        if (DIVIDEBYZERO_OVERFLOW_CHECK(in1, in2, NPY_MIN_@TYPE@, NPY_TRUE)) {
+            if (in2 == 0) {
+                npy_set_floatstatus_divbyzero();
+                *((@type@ *)op1) = 0;
+                *((@type@ *)op2) = 0;
+            }
+            else {
+                npy_set_floatstatus_overflow();
+                *((@type@ *)op1) = NPY_MIN_@TYPE@;
+                *((@type@ *)op2) = 0;
+            }
+        }
+        else {
+            /* handle mixed case the way Python does */
+            const @type@ quo = in1 / in2;
+            const @type@ rem = in1 % in2;
+            if ((in1 > 0) == (in2 > 0) || rem == 0) {
+                *((@type@ *)op1) = quo;
+                *((@type@ *)op2) = rem;
+            }
+            else {
+                *((@type@ *)op1) = quo - 1;
+                *((@type@ *)op2) = rem + in2;
+            }
+        }
+    }
+#else
+    BINARY_LOOP_TWO_OUT {
+        const @type@ in1 = *(@type@ *)ip1;
+        const @type@ in2 = *(@type@ *)ip2;
+        if (DIVIDEBYZERO_OVERFLOW_CHECK(in1, in2, 0, NPY_FALSE)) {
+            npy_set_floatstatus_divbyzero();
+            *((@type@ *)op1) = 0;
+            *((@type@ *)op2) = 0;
+        }
+        else {
+            *((@type@ *)op1)= in1/in2;
+            *((@type@ *)op2) = in1 % in2;
+        }
+    }
+#endif
+}
+/**end repeat**/
diff --git a/numpy/core/src/umath/loops_trigonometric.dispatch.c.src b/numpy/core/src/umath/loops_trigonometric.dispatch.c.src
index cd9b2ed547ff..9f9978e66824 100644
--- a/numpy/core/src/umath/loops_trigonometric.dispatch.c.src
+++ b/numpy/core/src/umath/loops_trigonometric.dispatch.c.src
@@ -1,8 +1,9 @@
 /*@targets
  ** $maxopt baseline
  ** (avx2 fma3) avx512f
- ** vsx2
+ ** vsx2 vsx3 vsx4
  ** neon_vfpv4
+ ** vxe vxe2
  **/
 #include "numpy/npy_math.h"
 #include "simd/simd.h"
@@ -13,7 +14,7 @@
  * - use vectorized version of Payne-Hanek style reduction for large elements or
  *   when there's no native FUSED support instead of fallback to libc
  */
-#if NPY_SIMD_FMA3 // native support
+#if NPY_SIMD_F32 && NPY_SIMD_FMA3 // native support
 /*
  * Vectorized Cody-Waite range reduction technique
  * Performs the reduction step x* = x - y*C in three steps:
@@ -123,6 +124,11 @@ simd_sincos_f32(const float *src, npy_intp ssrc, float *dst, npy_intp sdst,
         } else {
             x_in = npyv_loadn_tillz_f32(src, ssrc, len);
         }
+        npyv_b32 nnan_mask = npyv_notnan_f32(x_in);
+    #if NPY_SIMD_CMPSIGNAL
+        // Eliminate NaN to avoid FP invalid exception
+        x_in = npyv_and_f32(x_in, npyv_reinterpret_f32_u32(npyv_cvt_u32_b32(nnan_mask)));
+    #endif
         npyv_b32 simd_mask = npyv_cmple_f32(npyv_abs_f32(x_in), max_cody);
         npy_uint64 simd_maski = npyv_tobits_b32(simd_mask);
         /*
@@ -131,7 +137,6 @@ simd_sincos_f32(const float *src, npy_intp ssrc, float *dst, npy_intp sdst,
          * these numbers
          */
         if (simd_maski != 0) {
-            npyv_b32 nnan_mask = npyv_notnan_f32(x_in);
             npyv_f32 x = npyv_select_f32(npyv_and_b32(nnan_mask, simd_mask), x_in, zerosf);
 
             npyv_f32 quadrant = npyv_mul_f32(x, two_over_pi);
@@ -210,7 +215,7 @@ NPY_NO_EXPORT void NPY_CPU_DISPATCH_CURFX(FLOAT_@func@)
     const npy_intp sdst = steps[1] / lsize;
     npy_intp len = dimensions[0];
     assert(len <= 1 || (steps[0] % lsize == 0 && steps[1] % lsize == 0));
-#if NPY_SIMD_FMA3
+#if NPY_SIMD_F32 && NPY_SIMD_FMA3
     if (is_mem_overlap(src, steps[0], dst, steps[1], len) ||
         !npyv_loadable_stride_f32(ssrc) || !npyv_storable_stride_f32(sdst)
     ) {
diff --git a/numpy/core/src/umath/loops_umath_fp.dispatch.c.src b/numpy/core/src/umath/loops_umath_fp.dispatch.c.src
index a8289fc51092..d6703bfb94fa 100644
--- a/numpy/core/src/umath/loops_umath_fp.dispatch.c.src
+++ b/numpy/core/src/umath/loops_umath_fp.dispatch.c.src
@@ -12,10 +12,12 @@
 /**begin repeat
  * #sfx = f32, f64#
  * #func_suffix = f16, 8#
+ * #len = 32, 64#
  */
 /**begin repeat1
- * #func = tanh, exp2, log2, log10, expm1, log1p, cbrt, tan, asin, acos, atan, sinh, cosh, asinh, acosh, atanh#
- * #default_val = 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0#
+ * #func = exp2, log2, log10, expm1, log1p, cbrt, tan, asin, acos, atan, sinh, cosh, asinh, acosh, atanh#
+ * #default_val = 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0#
+ * #fxnan = 0,    0,   0,     64,    0,     0,    0,   0,    0,    0,    0,    0,    0,     0,     0#
  */
 static void
 simd_@func@_@sfx@(const npyv_lanetype_@sfx@ *src, npy_intp ssrc,
@@ -37,7 +39,15 @@ simd_@func@_@sfx@(const npyv_lanetype_@sfx@ *src, npy_intp ssrc,
                 x = npyv_loadn_tillz_@sfx@(src, ssrc, len);
             }
         #endif
+    #if @fxnan@ == @len@
+        // Workaround, invalid value encountered when x is set to nan
+        npyv_b@len@ nnan_mask = npyv_notnan_@sfx@(x);
+        npyv_@sfx@ x_exnan = npyv_select_@sfx@(nnan_mask, x, npyv_setall_@sfx@(@default_val@));
+        npyv_@sfx@ out = __svml_@func@@func_suffix@(x_exnan);
+        out = npyv_select_@sfx@(nnan_mask, out, x);
+    #else
         npyv_@sfx@ out = __svml_@func@@func_suffix@(x);
+    #endif
         if (sdst == 1) {
             npyv_store_till_@sfx@(dst, len, out);
         } else {
@@ -74,8 +84,125 @@ simd_@func@_f64(const double *src, npy_intp ssrc,
     npyv_cleanup();
 }
 /**end repeat**/
+
+/**begin repeat
+ * #sfx = f32, f64#
+ * #func_suffix = f16, 8#
+ */
+/**begin repeat1
+ * #func = pow, atan2#
+ */
+
+static void
+simd_@func@_@sfx@(const npyv_lanetype_@sfx@ *src1, npy_intp ssrc1,
+                  const npyv_lanetype_@sfx@ *src2, npy_intp ssrc2,
+                        npyv_lanetype_@sfx@ *dst, npy_intp sdst, npy_intp len)
+{
+    const int vstep = npyv_nlanes_@sfx@;
+    for (; len > 0; len -= vstep, src1 += ssrc1*vstep, src2 += ssrc2*vstep, dst += sdst*vstep) {
+        npyv_@sfx@ x1;
+        if (ssrc1 == 1) {
+            x1 = npyv_load_till_@sfx@(src1, len, 1);
+        } else {
+            x1 = npyv_loadn_till_@sfx@(src1, ssrc1, len, 1);
+        }
+
+        npyv_@sfx@ x2;
+        if (ssrc2 == 1) {
+            x2 = npyv_load_till_@sfx@(src2, len, 1);
+        } else {
+            x2 = npyv_loadn_till_@sfx@(src2, ssrc2, len, 1);
+        }
+
+        npyv_@sfx@ out = __svml_@func@@func_suffix@(x1, x2);
+        if (sdst == 1) {
+            npyv_store_till_@sfx@(dst, len, out);
+        } else {
+            npyv_storen_till_@sfx@(dst, sdst, len, out);
+        }
+    }
+}
+/**end repeat1**/
+/**end repeat**/
+
+typedef __m256i npyvh_f16;
+#define npyv_cvt_f16_f32 _mm512_cvtph_ps
+#define npyv_cvt_f32_f16 _mm512_cvtps_ph
+#define npyvh_load_f16(PTR) _mm256_loadu_si256((const __m256i*)(PTR))
+#define npyvh_store_f16(PTR, data) _mm256_storeu_si256((__m256i*)PTR, data)
+NPY_FINLINE npyvh_f16 npyvh_load_till_f16(const npy_half *ptr, npy_uintp nlane, npy_half fill)
+{
+    assert(nlane > 0);
+    const __m256i vfill = _mm256_set1_epi16(fill);
+    const __mmask16 mask = (0x0001 << nlane) - 0x0001;
+    return _mm256_mask_loadu_epi16(vfill, mask, ptr);
+}
+NPY_FINLINE void npyvh_store_till_f16(npy_half *ptr, npy_uintp nlane, npyvh_f16 data)
+{
+    assert(nlane > 0);
+    const __mmask16 mask = (0x0001 << nlane) - 0x0001;
+    _mm256_mask_storeu_epi16(ptr, mask, data);
+}
+
+/**begin repeat
+ * #func = sin, cos, tan, exp, exp2, expm1, log, log2, log10, log1p, cbrt, asin, acos, atan, sinh, cosh, tanh, asinh, acosh, atanh#
+ * #default_val = 0, 0, 0, 0, 0, 0x3c00, 0x3c00, 0x3c00, 0x3c00, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x3c00, 0#
+ */
+static void
+avx512_@func@_f16(const npy_half *src, npy_half *dst, npy_intp len)
+{
+    const int num_lanes = npyv_nlanes_f32;
+    npyvh_f16 x, out;
+    npyv_f32 x_ps, out_ps;
+    for (; len > 0; len -= num_lanes, src += num_lanes, dst += num_lanes) {
+        if (len >= num_lanes) {
+            x       = npyvh_load_f16(src);
+            x_ps    = npyv_cvt_f16_f32(x);
+            out_ps  = __svml_@func@f16(x_ps);
+            out     = npyv_cvt_f32_f16(out_ps, 0);
+            npyvh_store_f16(dst, out);
+        }
+        else {
+            x       = npyvh_load_till_f16(src, len, @default_val@);
+            x_ps    = npyv_cvt_f16_f32(x);
+            out_ps  = __svml_@func@f16(x_ps);
+            out     = npyv_cvt_f32_f16(out_ps, 0);
+            npyvh_store_till_f16(dst, len, out);
+        }
+    }
+    npyv_cleanup();
+}
+/**end repeat**/
 #endif
 
+/**begin repeat
+ *  #func = sin, cos, tan, exp, exp2, expm1, log, log2, log10, log1p, cbrt, arcsin, arccos, arctan, sinh, cosh, tanh, arcsinh, arccosh, arctanh#
+ *  #intrin = sin, cos, tan, exp, exp2, expm1, log, log2, log10, log1p, cbrt, asin, acos, atan, sinh, cosh, tanh, asinh, acosh, atanh#
+ */
+NPY_NO_EXPORT void NPY_CPU_DISPATCH_CURFX(HALF_@func@)
+(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(data))
+{
+#if NPY_SIMD && defined(NPY_HAVE_AVX512_SKX) && defined(NPY_CAN_LINK_SVML)
+    const npy_half *src = (npy_half*)args[0];
+          npy_half *dst = (npy_half*)args[1];
+    const int lsize = sizeof(src[0]);
+    const npy_intp ssrc = steps[0] / lsize;
+    const npy_intp sdst = steps[1] / lsize;
+    const npy_intp len = dimensions[0];
+    if (!is_mem_overlap(src, steps[0], dst, steps[1], len) &&
+        (ssrc == 1) &&
+        (sdst == 1)) {
+        avx512_@intrin@_f16(src, dst, len);
+        return;
+    }
+#endif
+    UNARY_LOOP {
+        const npy_float in1 = npy_half_to_float(*(npy_half *)ip1);
+        *((npy_half *)op1) = npy_float_to_half(npy_@intrin@f(in1));
+    }
+}
+/**end repeat**/
+
 /**begin repeat
  *  #TYPE = DOUBLE, FLOAT#
  *  #type = npy_double, npy_float#
@@ -83,8 +210,8 @@ simd_@func@_f64(const double *src, npy_intp ssrc,
  *  #sfx  = f64, f32#
  */
 /**begin repeat1
- *  #func = tanh, exp2, log2, log10, expm1, log1p, cbrt, tan, arcsin, arccos, arctan, sinh, cosh, arcsinh, arccosh, arctanh#
- *  #intrin = tanh, exp2, log2, log10, expm1, log1p, cbrt, tan, asin, acos, atan, sinh, cosh, asinh, acosh, atanh#
+ *  #func = exp2, log2, log10, expm1, log1p, cbrt, tan, arcsin, arccos, arctan, sinh, cosh, arcsinh, arccosh, arctanh#
+ *  #intrin = exp2, log2, log10, expm1, log1p, cbrt, tan, asin, acos, atan, sinh, cosh, asinh, acosh, atanh#
  */
 NPY_NO_EXPORT void NPY_CPU_DISPATCH_CURFX(@TYPE@_@func@)
 (char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(data))
@@ -112,6 +239,45 @@ NPY_NO_EXPORT void NPY_CPU_DISPATCH_CURFX(@TYPE@_@func@)
 /**end repeat1**/
 /**end repeat**/
 
+/**begin repeat
+ *  #TYPE = DOUBLE, FLOAT#
+ *  #type = npy_double, npy_float#
+ *  #vsub = , f#
+ *  #sfx  = f64, f32#
+ */
+/**begin repeat1
+ *  #func = power, arctan2#
+ *  #intrin = pow, atan2#
+ */
+NPY_NO_EXPORT void NPY_CPU_DISPATCH_CURFX(@TYPE@_@func@)
+(char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(data))
+{
+#if NPY_SIMD && defined(NPY_HAVE_AVX512_SKX) && defined(NPY_CAN_LINK_SVML)
+    const @type@ *src1 = (@type@*)args[0];
+    const @type@ *src2 = (@type@*)args[1];
+          @type@ *dst  = (@type@*)args[2];
+    const int lsize = sizeof(src1[0]);
+    const npy_intp ssrc1 = steps[0] / lsize;
+    const npy_intp ssrc2 = steps[1] / lsize;
+    const npy_intp sdst  = steps[2] / lsize;
+    const npy_intp len = dimensions[0];
+    assert(len <= 1 || (steps[0] % lsize == 0 && steps[1] % lsize == 0));
+    if (!is_mem_overlap(src1, steps[0], dst, steps[2], len) && !is_mem_overlap(src2, steps[1], dst, steps[2], len) &&
+        npyv_loadable_stride_@sfx@(ssrc1) && npyv_loadable_stride_@sfx@(ssrc2) &&
+        npyv_storable_stride_@sfx@(sdst)) {
+        simd_@intrin@_@sfx@(src1, ssrc1, src2, ssrc2, dst, sdst, len);
+        return;
+    }
+#endif
+    BINARY_LOOP {
+        const @type@ in1 = *(@type@ *)ip1;
+        const @type@ in2 = *(@type@ *)ip2;
+        *(@type@ *)op1 = npy_@intrin@@vsub@(in1, in2);
+    }
+}
+/**end repeat1**/
+/**end repeat**/
+
 /**begin repeat
  *  #func = sin, cos#
  */
diff --git a/numpy/core/src/umath/loops_unary_fp.dispatch.c.src b/numpy/core/src/umath/loops_unary_fp.dispatch.c.src
index 93761b98c04e..0ac39a9b18f0 100644
--- a/numpy/core/src/umath/loops_unary_fp.dispatch.c.src
+++ b/numpy/core/src/umath/loops_unary_fp.dispatch.c.src
@@ -3,6 +3,7 @@
  ** sse2 sse41
  ** vsx2
  ** neon asimd
+ ** vx vxe
  **/
 /**
  * Force use SSE only on x86, even if AVX2 or AVX512F are enabled
@@ -18,7 +19,7 @@
 /**********************************************************
  ** Scalars
  **********************************************************/
-#if !NPY_SIMD
+#if !NPY_SIMD_F32
 NPY_FINLINE float c_recip_f32(float a)
 { return 1.0f / a; }
 NPY_FINLINE float c_abs_f32(float a)
@@ -29,7 +30,7 @@ NPY_FINLINE float c_abs_f32(float a)
 }
 NPY_FINLINE float c_square_f32(float a)
 { return a * a; }
-#endif // !NPY_SIMD
+#endif // !NPY_SIMD_F32
 
 #if !NPY_SIMD_F64
 NPY_FINLINE double c_recip_f64(double a)
@@ -70,6 +71,15 @@ NPY_FINLINE double c_square_f64(double a)
 #define c_ceil_f32 npy_ceilf
 #define c_ceil_f64 npy_ceil
 
+#define c_trunc_f32 npy_truncf
+#define c_trunc_f64 npy_trunc
+
+#define c_floor_f32 npy_floorf
+#define c_floor_f64 npy_floor
+
+#define c_rint_f32 npy_rintf
+#define c_rint_f64 npy_rint
+
 /********************************************************************************
  ** Defining the SIMD kernels
  ********************************************************************************/
@@ -119,6 +129,9 @@ NPY_FINLINE double c_square_f64(double a)
         #if __clang_major__ < 10
         // Clang before v10
         #define WORKAROUND_CLANG_RECIPROCAL_BUG 1
+        #elif defined(_MSC_VER)
+        // clang-cl has the same bug
+        #define WORKAROUND_CLANG_RECIPROCAL_BUG 1
         #elif defined(NPY_CPU_X86) || defined(NPY_CPU_AMD64)
         // Clang v10+, targeting i386 or x86_64
         #define WORKAROUND_CLANG_RECIPROCAL_BUG 0
@@ -135,14 +148,14 @@ NPY_FINLINE double c_square_f64(double a)
 /**begin repeat
  * #TYPE = FLOAT, DOUBLE#
  * #sfx  = f32, f64#
- * #VCHK = NPY_SIMD, NPY_SIMD_F64#
+ * #VCHK = NPY_SIMD_F32, NPY_SIMD_F64#
  */
 #if @VCHK@
 /**begin repeat1
- * #kind     = ceil, sqrt, absolute, square, reciprocal#
- * #intr     = ceil, sqrt, abs,      square, recip#
- * #repl_0w1 = 0,    0,    0,        0,      1#
- * #RECIP_WORKAROUND = 0, 0, 0, 0, WORKAROUND_CLANG_RECIPROCAL_BUG#
+ * #kind     = rint,  floor, ceil, trunc, sqrt, absolute, square, reciprocal#
+ * #intr     = rint,  floor, ceil, trunc, sqrt, abs,      square, recip#
+ * #repl_0w1 = 0*7, 1#
+ * #RECIP_WORKAROUND = 0*7, WORKAROUND_CLANG_RECIPROCAL_BUG#
  */
 /**begin repeat2
  * #STYPE  = CONTIG, NCONTIG, CONTIG,  NCONTIG#
@@ -247,12 +260,12 @@ static void simd_@TYPE@_@kind@_@STYPE@_@DTYPE@
 /**begin repeat
  * #TYPE = FLOAT, DOUBLE#
  * #sfx  = f32, f64#
- * #VCHK = NPY_SIMD, NPY_SIMD_F64#
+ * #VCHK = NPY_SIMD_F32, NPY_SIMD_F64#
  */
 /**begin repeat1
- * #kind  = ceil, sqrt, absolute, square, reciprocal#
- * #intr  = ceil, sqrt, abs,      square, recip#
- * #clear = 0,    0,    1,        0,      0#
+ * #kind  = rint, floor, ceil, trunc, sqrt, absolute, square, reciprocal#
+ * #intr  = rint, floor, ceil, trunc, sqrt, abs,      square, recip#
+ * #clear = 0,    0,     0,    0,     0,    1,        0,      0#
  */
 NPY_NO_EXPORT void NPY_CPU_DISPATCH_CURFX(@TYPE@_@kind@)
 (char **args, npy_intp const *dimensions, npy_intp const *steps, void *NPY_UNUSED(func))
diff --git a/numpy/core/src/umath/loops_utils.h.src b/numpy/core/src/umath/loops_utils.h.src
index 762e9ee59bed..df92bc315c5e 100644
--- a/numpy/core/src/umath/loops_utils.h.src
+++ b/numpy/core/src/umath/loops_utils.h.src
@@ -79,7 +79,11 @@ static NPY_INLINE @type@
 {
     if (n < 8) {
         npy_intp i;
-        @type@ res = 0.;
+        /*
+         * Start with -0 to preserve -0 values.  The reason is that summing
+         * only -0 should return -0, but `0 + -0 == 0` while `-0 + -0 == -0`.
+         */
+        @type@ res = -0.0;
 
         for (i = 0; i < n; i++) {
             res += @trf@(*((@dtype@*)(a + i * stride)));
@@ -156,8 +160,8 @@ static NPY_INLINE void
     if (n < 8) {
         npy_intp i;
 
-        *rr = 0.;
-        *ri = 0.;
+        *rr = -0.0;
+        *ri = -0.0;
         for (i = 0; i < n; i += 2) {
             *rr += *((@ftype@ *)(a + i * stride + 0));
             *ri += *((@ftype@ *)(a + i * stride + sizeof(@ftype@)));
diff --git a/numpy/core/src/umath/npy_simd_data.h b/numpy/core/src/umath/npy_simd_data.h
index 62438d7a3fa8..43640a2d6324 100644
--- a/numpy/core/src/umath/npy_simd_data.h
+++ b/numpy/core/src/umath/npy_simd_data.h
@@ -15,6 +15,7 @@
 #define NPY_TANG_A4 0x1.11115b7aa905ep-7
 #define NPY_TANG_A5 0x1.6c1728d739765p-10
 
+#if !defined NPY_HAVE_AVX512_SKX || !defined NPY_CAN_LINK_SVML
 /* Lookup table for 2^(j/32) */
 static npy_uint64 EXP_Table_top[32] = {
     0x3FF0000000000000,
@@ -85,6 +86,7 @@ static npy_uint64 EXP_Table_tail[32] = {
     0x3CF9858F73A18F5E,
     0x3C99D3E12DD8A18B,
 };
+#endif //#if !defined NPY_HAVE_AVX512_SKX || !defined NPY_CAN_LINK_SVML
 #endif
 #endif
 
@@ -128,6 +130,7 @@ static npy_uint64 EXP_Table_tail[32] = {
  */
 #if defined NPY_HAVE_AVX512F
 #if !(defined(__clang__) && (__clang_major__ < 10 || (__clang_major__ == 10 && __clang_minor__ < 1)))
+#if !defined NPY_HAVE_AVX512_SKX || !defined NPY_CAN_LINK_SVML
 static npy_uint64 LOG_TABLE_TOP[64] = {
     0x0000000000000000,
     0x3F8FC0A8B1000000,
@@ -261,6 +264,7 @@ static npy_uint64 LOG_TABLE_TAIL[64] = {
     0x3D6F2CFB29AAA5F0,
     0x3D66757006095FD2,
 };
+#endif //#if !defined NPY_HAVE_AVX512_SKX || !defined NPY_CAN_LINK_SVML
 
 #define NPY_TANG_LOG_A1 0x1.55555555554e6p-4
 #define NPY_TANG_LOG_A2 0x1.9999999bac6d4p-7
diff --git a/numpy/core/src/umath/reduction.c b/numpy/core/src/umath/reduction.c
index c28c8abd8b49..817f99a04fab 100644
--- a/numpy/core/src/umath/reduction.c
+++ b/numpy/core/src/umath/reduction.c
@@ -68,7 +68,7 @@ count_axes(int ndim, const npy_bool *axis_flags)
  * Returns -1 if an error occurred, and otherwise the reduce arrays size,
  * which is the number of elements already initialized.
  */
-NPY_NO_EXPORT int
+static npy_intp
 PyArray_CopyInitialReduceValues(
                     PyArrayObject *result, PyArrayObject *operand,
                     const npy_bool *axis_flags, const char *funcname,
@@ -301,20 +301,6 @@ PyUFunc_ReduceWrapper(PyArrayMethod_Context *context,
 
     PyArrayMethod_StridedLoop *strided_loop;
     NPY_ARRAYMETHOD_FLAGS flags = 0;
-    npy_intp fixed_strides[3];
-    NpyIter_GetInnerFixedStrideArray(iter, fixed_strides);
-    if (wheremask != NULL) {
-        if (PyArrayMethod_GetMaskedStridedLoop(context,
-                1, fixed_strides, &strided_loop, &auxdata, &flags) < 0) {
-            goto fail;
-        }
-    }
-    else {
-        if (context->method->get_strided_loop(context,
-                1, 0, fixed_strides, &strided_loop, &auxdata, &flags) < 0) {
-            goto fail;
-        }
-    }
 
     int needs_api = (flags & NPY_METH_REQUIRES_PYAPI) != 0;
     needs_api |= NpyIter_IterationNeedsAPI(iter);
@@ -349,6 +335,25 @@ PyUFunc_ReduceWrapper(PyArrayMethod_Context *context,
         goto fail;
     }
 
+    /*
+     * Note that we need to ensure that the iterator is reset before getting
+     * the fixed strides.  (The buffer information is uninitialized before.)
+     */
+    npy_intp fixed_strides[3];
+    NpyIter_GetInnerFixedStrideArray(iter, fixed_strides);
+    if (wheremask != NULL) {
+        if (PyArrayMethod_GetMaskedStridedLoop(context,
+                1, fixed_strides, &strided_loop, &auxdata, &flags) < 0) {
+            goto fail;
+        }
+    }
+    else {
+        if (context->method->get_strided_loop(context,
+                1, 0, fixed_strides, &strided_loop, &auxdata, &flags) < 0) {
+            goto fail;
+        }
+    }
+
     if (NpyIter_GetIterSize(iter) != 0) {
         NpyIter_IterNextFunc *iternext;
         char **dataptr;
@@ -382,6 +387,7 @@ PyUFunc_ReduceWrapper(PyArrayMethod_Context *context,
     }
     Py_INCREF(result);
 
+    NPY_AUXDATA_FREE(auxdata);
     if (!NpyIter_Deallocate(iter)) {
         Py_DECREF(result);
         return NULL;
diff --git a/numpy/core/src/umath/scalarmath.c.src b/numpy/core/src/umath/scalarmath.c.src
index 402e6b561717..6121c2fcddf6 100644
--- a/numpy/core/src/umath/scalarmath.c.src
+++ b/numpy/core/src/umath/scalarmath.c.src
@@ -26,6 +26,18 @@
 #include "binop_override.h"
 #include "npy_longdouble.h"
 
+#include "arraytypes.h"
+#include "array_coercion.h"
+#include "common.h"
+#include "can_cast_table.h"
+#include "umathmodule.h"
+
+#include "convert_datatype.h"
+
+
+/* TODO: Used for some functions, should possibly move these to npy_math.h */
+#include "loops.h"
+
 /* Basic operations:
  *
  *  BINARY:
@@ -45,23 +57,22 @@
  *  #name = byte, short, int, long, longlong#
  *  #type = npy_byte, npy_short, npy_int, npy_long, npy_longlong#
  */
-static void
+static NPY_INLINE int
 @name@_ctype_add(@type@ a, @type@ b, @type@ *out) {
     *out = a + b;
     if ((*out^a) >= 0 || (*out^b) >= 0) {
-        return;
+        return 0;
     }
-    npy_set_floatstatus_overflow();
-    return;
+    return NPY_FPE_OVERFLOW;
 }
-static void
+
+static NPY_INLINE int
 @name@_ctype_subtract(@type@ a, @type@ b, @type@ *out) {
     *out = a - b;
     if ((*out^a) >= 0 || (*out^~b) >= 0) {
-        return;
+        return 0;
     }
-    npy_set_floatstatus_overflow();
-    return;
+    return NPY_FPE_OVERFLOW;
 }
 /**end repeat**/
 
@@ -69,23 +80,22 @@ static void
  *  #name = ubyte, ushort, uint, ulong, ulonglong#
  *  #type = npy_ubyte, npy_ushort, npy_uint, npy_ulong, npy_ulonglong#
  */
-static void
+static NPY_INLINE int
 @name@_ctype_add(@type@ a, @type@ b, @type@ *out) {
     *out = a + b;
     if (*out >= a && *out >= b) {
-        return;
+        return 0;
     }
-    npy_set_floatstatus_overflow();
-    return;
+    return NPY_FPE_OVERFLOW;
 }
-static void
+
+static NPY_INLINE int
 @name@_ctype_subtract(@type@ a, @type@ b, @type@ *out) {
     *out = a - b;
     if (a >= b) {
-        return;
+        return 0;
     }
-    npy_set_floatstatus_overflow();
-    return;
+    return NPY_FPE_OVERFLOW;
 }
 /**end repeat**/
 
@@ -108,18 +118,19 @@ static void
  * #neg = (1,0)*4#
  */
 #if NPY_SIZEOF_@SIZE@ > NPY_SIZEOF_@SIZENAME@
-static void
+static NPY_INLINE int
 @name@_ctype_multiply(@type@ a, @type@ b, @type@ *out) {
     @big@ temp;
     temp = ((@big@) a) * ((@big@) b);
     *out = (@type@) temp;
 #if @neg@
-    if (temp > NPY_MAX_@NAME@ || temp < NPY_MIN_@NAME@)
+    if (temp > NPY_MAX_@NAME@ || temp < NPY_MIN_@NAME@) {
 #else
-        if (temp > NPY_MAX_@NAME@)
+    if (temp > NPY_MAX_@NAME@) {
 #endif
-            npy_set_floatstatus_overflow();
-    return;
+        return NPY_FPE_OVERFLOW;
+    }
+    return 0;
 }
 #endif
 /**end repeat**/
@@ -133,12 +144,12 @@ static void
  * #SIZE = INT*2, LONG*2, LONGLONG*2#
  */
 #if NPY_SIZEOF_LONGLONG == NPY_SIZEOF_@SIZE@
-static void
+static NPY_INLINE int
 @name@_ctype_multiply(@type@ a, @type@ b, @type@ *out) {
     if (npy_mul_with_overflow_@name@(out, a, b)) {
-        npy_set_floatstatus_overflow();
+        return NPY_FPE_OVERFLOW;
     }
-    return;
+    return 0;
 }
 #endif
 /**end repeat**/
@@ -150,17 +161,26 @@ static void
  * #type = npy_byte, npy_ubyte, npy_short, npy_ushort, npy_int, npy_uint,
  *         npy_long, npy_ulong, npy_longlong, npy_ulonglong#
  * #neg = (1,0)*5#
+ * #NAME = BYTE, UBYTE, SHORT, USHORT, INT, UINT,
+ *         LONG, ULONG, LONGLONG, ULONGLONG#
  */
-static void
+
+#if @neg@
+    #define DIVIDEBYZERO_CHECK (b == 0 || (a == NPY_MIN_@NAME@ && b == -1))
+#else
+    #define DIVIDEBYZERO_CHECK (b == 0)
+#endif
+
+static NPY_INLINE int
 @name@_ctype_divide(@type@ a, @type@ b, @type@ *out) {
     if (b == 0) {
-        npy_set_floatstatus_divbyzero();
         *out = 0;
+        return NPY_FPE_DIVIDEBYZERO;
     }
 #if @neg@
-    else if (b == -1 && a < 0 && a == -a) {
-        npy_set_floatstatus_overflow();
-        *out = a / b;
+    else if (b == -1 && a == NPY_MIN_@NAME@) {
+        *out = NPY_MIN_@NAME@;
+        return NPY_FPE_OVERFLOW;
     }
 #endif
     else {
@@ -174,17 +194,20 @@ static void
 #else
         *out = a / b;
 #endif
+        return 0;
     }
 }
 
 #define @name@_ctype_floor_divide @name@_ctype_divide
 
-static void
+static NPY_INLINE int
 @name@_ctype_remainder(@type@ a, @type@ b, @type@ *out) {
-    if (a == 0 || b == 0) {
-        if (b == 0) npy_set_floatstatus_divbyzero();
+    if (DIVIDEBYZERO_CHECK) {
         *out = 0;
-        return;
+        if (b == 0) {
+            return NPY_FPE_DIVIDEBYZERO;
+        }
+        return 0;
     }
 #if @neg@
     else if ((a > 0) == (b > 0)) {
@@ -198,17 +221,24 @@ static void
 #else
     *out = a % b;
 #endif
+    return 0;
 }
+#undef DIVIDEBYZERO_CHECK
 /**end repeat**/
 
 /**begin repeat
  *
  * #name = byte, ubyte, short, ushort, int, uint, long,
  *         ulong, longlong, ulonglong#
- * #otyp = npy_float*4, npy_double*6#
  */
-#define @name@_ctype_true_divide(a, b, out)     \
-    *(out) = ((@otyp@) (a)) / ((@otyp@) (b));
+
+static NPY_INLINE int
+@name@_ctype_true_divide(npy_@name@ a, npy_@name@ b, npy_double *out)
+{
+    *out = (npy_double)a / (npy_double)b;
+    return 0;
+}
+
 /**end repeat**/
 
 /* b will always be positive in this call */
@@ -221,17 +251,17 @@ static void
  * #upc = BYTE, UBYTE, SHORT, USHORT, INT, UINT,
  *        LONG, ULONG, LONGLONG, ULONGLONG#
  */
-static void
+static NPY_INLINE int
 @name@_ctype_power(@type@ a, @type@ b, @type@ *out) {
     @type@ tmp;
 
     if (b == 0) {
         *out = 1;
-        return;
+        return 0;
     }
     if (a == 1) {
         *out = 1;
-        return;
+        return 0;
     }
 
     tmp = b & 1 ? a : 1;
@@ -244,6 +274,7 @@ static void
         b >>= 1;
     }
     *out = tmp;
+    return 0;
 }
 /**end repeat**/
 
@@ -261,12 +292,28 @@ static void
  * #op = &, ^, |#
  */
 
-#define @name@_ctype_@oper@(arg1, arg2, out) *(out) = (arg1) @op@ (arg2)
+static NPY_INLINE int
+@name@_ctype_@oper@(@type@ arg1, @type@ arg2, @type@ *out)
+{
+    *out = arg1 @op@ arg2;
+    return 0;
+}
 
 /**end repeat1**/
 
-#define @name@_ctype_lshift(arg1, arg2, out) *(out) = npy_lshift@suffix@(arg1, arg2)
-#define @name@_ctype_rshift(arg1, arg2, out) *(out) = npy_rshift@suffix@(arg1, arg2)
+static NPY_INLINE int
+@name@_ctype_lshift(@type@ arg1, @type@ arg2, @type@ *out)
+{
+    *out = npy_lshift@suffix@(arg1, arg2);
+    return 0;
+}
+
+static NPY_INLINE int
+@name@_ctype_rshift(@type@ arg1, @type@ arg2, @type@ *out)
+{
+    *out = npy_rshift@suffix@(arg1, arg2);
+    return 0;
+}
 
 /**end repeat**/
 
@@ -275,135 +322,162 @@ static void
  * #type = npy_float, npy_double, npy_longdouble#
  * #c = f, , l#
  */
-#define @name@_ctype_add(a, b, outp) *(outp) = (a) + (b)
-#define @name@_ctype_subtract(a, b, outp) *(outp) = (a) - (b)
-#define @name@_ctype_multiply(a, b, outp) *(outp) = (a) * (b)
-#define @name@_ctype_divide(a, b, outp) *(outp) = (a) / (b)
+
+/**begin repeat1
+ * #OP = +, -, *, /#
+ * #oper = add, subtract, multiply, divide#
+ */
+
+static NPY_INLINE int
+@name@_ctype_@oper@(@type@ a, @type@ b, @type@ *out)
+{
+    *out = a @OP@ b;
+    return 0;
+}
+
+/**end repeat1**/
+
 #define @name@_ctype_true_divide @name@_ctype_divide
 
 
-static void
+static NPY_INLINE int
 @name@_ctype_floor_divide(@type@ a, @type@ b, @type@ *out) {
     *out = npy_floor_divide@c@(a, b);
+    return 0;
 }
 
 
-static void
+static NPY_INLINE int
 @name@_ctype_remainder(@type@ a, @type@ b, @type@ *out) {
     *out = npy_remainder@c@(a, b);
+    return 0;
 }
 
 
-static void
+static NPY_INLINE int
 @name@_ctype_divmod(@type@ a, @type@ b, @type@ *out1, @type@ *out2) {
     *out1 = npy_divmod@c@(a, b, out2);
+    return 0;
 }
 
 
 /**end repeat**/
 
-#define half_ctype_add(a, b, outp) *(outp) = \
-        npy_float_to_half(npy_half_to_float(a) + npy_half_to_float(b))
-#define half_ctype_subtract(a, b, outp) *(outp) = \
-        npy_float_to_half(npy_half_to_float(a) - npy_half_to_float(b))
-#define half_ctype_multiply(a, b, outp) *(outp) = \
-        npy_float_to_half(npy_half_to_float(a) * npy_half_to_float(b))
-#define half_ctype_divide(a, b, outp) *(outp) = \
-        npy_float_to_half(npy_half_to_float(a) / npy_half_to_float(b))
+/**begin repeat
+ * #OP = +, -, *, /#
+ * #oper = add, subtract, multiply, divide#
+ */
+
+static NPY_INLINE int
+half_ctype_@oper@(npy_half a, npy_half b, npy_half *out)
+{
+    float res = npy_half_to_float(a) @OP@ npy_half_to_float(b);
+    *out = npy_float_to_half(res);
+    return 0;
+}
+
+/**end repeat**/
 #define half_ctype_true_divide half_ctype_divide
 
 
-static void
-half_ctype_floor_divide(npy_half a, npy_half b, npy_half *out) {
+static NPY_INLINE int
+half_ctype_floor_divide(npy_half a, npy_half b, npy_half *out)
+{
     npy_half mod;
 
     if (!b) {
-        *out = a / b;
-    } else {
+        float res = npy_half_to_float(a) / npy_half_to_float(b);
+        *out = npy_float_to_half(res);
+    }
+    else {
         *out = npy_half_divmod(a, b, &mod);
     }
+    return 0;
 }
 
 
-static void
-half_ctype_remainder(npy_half a, npy_half b, npy_half *out) {
+static NPY_INLINE int
+half_ctype_remainder(npy_half a, npy_half b, npy_half *out)
+{
     npy_half_divmod(a, b, out);
+    return 0;
 }
 
 
-static void
-half_ctype_divmod(npy_half a, npy_half b, npy_half *out1, npy_half *out2) {
+static NPY_INLINE int
+half_ctype_divmod(npy_half a, npy_half b, npy_half *out1, npy_half *out2)
+{
     *out1 = npy_half_divmod(a, b, out2);
+    return 0;
 }
 
 /**begin repeat
  * #name = cfloat, cdouble, clongdouble#
+ * #type = npy_cfloat, npy_cdouble, npy_clongdouble#
+ * #TYPE = CFLOAT, CDOUBLE, CLONGDOUBLE#
  * #rname = float, double, longdouble#
  * #rtype = npy_float, npy_double, npy_longdouble#
  * #c = f,,l#
  */
-#define @name@_ctype_add(a, b, outp) do{        \
-    (outp)->real = (a).real + (b).real;         \
-    (outp)->imag = (a).imag + (b).imag;         \
-    } while(0)
-#define @name@_ctype_subtract(a, b, outp) do{   \
-    (outp)->real = (a).real - (b).real;         \
-    (outp)->imag = (a).imag - (b).imag;         \
-    } while(0)
-#define @name@_ctype_multiply(a, b, outp) do{                   \
-    (outp)->real = (a).real * (b).real - (a).imag * (b).imag;   \
-    (outp)->imag = (a).real * (b).imag + (a).imag * (b).real;   \
-    } while(0)
-/* Algorithm identical to that in loops.c.src, for consistency */
-#define @name@_ctype_divide(a, b, outp) do{                         \
-    @rtype@ in1r = (a).real;                                        \
-    @rtype@ in1i = (a).imag;                                        \
-    @rtype@ in2r = (b).real;                                        \
-    @rtype@ in2i = (b).imag;                                        \
-    @rtype@ in2r_abs = npy_fabs@c@(in2r);                           \
-    @rtype@ in2i_abs = npy_fabs@c@(in2i);                           \
-    if (in2r_abs >= in2i_abs) {                                     \
-        if (in2r_abs == 0 && in2i_abs == 0) {                       \
-            /* divide by zero should yield a complex inf or nan */  \
-            (outp)->real = in1r/in2r_abs;                           \
-            (outp)->imag = in1i/in2i_abs;                           \
-        }                                                           \
-        else {                                                      \
-            @rtype@ rat = in2i/in2r;                                \
-            @rtype@ scl = 1.0@c@/(in2r + in2i*rat);                 \
-            (outp)->real = (in1r + in1i*rat)*scl;                   \
-            (outp)->imag = (in1i - in1r*rat)*scl;                   \
-        }                                                           \
-    }                                                               \
-    else {                                                          \
-        @rtype@ rat = in2r/in2i;                                    \
-        @rtype@ scl = 1.0@c@/(in2i + in2r*rat);                     \
-        (outp)->real = (in1r*rat + in1i)*scl;                       \
-        (outp)->imag = (in1i*rat - in1r)*scl;                       \
-    }                                                               \
-    } while(0)
+static NPY_INLINE int
+@name@_ctype_add(@type@ a, @type@ b, @type@ *out)
+{
+    out->real = a.real + b.real;
+    out->imag = a.imag + b.imag;
+    return 0;
+}
+
+static NPY_INLINE int
+@name@_ctype_subtract(@type@ a, @type@ b, @type@ *out)
+{
+    out->real = a.real - b.real;
+    out->imag = a.imag - b.imag;
+    return 0;
+}
+
+
+/*
+ * TODO: Mark as  to work around FPEs not being issues on clang 12.
+ *       This should be removed when possible.
+ */
+static NPY_INLINE int
+@name@_ctype_multiply( @type@ a, @type@ b, @type@ *out)
+{
+    out->real = a.real * b.real - a.imag * b.imag;
+    out->imag = a.real * b.imag + a.imag * b.real;
+    return 0;
+}
+
+/* Use the ufunc loop directly to avoid duplicating the complicated logic */
+static NPY_INLINE int
+@name@_ctype_divide(@type@ a, @type@ b, @type@ *out)
+{
+    char *args[3] = {(char *)&a, (char *)&b, (char *)out};
+    npy_intp steps[3];
+    npy_intp size = 1;
+    @TYPE@_divide(args, &size, steps, NULL);
+    return 0;
+}
 
 #define @name@_ctype_true_divide @name@_ctype_divide
 
-#define @name@_ctype_floor_divide(a, b, outp) do {      \
-    @rname@_ctype_floor_divide(                         \
-        ((a).real*(b).real + (a).imag*(b).imag),        \
-        ((b).real*(b).real + (b).imag*(b).imag),        \
-        &((outp)->real));                               \
-    (outp)->imag = 0;                                   \
-    } while(0)
 /**end repeat**/
 
 
 
 /**begin repeat
  * #name = byte, ubyte, short, ushort, int, uint, long, ulong,
- *         longlong, ulonglong, cfloat, cdouble, clongdouble#
+ *         longlong, ulonglong#
  */
-#define @name@_ctype_divmod(a, b, out, out2) {  \
-    @name@_ctype_floor_divide(a, b, out);       \
-    @name@_ctype_remainder(a, b, out2);         \
-    }
+
+static NPY_INLINE int
+@name@_ctype_divmod(npy_@name@ a, npy_@name@ b, npy_@name@ *out, npy_@name@ *out2)
+{
+    int res = @name@_ctype_floor_divide(a, b, out);
+    res |= @name@_ctype_remainder(a, b, out2);
+    return res;
+}
+
 /**end repeat**/
 
 
@@ -413,20 +487,22 @@ half_ctype_divmod(npy_half a, npy_half b, npy_half *out1, npy_half *out2) {
  * #c = f,,l#
  */
 
-static void
+static NPY_INLINE int
 @name@_ctype_power(@type@ a, @type@ b, @type@ *out)
 {
     *out = npy_pow@c@(a, b);
+    return 0;
 }
 
 /**end repeat**/
-static void
+static NPY_INLINE int
 half_ctype_power(npy_half a, npy_half b, npy_half *out)
 {
     const npy_float af = npy_half_to_float(a);
     const npy_float bf = npy_half_to_float(b);
     const npy_float outf = npy_powf(af,bf);
     *out = npy_float_to_half(outf);
+    return 0;
 }
 
 /**begin repeat
@@ -436,22 +512,40 @@ half_ctype_power(npy_half a, npy_half b, npy_half *out)
  * #type = npy_byte, npy_ubyte, npy_short, npy_ushort, npy_int, npy_uint,
  *         npy_long, npy_ulong, npy_longlong, npy_ulonglong,
  *         npy_float, npy_double, npy_longdouble#
+ * #NAME = BYTE, UBYTE, SHORT, USHORT, INT, UINT,
+ *         LONG, ULONG, LONGLONG, ULONGLONG,
+ *         FLOAT, DOUBLE, LONGDOUBLE#
  * #uns = (0,1)*5,0*3#
+ * #int = 1*10,0*3#
  */
-static void
+static NPY_INLINE int
 @name@_ctype_negative(@type@ a, @type@ *out)
 {
 #if @uns@
-    npy_set_floatstatus_overflow();
-#endif
     *out = -a;
+    if (a == 0) {
+        return 0;
+    }
+    return NPY_FPE_OVERFLOW;
+#elif @int@
+    if (a == NPY_MIN_@NAME@){
+        *out = a;
+        return NPY_FPE_OVERFLOW;
+    }
+    *out = -a;
+    return 0;
+#else  /* floats */
+    *out = -a;
+    return 0;
+#endif
 }
 /**end repeat**/
 
-static void
+static NPY_INLINE int
 half_ctype_negative(npy_half a, npy_half *out)
 {
     *out = a^0x8000u;
+    return 0;
 }
 
 
@@ -459,11 +553,12 @@ half_ctype_negative(npy_half a, npy_half *out)
  * #name = cfloat, cdouble, clongdouble#
  * #type = npy_cfloat, npy_cdouble, npy_clongdouble#
  */
-static void
+static NPY_INLINE int
 @name@_ctype_negative(@type@ a, @type@ *out)
 {
     out->real = -a.real;
     out->imag = -a.imag;
+    return 0;
 }
 /**end repeat**/
 
@@ -475,10 +570,11 @@ static void
  *         npy_long, npy_ulong, npy_longlong, npy_ulonglong,
  *         npy_half, npy_float, npy_double, npy_longdouble#
  */
-static void
+static NPY_INLINE int
 @name@_ctype_positive(@type@ a, @type@ *out)
 {
     *out = a;
+    return 0;
 }
 /**end repeat**/
 
@@ -487,17 +583,19 @@ static void
  * #type = npy_cfloat, npy_cdouble, npy_clongdouble#
  * #c = f,,l#
  */
-static void
+static NPY_INLINE int
 @name@_ctype_positive(@type@ a, @type@ *out)
 {
     out->real = a.real;
     out->imag = a.imag;
+    return 0;
 }
 
-static void
+static NPY_INLINE int
 @name@_ctype_power(@type@ a, @type@ b, @type@ *out)
 {
     *out = npy_cpow@c@(a, b);
+    return 0;
 }
 /**end repeat**/
 
@@ -514,11 +612,17 @@ static void
 /**begin repeat
  * #name = byte, short, int, long, longlong#
  * #type = npy_byte, npy_short, npy_int, npy_long, npy_longlong#
+ * #NAME = BYTE, SHORT, INT, LONG, LONGLONG#
  */
-static void
+static NPY_INLINE int
 @name@_ctype_absolute(@type@ a, @type@ *out)
 {
+    if (a == NPY_MIN_@NAME@) {
+        *out = a;
+        return NPY_FPE_OVERFLOW;
+    }
     *out = (a < 0 ? -a : a);
+    return 0;
 }
 /**end repeat**/
 
@@ -527,17 +631,19 @@ static void
  * #type = npy_float, npy_double, npy_longdouble#
  * #c = f,,l#
  */
-static void
+static NPY_INLINE int
 @name@_ctype_absolute(@type@ a, @type@ *out)
 {
     *out = npy_fabs@c@(a);
+    return 0;
 }
 /**end repeat**/
 
-static void
+static NPY_INLINE int
 half_ctype_absolute(npy_half a, npy_half *out)
 {
     *out = a&0x7fffu;
+    return 0;
 }
 
 /**begin repeat
@@ -546,10 +652,11 @@ half_ctype_absolute(npy_half a, npy_half *out)
  * #rtype = npy_float, npy_double, npy_longdouble#
  * #c = f,,l#
  */
-static void
+static NPY_INLINE int
 @name@_ctype_absolute(@type@ a, @rtype@ *out)
 {
     *out = npy_cabs@c@(a);
+    return 0;
 }
 /**end repeat**/
 
@@ -558,196 +665,505 @@ static void
  *         ulong, longlong, ulonglong#
  */
 
-#define @name@_ctype_invert(a, out) *(out) = ~a;
+static NPY_INLINE int
+@name@_ctype_invert(npy_@name@ a, npy_@name@ *out)
+{
+    *out = ~a;
+    return 0;
+}
 
 /**end repeat**/
 
 /*** END OF BASIC CODE **/
 
 
-/* The general strategy for commutative binary operators is to
+/*
+ * How binary operators work
+ * -------------------------
+ *
+ * All binary (numeric) operators use the larger of the two types, with the
+ * exception of unsigned int and signed int mixed cases which must promote
+ * to a larger type.
+ *
+ * The strategy employed for all binary operation is that we coerce the other
+ * scalar if it is safe to do.  E.g. `float64 + float32` the `float64` can
+ * convert `float32` and do the operation as `float64 + float64`.
+ * OTOH, for `float32 + float64` it is safe, and we should defer to `float64`.
+ *
+ * So we have multiple possible paths:
+ * - The other scalar is a subclass.  In principle *both* inputs could be
+ *   different subclasses.  In this case it would make sense to defer, but
+ *   Python's `int` does not try this as well, so we do not here:
+ *
+ *      class A(int): pass
+ *      class B(int):
+ *          def __add__(self, other): return "b"
+ *          __radd__ = __add__
+ *
+ *      A(1) + B(1)  # return 2
+ *      B(1) + A(1)  # return "b"
+ *
+ * - The other scalar can be converted:  All is good, we do the operation
+ * - The other scalar cannot be converted, there are two possibilities:
+ *   - The reverse should work, so we return NotImplemented to defer.
+ *     (If self is a subclass, this will end up in the "unknown" path.)
+ *   - Neither works (e.g. `uint8 + int8`):  We currently use the array path.
+ * - The other object is a unknown.  It could be either a scalar, an array,
+ *   or an array-like (including a list!).  Because NumPy scalars pretend to be
+ *   arrays we fall into the array fallback path here _normally_ (through
+ *   the generic scalar path).
+ *   First we check if we should defer, though.
+ *
+ * The last possibility is awkward and leads to very confusing situations.
+ * The problem is that usually we should defer (return NotImplemented)
+ * in that path.
+ * If the other object is a NumPy array (or array-like) it will know what to
+ * do.  If NumPy knows that it is a scalar (not generic `object`), then it
+ * would make sense to try and use the "array path" (i.e. deal with it
+ * using the ufunc machinery).
  *
- * 1) Convert the types to the common type if both are scalars (0 return)
- * 2) If both are not scalars use ufunc machinery (-2 return)
- * 3) If both are scalars but cannot be cast to the right type
- * return NotImplemented (-1 return)
+ * But this overlooks two things that currently work:
  *
- * 4) Perform the function on the C-type.
- * 5) If an error condition occurred, check to see
- * what the current error-handling is and handle the error.
+ * 1. `np.float64(3) * [1, 2, 3]`  happily returns an array result.
+ * 2. `np.int32(3) * decimal.Decimal(3)` works!  (see below)
  *
- * 6) Construct and return the output scalar.
+ * The first must work, because scalars pretend to be arrays.  Which means
+ * they inherit the greedy "convert the other object to an array" logic.
+ * This may be a questionable choice, but is fine.
+ * (As of now, it is not negotiable, since NumPy often converts 0-D arrays
+ * to scalars.)
+ *
+ * The second one is more confusing.  This works also by using the ufunc
+ * machinery (array path), but it works because:
+ *
+ *     np.add(np.int32(3), decimal.Decimal(3))
+ *
+ * Will convert the `int32` to an int32 array, and the decimal to an object
+ * array.  It then *casts* the `int32` array to an object array.
+ * The casting step CONVERTS the integer to a Python integer.  The ufunc object
+ * loop will then call back into Python scalar logic.
+ *
+ * The above would be recursive, if it was not for the conversion of the int32
+ * to a Python integer!
+ * This leads us to the EXCEEDINGLY IMPORTANT special case:
+ *
+ * WARNING: longdouble and clongdouble do NOT convert to a Python scalar
+ *          when cast to object.  Thus they MUST NEVER take the array-path.
+ *          However, they STILL should defer at least for
+ *          `np.longdouble(3) + array`.
+ *
+ *
+ * As a general note, in the above we defer exactly when we know that deferring
+ * will work.  `longdouble` uses the "simple" logic of generally deferring
+ * though, because it would otherwise easily run into an infinite recursion.
+ *
+ *
+ * The future?!
+ * ------------
+ *
+ * This is very tricky and it would be nice to formalize away that "recursive"
+ * path we currently use.  I (seberg) have currently no great idea on this,
+ * this is more brainstorming!
+ *
+ * If both are scalars (known to NumPy), they have a DType and we may be able
+ * to do the ufunc promotion to make sure there is no risk of recursion.
+ *
+ * In principle always deferring would probably be clean.  But we likely cannot
+ * do that?  There is also an issue that it is nice that we allow adding a
+ * DType for an existing Python scalar (which will not know about NumPy
+ * scalars).
+ * The DType/ufunc machinery teaches NumPy how arrays will work with that
+ * Python scalar, but the DType may need to help us decide whether we should
+ * defer (return NotImplemented) or try using the ufunc machinery (or a
+ * simplified ufunc-like machinery limited to scalars).
+ */
+
+
+/*
+ * Enum used to describe the space of possibilities when converting the second
+ * argument to a binary operation.
+ * Any of these flags may be combined with the return flag of
+ * `may_need_deferring` indicating that the other is any type of object which
+ * may e.g. define an `__array_priority__`.
  */
+typedef enum {
+    /* An error occurred (should not really happen/be possible) */
+    CONVERSION_ERROR = -1,
+    /* A known NumPy scalar, but of higher precision: we defer */
+    DEFER_TO_OTHER_KNOWN_SCALAR,
+    /*
+     * Conversion was successful (known scalar of less precision).  Note that
+     * the other value may still be a subclass of such a scalar so even here
+     * we may have to check for deferring.
+     * More specialized subclass handling, which defers based on whether the
+     * subclass has an implementation, plausible but complicated.
+     * We do not do it, as even CPython does not do it for the builtin `int`.
+     */
+    CONVERSION_SUCCESS,
+    /*
+     * We use the normal conversion (setitem) function when coercing from
+     * Python scalars.
+     */
+    CONVERT_PYSCALAR,
+    /*
+     * Other object is an unkown scalar or array-like, we (typically) use
+     * the generic path, which normally ends up in the ufunc machinery.
+     */
+    OTHER_IS_UNKNOWN_OBJECT,
+    /*
+     * Promotion necessary
+     */
+    PROMOTION_REQUIRED,
+} conversion_result;
 
 /**begin repeat
  * #name = byte, ubyte, short, ushort, int, uint,
  *         long, ulong, longlong, ulonglong,
- *         half, float, longdouble,
+ *         half, float, double, longdouble,
  *         cfloat, cdouble, clongdouble#
- * #type = npy_byte, npy_ubyte, npy_short, npy_ushort, npy_int, npy_uint,
- *         npy_long, npy_ulong, npy_longlong, npy_ulonglong,
- *         npy_half, npy_float, npy_longdouble,
- *         npy_cfloat, npy_cdouble, npy_clongdouble#
  * #Name = Byte, UByte, Short, UShort, Int, UInt,
  *         Long, ULong, LongLong, ULongLong,
- *         Half, Float, LongDouble,
+ *         Half, Float, Double, LongDouble,
  *         CFloat, CDouble, CLongDouble#
- * #TYPE = NPY_BYTE, NPY_UBYTE, NPY_SHORT, NPY_USHORT, NPY_INT, NPY_UINT,
- *         NPY_LONG, NPY_ULONG, NPY_LONGLONG, NPY_ULONGLONG,
- *         NPY_HALF, NPY_FLOAT, NPY_LONGDOUBLE,
- *         NPY_CFLOAT, NPY_CDOUBLE, NPY_CLONGDOUBLE#
+ * #TYPE = BYTE, UBYTE, SHORT, USHORT, INT, UINT,
+ *         LONG, ULONG, LONGLONG, ULONGLONG,
+ *         HALF, FLOAT, DOUBLE, LONGDOUBLE,
+ *         CFLOAT, CDOUBLE, CLONGDOUBLE#
+ * #type = npy_byte, npy_ubyte, npy_short, npy_ushort, npy_int, npy_uint,
+ *         npy_long, npy_ulong, npy_longlong, npy_ulonglong,
+ *         npy_half, npy_float, npy_double, npy_longdouble,
+ *         npy_cfloat, npy_cdouble, npy_clongdouble#
  */
 
-static int
-_@name@_convert_to_ctype(PyObject *a, @type@ *arg1)
-{
-    PyObject *temp;
-
-    if (PyArray_IsScalar(a, @Name@)) {
-        *arg1 = PyArrayScalar_VAL(a, @Name@);
-        return 0;
-    }
-    else if (PyArray_IsScalar(a, Generic)) {
-        PyArray_Descr *descr1;
+#define IS_@TYPE@ 1
 
-        if (!PyArray_IsScalar(a, Number)) {
-            return -1;
-        }
-        descr1 = PyArray_DescrFromTypeObject((PyObject *)Py_TYPE(a));
-        if (PyArray_CanCastSafely(descr1->type_num, @TYPE@)) {
-            PyArray_CastScalarDirect(a, descr1, arg1, @TYPE@);
-            Py_DECREF(descr1);
-            return 0;
-        }
-        else {
-            Py_DECREF(descr1);
-            return -1;
-        }
-    }
-    else if (PyArray_GetPriority(a, NPY_PRIORITY) > NPY_PRIORITY) {
-        return -2;
-    }
-    else if ((temp = PyArray_ScalarFromObject(a)) != NULL) {
-        int retval = _@name@_convert_to_ctype(temp, arg1);
+#define IS_SAFE(FROM, TO) _npy_can_cast_safely_table[FROM][TO]
 
-        Py_DECREF(temp);
-        return retval;
-    }
-    return -2;
-}
+/*
+ * TODO: This whole thing is awkward, and we should create a helper header to
+ *       define inline functions that convert single elements for all numeric
+ *       types.  That could then also be used to define all cast loops.
+ *       (Even if that may get more complex for SIMD at some point.)
+ *       For now, half casts could be optimized because of that.
+ */
 
-/**end repeat**/
+#if defined(IS_HALF)
+    #define CONVERT_TO_RESULT(value)  \
+        *result = npy_float_to_half((float)(value))
+#elif defined(IS_CFLOAT) || defined(IS_CDOUBLE) || defined(IS_CLONGDOUBLE)
+    #define CONVERT_TO_RESULT(value)  \
+        result->real = value;  \
+        result->imag = 0
+#else
+    #define CONVERT_TO_RESULT(value) *result = value
+#endif
 
 
-/* Same as above but added exact checks against known python types for speed */
+#define GET_VALUE_OR_DEFER(OTHER, Other, value)  \
+    case NPY_##OTHER:  \
+        if (IS_SAFE(NPY_##OTHER, NPY_@TYPE@)) {  \
+            CONVERT_TO_RESULT(PyArrayScalar_VAL(value, Other));  \
+            ret = CONVERSION_SUCCESS;  \
+        }  \
+        else if (IS_SAFE(NPY_@TYPE@, NPY_##OTHER)) {  \
+            /*
+             * If self can cast safely to other, this is clear:
+             * we should definitely defer.
+             */  \
+             ret = DEFER_TO_OTHER_KNOWN_SCALAR;  \
+        }  \
+        else {  \
+            /* Otherwise, we must promote */  \
+            ret = PROMOTION_REQUIRED;  \
+        }  \
+        break;
 
-/**begin repeat
- * #name = double#
- * #type = npy_double#
- * #Name = Double#
- * #TYPE = NPY_DOUBLE#
- * #PYCHECKEXACT = PyFloat_CheckExact#
- * #PYEXTRACTCTYPE = PyFloat_AS_DOUBLE#
+/*
+ * Complex to complex (and rejecting complex to real) is a bit different:
  */
 
-static int
-_@name@_convert_to_ctype(PyObject *a, @type@ *arg1)
+#if defined(IS_CFLOAT) || defined(IS_CDOUBLE) || defined(IS_CLONGDOUBLE)
+
+#define GET_CVALUE_OR_DEFER(OTHER, Other, value)  \
+    case NPY_##OTHER:  \
+        if (IS_SAFE(NPY_##OTHER, NPY_@TYPE@)) {  \
+            assert(Py_TYPE(value) == &Py##Other##ArrType_Type);  \
+            result->real = PyArrayScalar_VAL(value, Other).real;  \
+            result->imag = PyArrayScalar_VAL(value, Other).imag;  \
+            ret = 1;  \
+        }  \
+        else if (IS_SAFE(NPY_@TYPE@, NPY_##OTHER)) {  \
+             ret = DEFER_TO_OTHER_KNOWN_SCALAR;  \
+        }  \
+        else {  \
+            ret = PROMOTION_REQUIRED;  \
+        }  \
+        break;
+
+#else
+
+/* Getting a complex value to real is never safe: */
+#define GET_CVALUE_OR_DEFER(OTHER, Other, value)  \
+    case NPY_##OTHER:  \
+        if (IS_SAFE(NPY_@TYPE@, NPY_##OTHER)) {  \
+            ret = DEFER_TO_OTHER_KNOWN_SCALAR;  \
+        }  \
+        else {  \
+            ret = PROMOTION_REQUIRED;  \
+        }  \
+        break;
+
+#endif
+
+
+/**
+ * Convert the value to the own type and and store the result.
+ *
+ * @param value The value to convert (if compatible)
+ * @param result The result value (output)
+ * @param may_need_deferring Set to `NPY_TRUE` when the caller must check
+ *        `BINOP_GIVE_UP_IF_NEEDED` (or similar) due to possible implementation
+ *        of `__array_priority__` (or similar).
+ *        This is set for unknown objects and all subclasses even when they
+ *        can be handled.
+ * @result The result value indicating what we did with `value` or what type
+ *         of object it is (see `conversion_result`).
+ */
+static NPY_INLINE conversion_result
+convert_to_@name@(PyObject *value, @type@ *result, npy_bool *may_need_deferring)
 {
-    PyObject *temp;
+    PyArray_Descr *descr;
+    *may_need_deferring = NPY_FALSE;
 
-    if (@PYCHECKEXACT@(a)){
-        *arg1 = @PYEXTRACTCTYPE@(a);
-        return 0;
+    if (Py_TYPE(value) == &Py@Name@ArrType_Type) {
+        *result = PyArrayScalar_VAL(value, @Name@);
+        return CONVERSION_SUCCESS;
+    }
+    /* Optimize the identical scalar specifically. */
+    if (PyArray_IsScalar(value, @Name@)) {
+        *result = PyArrayScalar_VAL(value, @Name@);
+        /*
+         * In principle special, assyemetric, handling could be possible for
+         * explicit subclasses.
+         * In practice, we just check the normal deferring logic.
+         */
+        *may_need_deferring = NPY_TRUE;
+        return CONVERSION_SUCCESS;
     }
 
-    if (PyArray_IsScalar(a, @Name@)) {
-        *arg1 = PyArrayScalar_VAL(a, @Name@);
-        return 0;
+    /*
+     * Then we check for the basic Python types float, int, and complex.
+     * (this is a bit tedious to do right for complex).
+     */
+    if (PyBool_Check(value)) {
+        CONVERT_TO_RESULT(value == Py_True);
+        return CONVERSION_SUCCESS;
     }
-    else if (PyArray_IsScalar(a, Generic)) {
-        PyArray_Descr *descr1;
 
-        if (!PyArray_IsScalar(a, Number)) {
-            return -1;
-        }
-        descr1 = PyArray_DescrFromTypeObject((PyObject *)Py_TYPE(a));
-        if (PyArray_CanCastSafely(descr1->type_num, @TYPE@)) {
-            PyArray_CastScalarDirect(a, descr1, arg1, @TYPE@);
-            Py_DECREF(descr1);
-            return 0;
+    if (PyFloat_Check(value)) {
+        if (!PyFloat_CheckExact(value)) {
+            /* A NumPy double is a float subclass, but special. */
+            if (PyArray_IsScalar(value, Double)) {
+                descr = PyArray_DescrFromType(NPY_DOUBLE);
+                goto numpy_scalar;
+            }
+            *may_need_deferring = NPY_TRUE;
         }
-        else {
-            Py_DECREF(descr1);
-            return -1;
+        if (!IS_SAFE(NPY_DOUBLE, NPY_@TYPE@)) {
+            if (npy_promotion_state != NPY_USE_WEAK_PROMOTION) {
+                /* Legacy promotion and weak-and-warn not handled here */
+                return PROMOTION_REQUIRED;
+            }
+            /* Weak promotion is used when self is float or complex: */
+            if (!PyTypeNum_ISFLOAT(NPY_@TYPE@) && !PyTypeNum_ISCOMPLEX(NPY_@TYPE@)) {
+                return PROMOTION_REQUIRED;
+            }
+            return CONVERT_PYSCALAR;
         }
+        CONVERT_TO_RESULT(PyFloat_AS_DOUBLE(value));
+        return CONVERSION_SUCCESS;
     }
-    else if (PyArray_GetPriority(a, NPY_PRIORITY) > NPY_PRIORITY) {
-        return -2;
-    }
-    else if ((temp = PyArray_ScalarFromObject(a)) != NULL) {
-        int retval = _@name@_convert_to_ctype(temp, arg1);
 
-        Py_DECREF(temp);
-        return retval;
+    if (PyLong_Check(value)) {
+        if (!PyLong_CheckExact(value)) {
+            *may_need_deferring = NPY_TRUE;
+        }
+        if (!IS_SAFE(NPY_LONG, NPY_@TYPE@)) {
+            /*
+             * long -> (c)longdouble is safe, so `OTHER_IS_UNKNOWN_OBJECT` will
+             * be returned below for huge integers.
+             */
+            if (npy_promotion_state != NPY_USE_WEAK_PROMOTION) {
+                /* Legacy promotion and weak-and-warn not handled here */
+                return PROMOTION_REQUIRED;
+            }
+            return CONVERT_PYSCALAR;
+        }
+        int overflow;
+        long val = PyLong_AsLongAndOverflow(value, &overflow);
+        if (overflow) {
+            /* handle as if "unsafe" */
+            if (npy_promotion_state != NPY_USE_WEAK_PROMOTION) {
+                return OTHER_IS_UNKNOWN_OBJECT;
+            }
+            return CONVERT_PYSCALAR;
+        }
+        if (error_converting(val)) {
+            return CONVERSION_ERROR;  /* should not be possible */
+        }
+        CONVERT_TO_RESULT(val);
+        return CONVERSION_SUCCESS;
     }
-    return -2;
-}
 
-/**end repeat**/
-
-
-/**begin repeat
- * #name = byte, ubyte, short, ushort, int, uint,
- *         long, ulong, longlong, ulonglong,
- *         half, float, double, cfloat, cdouble#
- * #type = npy_byte, npy_ubyte, npy_short, npy_ushort, npy_int, npy_uint,
- *         npy_long, npy_ulong, npy_longlong, npy_ulonglong,
- *         npy_half, npy_float, npy_double, npy_cfloat, npy_cdouble#
- */
-static int
-_@name@_convert2_to_ctypes(PyObject *a, @type@ *arg1,
-                           PyObject *b, @type@ *arg2)
-{
-    int ret;
-    ret = _@name@_convert_to_ctype(a, arg1);
-    if (ret < 0) {
-        return ret;
-    }
-    ret = _@name@_convert_to_ctype(b, arg2);
-    if (ret < 0) {
-        return ret;
+    if (PyComplex_Check(value)) {
+        if (!PyComplex_CheckExact(value)) {
+            /* A NumPy complex double is a float subclass, but special. */
+            if (PyArray_IsScalar(value, CDouble)) {
+                descr = PyArray_DescrFromType(NPY_CDOUBLE);
+                goto numpy_scalar;
+            }
+            *may_need_deferring = NPY_TRUE;
+        }
+        if (!IS_SAFE(NPY_CDOUBLE, NPY_@TYPE@)) {
+            if (npy_promotion_state != NPY_USE_WEAK_PROMOTION) {
+                /* Legacy promotion and weak-and-warn not handled here */
+                return PROMOTION_REQUIRED;
+            }
+            /* Weak promotion is used when self is float or complex: */
+            if (!PyTypeNum_ISCOMPLEX(NPY_@TYPE@)) {
+                return PROMOTION_REQUIRED;
+            }
+            return CONVERT_PYSCALAR;
+        }
+#if defined(IS_CFLOAT) || defined(IS_CDOUBLE) || defined(IS_CLONGDOUBLE)
+        Py_complex val = PyComplex_AsCComplex(value);
+        if (error_converting(val.real)) {
+            return CONVERSION_ERROR;  /* should not be possible */
+        }
+        result->real = val.real;
+        result->imag = val.imag;
+        return CONVERSION_SUCCESS;
+#else
+        /* unreachable, always unsafe cast above; return to avoid warning */
+        assert(0);
+        return OTHER_IS_UNKNOWN_OBJECT;
+#endif  /* defined(IS_CFLOAT) || ... */
     }
-    return 0;
-}
-/**end repeat**/
 
-/**begin repeat
- * #name = longdouble, clongdouble#
- * #type = npy_longdouble, npy_clongdouble#
- */
-
-static int
-_@name@_convert2_to_ctypes(PyObject *a, @type@ *arg1,
-                           PyObject *b, @type@ *arg2)
-{
-    int ret;
-    ret = _@name@_convert_to_ctype(a, arg1);
-    if (ret == -2) {
-        ret = -3;
+    /*
+     * (seberg) It would be nice to use `PyArray_DiscoverDTypeFromScalarType`
+     * from array coercion here.  OTOH, the array coercion code also falls
+     * back to this code.  The issue is around how subclasses should work...
+     *
+     * It would be nice to try to fully align the paths again (they effectively
+     * are equivalent).  Proper support for subclasses is in general tricky,
+     * and it would make more sense to just _refuse_ to support them.
+     * However, it is unclear that this is a viable option...
+     */
+    if (!PyArray_IsScalar(value, Generic)) {
+        /*
+         * The input is an unknown python object.  This should probably defer
+         * but only does so for float128.
+         * For all other cases, we defer to the array logic.  If the object
+         * is indeed not an array-like, this will end up converting the NumPy
+         * scalar to a Python scalar and then try again.
+         * The logic is that the ufunc casts the input to object, which does
+         * the conversion.
+         * If the object is an array, deferring will always kick in.
+         */
+        *may_need_deferring = NPY_TRUE;
+        return OTHER_IS_UNKNOWN_OBJECT;
     }
-    if (ret < 0) {
-        return ret;
+
+    descr = PyArray_DescrFromScalar(value);
+    if (descr == NULL) {
+        if (PyErr_Occurred()) {
+            return CONVERSION_ERROR;
+        }
+        /* Should not happen, but may be possible with bad user subclasses */
+        *may_need_deferring = NPY_TRUE;
+        return OTHER_IS_UNKNOWN_OBJECT;
     }
-    ret = _@name@_convert_to_ctype(b, arg2);
-    if (ret == -2) {
-        ret = -3;
+
+  numpy_scalar:
+    if (descr->typeobj != Py_TYPE(value)) {
+        /*
+         * This is a subclass of a builtin type, we may continue normally,
+         * but should check whether we need to defer.
+         */
+        *may_need_deferring = NPY_TRUE;
     }
-    if (ret < 0) {
-        return ret;
+
+    /*
+     * Otherwise, we have a clear NumPy scalar, find if it is a compatible
+     * builtin scalar.
+     * Each `GET_VALUE_OR_DEFER` represents a case clause for its type number,
+     * extracting the value if it is safe and otherwise deferring.
+     * (Safety is known at compile time, so the switch statement should be
+     * simplified by the compiler accordingly.)
+     * If we have a scalar that is not listed or not safe, we defer to it.
+     *
+     * We should probably defer more aggressively, but that is too big a change,
+     * since it would disable `np.float64(1.) * [1, 2, 3, 4]`.
+     */
+    int ret;  /* set by the GET_VALUE_OR_DEFER macro */
+    switch (descr->type_num) {
+        GET_VALUE_OR_DEFER(BOOL, Bool, value);
+        /* UInts */
+        GET_VALUE_OR_DEFER(UBYTE, UByte, value);
+        GET_VALUE_OR_DEFER(USHORT, UShort, value);
+        GET_VALUE_OR_DEFER(UINT, UInt, value);
+        GET_VALUE_OR_DEFER(ULONG, ULong, value);
+        GET_VALUE_OR_DEFER(ULONGLONG, ULongLong, value);
+        /* Ints */
+        GET_VALUE_OR_DEFER(BYTE, Byte, value);
+        GET_VALUE_OR_DEFER(SHORT, Short, value);
+        GET_VALUE_OR_DEFER(INT, Int, value);
+        GET_VALUE_OR_DEFER(LONG, Long, value);
+        GET_VALUE_OR_DEFER(LONGLONG, LongLong, value);
+        /* Floats */
+        case NPY_HALF:
+            if (IS_SAFE(NPY_HALF, NPY_@TYPE@)) {
+                CONVERT_TO_RESULT(npy_half_to_float(PyArrayScalar_VAL(value, Half)));
+                ret = CONVERSION_SUCCESS;
+            }
+            else if (IS_SAFE(NPY_@TYPE@, NPY_HALF)) {
+                ret = DEFER_TO_OTHER_KNOWN_SCALAR;
+            }
+            else {
+                ret = PROMOTION_REQUIRED;
+            }
+            break;
+        GET_VALUE_OR_DEFER(FLOAT, Float, value);
+        GET_VALUE_OR_DEFER(DOUBLE, Double, value);
+        GET_VALUE_OR_DEFER(LONGDOUBLE, LongDouble, value);
+        /* Complex: We should still defer, but the code won't work... */
+        GET_CVALUE_OR_DEFER(CFLOAT, CFloat, value);
+        GET_CVALUE_OR_DEFER(CDOUBLE, CDouble, value);
+        GET_CVALUE_OR_DEFER(CLONGDOUBLE, CLongDouble, value);
+        default:
+            /*
+             * If there is no match, this is an unknown scalar object.  It
+             * would make sense to defer generously here, but it should also
+             * always be safe to use the array path.
+             * The issue is, that the other scalar may or may not be designed
+             * to deal with NumPy scalars.  Without knowing that, we cannot
+             * defer (which would be much faster potentially).
+             * TODO: We could add a DType flag to allow opting in to deferring!
+             */
+            *may_need_deferring = NPY_TRUE;
+            ret = OTHER_IS_UNKNOWN_OBJECT;
     }
-    return 0;
+    Py_DECREF(descr);
+    return ret;
 }
 
+#undef IS_SAFE
+#undef CONVERT_TO_RESULT
+#undef GET_VALUE_OR_DEFER
+#undef GET_CVALUE_OR_DEFER
+#undef IS_@TYPE@
+
 /**end repeat**/
 
 
@@ -756,118 +1172,184 @@ _@name@_convert2_to_ctypes(PyObject *a, @type@ *arg1,
  * #name = (byte, ubyte, short, ushort, int, uint,
  *             long, ulong, longlong, ulonglong)*12,
  *         (half, float, double, longdouble,
- *             cfloat, cdouble, clongdouble)*5,
- *         (half, float, double, longdouble)*2#
+ *             cfloat, cdouble, clongdouble)*4,
+ *         (half, float, double, longdouble)*3#
  * #Name = (Byte, UByte, Short, UShort, Int, UInt,
  *             Long, ULong,LongLong,ULongLong)*12,
  *         (Half, Float, Double, LongDouble,
- *             CFloat, CDouble, CLongDouble)*5,
- *         (Half, Float, Double, LongDouble)*2#
+ *             CFloat, CDouble, CLongDouble)*4,
+ *         (Half, Float, Double, LongDouble)*3#
+ * #NAME = (BYTE, UBYTE, SHORT, USHORT, INT, UINT,
+ *              LONG, ULONG, LONGLONG, ULONGLONG)*12,
+ *          (HALF, FLOAT, DOUBLE, LONGDOUBLE,
+ *              CFLOAT, CDOUBLE, CLONGDOUBLE)*4,
+ *          (HALF, FLOAT, DOUBLE, LONGDOUBLE)*3#
  * #type = (npy_byte, npy_ubyte, npy_short, npy_ushort, npy_int, npy_uint,
  *             npy_long, npy_ulong, npy_longlong, npy_ulonglong)*12,
  *         (npy_half, npy_float, npy_double, npy_longdouble,
- *             npy_cfloat, npy_cdouble, npy_clongdouble)*5,
- *         (npy_half, npy_float, npy_double, npy_longdouble)*2#
+ *             npy_cfloat, npy_cdouble, npy_clongdouble)*4,
+ *         (npy_half, npy_float, npy_double, npy_longdouble)*3#
  *
  * #oper = add*10, subtract*10, multiply*10, remainder*10,
  *         divmod*10, floor_divide*10, lshift*10, rshift*10, and*10,
  *         or*10, xor*10, true_divide*10,
- *         add*7, subtract*7, multiply*7, floor_divide*7, true_divide*7,
- *         divmod*4, remainder*4#
+ *         add*7, subtract*7, multiply*7, true_divide*7,
+ *         floor_divide*4, divmod*4, remainder*4#
  *
- * #fperr = 1*60,0*50,1*10,
- *          1*35,
- *          1*8#
+ * #fperr = 0*110, 1*10,
+ *          1*28, 1*12#
  * #twoout = 0*40,1*10,0*70,
- *           0*35,
- *           1*4,0*4#
+ *           0*28,
+ *           0*4,1*4,0*4#
  * #otype = (npy_byte, npy_ubyte, npy_short, npy_ushort, npy_int, npy_uint,
  *             npy_long, npy_ulong, npy_longlong, npy_ulonglong)*11,
- *         npy_float*4, npy_double*6,
+ *         npy_double*10,
  *         (npy_half, npy_float, npy_double, npy_longdouble,
- *             npy_cfloat, npy_cdouble, npy_clongdouble)*5,
- *         (npy_half, npy_float, npy_double, npy_longdouble)*2#
+ *             npy_cfloat, npy_cdouble, npy_clongdouble)*4,
+ *         (npy_half, npy_float, npy_double, npy_longdouble)*3#
  * #OName = (Byte, UByte, Short, UShort, Int, UInt,
  *              Long, ULong, LongLong, ULongLong)*11,
- *          Float*4, Double*6,
+ *          Double*10,
  *          (Half, Float, Double, LongDouble,
- *              CFloat, CDouble, CLongDouble)*5,
- *          (Half, Float, Double, LongDouble)*2#
+ *              CFloat, CDouble, CLongDouble)*4,
+ *          (Half, Float, Double, LongDouble)*3#
  */
+#define IS_@name@
+/* drop the "true_" from "true_divide" for floating point warnings: */
+#define IS_@oper@
+#ifdef IS_true_divide
+    #define OP_NAME "divide"
+#else
+    #define OP_NAME "@oper@"
+#endif
 
 static PyObject *
 @name@_@oper@(PyObject *a, PyObject *b)
 {
     PyObject *ret;
-    @type@ arg1, arg2;
-    @otype@ out;
+    @type@ arg1, arg2, other_val;
 
-#if @twoout@
-    @otype@ out2;
-    PyObject *obj;
-#endif
-
-#if @fperr@
-    int retstatus;
-    int first;
-#endif
+    /*
+     * Check if this operation may be considered forward.  Note `is_forward`
+     * does not imply that we can defer to a subclass `b`.  It just means that
+     * the first operand fits to the method.
+     */
+    int is_forward;
+    if (Py_TYPE(a) == &Py@Name@ArrType_Type) {
+        is_forward = 1;
+    }
+    else if (Py_TYPE(b) == &Py@Name@ArrType_Type) {
+        is_forward = 0;
+    }
+    else {
+        /* subclasses are involved */
+        is_forward = PyArray_IsScalar(a, @Name@);
+        assert(is_forward || PyArray_IsScalar(b, @Name@));
+    }
 
-    BINOP_GIVE_UP_IF_NEEDED(a, b, nb_@oper@, @name@_@oper@);
+    /*
+     * Extract the other value (if it is compatible).  Otherwise, decide
+     * how to deal with it.  This is somewhat complicated.
+     *
+     * Note: This pattern is used multiple times below.
+     */
+    PyObject *other = is_forward ? b : a;
 
-    switch(_@name@_convert2_to_ctypes(a, &arg1, b, &arg2)) {
-        case 0:
-            break;
-        case -1:
-            /* one of them can't be cast safely must be mixed-types*/
-            return PyArray_Type.tp_as_number->nb_@oper@(a,b);
-        case -2:
-            /* use default handling */
-            if (PyErr_Occurred()) {
-                return NULL;
-            }
-            return PyGenericArrType_Type.tp_as_number->nb_@oper@(a,b);
-        case -3:
+    npy_bool may_need_deferring;
+    conversion_result res = convert_to_@name@(
+            other, &other_val, &may_need_deferring);
+    if (res == CONVERSION_ERROR) {
+        return NULL;  /* an error occurred (should never happen) */
+    }
+    if (may_need_deferring) {
+        BINOP_GIVE_UP_IF_NEEDED(a, b, nb_@oper@, @name@_@oper@);
+    }
+    switch (res) {
+        case DEFER_TO_OTHER_KNOWN_SCALAR:
             /*
-             * special case for longdouble and clongdouble
-             * because they have a recursive getitem in their dtype
+             * defer to other;  This is normally a forward operation.  However,
+             * it could be backward if an operation is undefined forward.
+             * An example is the complex remainder `complex % bool` will defer
+             * even though it would normally handle the operation.
              */
-            Py_INCREF(Py_NotImplemented);
-            return Py_NotImplemented;
+            Py_RETURN_NOTIMPLEMENTED;
+        case CONVERSION_SUCCESS:
+            break;  /* successfully extracted value we can proceed */
+        case OTHER_IS_UNKNOWN_OBJECT:
+            /*
+             * Either an array-like, unknown scalar (any Python object, but
+             * also integers that are too large to convert to `long`), or
+             * even a subclass of a NumPy scalar (currently).
+             *
+             * Generally, we try dropping through to the array path here,
+             * but this can lead to infinite recursions for (c)longdouble.
+             */
+#if defined(IS_longdouble) || defined(IS_clongdouble)
+            Py_RETURN_NOTIMPLEMENTED;
+#endif
+        case PROMOTION_REQUIRED:
+            /*
+             * Python scalar that is larger than the current one, or two
+             * NumPy scalars that promote to a third (uint16 + int16 -> int32).
+             *
+             * TODO: We could special case the promotion case here for much
+             *       better speed and to deal with integer overflow warnings
+             *       correctly.  (e.g. `uint8 * int8` cannot warn).
+             */
+            return PyGenericArrType_Type.tp_as_number->nb_@oper@(a,b);
+        case CONVERT_PYSCALAR:
+            if (@NAME@_setitem(other, (char *)&other_val, NULL) < 0) {
+                return NULL;
+            }
+            break;
+        default:
+            assert(0);  /* error was checked already, impossible to reach */
+            return NULL;
     }
 
 #if @fperr@
-    npy_clear_floatstatus_barrier((char*)&out);
+    npy_clear_floatstatus_barrier((char*)&arg1);
+#endif
+    if (is_forward) {
+        arg1 = PyArrayScalar_VAL(a, @Name@);
+        arg2 = other_val;
+    }
+    else {
+        arg1 = other_val;
+        arg2 = PyArrayScalar_VAL(b, @Name@);
+    }
+
+    /*
+     * Prepare the actual calculation.
+     */
+    @otype@ out;
+#if @twoout@
+    @otype@ out2;
+    PyObject *obj;
 #endif
 
     /*
      * here we do the actual calculation with arg1 and arg2
      * as a function call.
+     * Note that `retstatus` is the "floating point error" value for integer
+     * functions.  Float functions should always return 0, and then use
+     * the following `npy_get_floatstatus_barrier`.
      */
 #if @twoout@
-    @name@_ctype_@oper@(arg1, arg2, (@otype@ *)&out, &out2);
+    int retstatus = @name@_ctype_@oper@(arg1, arg2, &out, &out2);
 #else
-    @name@_ctype_@oper@(arg1, arg2, (@otype@ *)&out);
+    int retstatus = @name@_ctype_@oper@(arg1, arg2, &out);
 #endif
 
 #if @fperr@
     /* Check status flag.  If it is set, then look up what to do */
-    retstatus = npy_get_floatstatus_barrier((char*)&out);
+    retstatus |= npy_get_floatstatus_barrier((char*)&out);
+#endif
     if (retstatus) {
-        int bufsize, errmask;
-        PyObject *errobj;
-
-        if (PyUFunc_GetPyValues("@name@_scalars", &bufsize, &errmask,
-                                &errobj) < 0) {
+        if (PyUFunc_GiveFloatingpointErrors("scalar " OP_NAME, retstatus) < 0) {
             return NULL;
         }
-        first = 1;
-        if (PyUFunc_handlefperr(errmask, errobj, retstatus, &first)) {
-            Py_XDECREF(errobj);
-            return NULL;
-        }
-        Py_XDECREF(errobj);
     }
-#endif
 
 
 #if @twoout@
@@ -899,6 +1381,11 @@ static PyObject *
     return ret;
 }
 
+
+#undef OP_NAME
+#undef IS_@oper@
+#undef IS_@name@
+
 /**end repeat**/
 
 #define _IS_ZERO(x) (x == 0)
@@ -919,17 +1406,10 @@ static PyObject *
  *         Long, ULong, LongLong, ULongLong,
  *         Half, Float, Double, LongDouble,
  *         CFloat, CDouble, CLongDouble#
- *
- * #oname = float*4, double*6, half, float, double, longdouble,
- *          cfloat, cdouble, clongdouble#
- *
- * #otype = npy_float*4, npy_double*6, npy_half, npy_float,
- *          npy_double, npy_longdouble,
- *          npy_cfloat, npy_cdouble, npy_clongdouble#
- *
- * #OName = Float*4, Double*6, Half, Float,
- *          Double, LongDouble,
- *          CFloat, CDouble, CLongDouble#
+ * #NAME = BYTE, UBYTE, SHORT, USHORT, INT, UINT,
+ *         LONG, ULONG, LONGLONG, ULONGLONG,
+ *         HALF, FLOAT, DOUBLE, LONGDOUBLE,
+ *         CFLOAT, CDOUBLE, CLONGDOUBLE#
  *
  * #isint = 1*10,0*7#
  * #isuint = (0,1)*5,0*7#
@@ -938,46 +1418,85 @@ static PyObject *
  * #zero = 0*10, NPY_HALF_ZERO, 0*6#
  * #one = 1*10, NPY_HALF_ONE, 1*6#
  */
+#define IS_@name@
 
 static PyObject *
 @name@_power(PyObject *a, PyObject *b, PyObject *modulo)
 {
+    if (modulo != Py_None) {
+        /* modular exponentiation is not implemented (gh-8804) */
+        Py_INCREF(Py_NotImplemented);
+        return Py_NotImplemented;
+    }
+
     PyObject *ret;
-    @type@ arg1, arg2, out;
+    @type@ arg1, arg2, other_val;
 
-    BINOP_GIVE_UP_IF_NEEDED(a, b, nb_power, @name@_power);
+    int is_forward;
+    if (Py_TYPE(a) == &Py@Name@ArrType_Type) {
+        is_forward = 1;
+    }
+    else if (Py_TYPE(b) == &Py@Name@ArrType_Type) {
+        is_forward = 0;
+    }
+    else {
+        /* subclasses are involved */
+        is_forward = PyArray_IsScalar(a, @Name@);
+        assert(is_forward || PyArray_IsScalar(b, @Name@));
+    }
+    /*
+     * Extract the other value (if it is compatible). See the generic
+     * (non power) version above for detailed notes.
+     */
+    PyObject *other = is_forward ? b : a;
 
-    switch(_@name@_convert2_to_ctypes(a, &arg1, b, &arg2)) {
-        case 0:
-            break;
-        case -1:
-            /* can't cast both safely mixed-types? */
-            return PyArray_Type.tp_as_number->nb_power(a,b,modulo);
-        case -2:
-            /* use default handling */
-            if (PyErr_Occurred()) {
+    npy_bool may_need_deferring;
+    int res = convert_to_@name@(other, &other_val, &may_need_deferring);
+    if (res == CONVERSION_ERROR) {
+        return NULL;  /* an error occurred (should never happen) */
+    }
+    if (may_need_deferring) {
+        BINOP_GIVE_UP_IF_NEEDED(a, b, nb_power, @name@_power);
+    }
+    switch (res) {
+        case DEFER_TO_OTHER_KNOWN_SCALAR:
+            Py_RETURN_NOTIMPLEMENTED;
+        case CONVERSION_SUCCESS:
+            break;  /* successfully extracted value we can proceed */
+        case OTHER_IS_UNKNOWN_OBJECT:
+#if defined(IS_longdouble) || defined(IS_clongdouble)
+            Py_RETURN_NOTIMPLEMENTED;
+#endif
+        case PROMOTION_REQUIRED:
+            return PyGenericArrType_Type.tp_as_number->nb_power(a, b, modulo);
+        case CONVERT_PYSCALAR:
+            if (@NAME@_setitem(other, (char *)&other_val, NULL) < 0) {
                 return NULL;
             }
-            return PyGenericArrType_Type.tp_as_number->nb_power(a,b,modulo);
-        case -3:
+            break;
         default:
-            /*
-             * special case for longdouble and clongdouble
-             * because they have a recursive getitem in their dtype
-             */
-            Py_INCREF(Py_NotImplemented);
-            return Py_NotImplemented;
-    }
-
-    if (modulo != Py_None) {
-        /* modular exponentiation is not implemented (gh-8804) */
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
+            assert(0);  /* error was checked already, impossible to reach */
+            return NULL;
     }
 
 #if !@isint@
-    npy_clear_floatstatus_barrier((char*)&out);
+    npy_clear_floatstatus_barrier((char*)&arg1);
 #endif
+
+    if (is_forward) {
+        arg1 = PyArrayScalar_VAL(a, @Name@);
+        arg2 = other_val;
+    }
+    else {
+        arg1 = other_val;
+        arg2 = PyArrayScalar_VAL(b, @Name@);
+    }
+
+    /*
+     * Prepare the actual calculation:
+     */
+    @type@ out;
+
     /*
      * here we do the actual calculation with arg1 and arg2
      * as a function call.
@@ -989,27 +1508,17 @@ static PyObject *
         return NULL;
     }
 #endif
-    @name@_ctype_power(arg1, arg2, &out);
+    int retstatus = @name@_ctype_power(arg1, arg2, &out);
 
 #if !@isint@
     /* Check status flag.  If it is set, then look up what to do */
-    int retstatus = npy_get_floatstatus_barrier((char*)&out);
+    retstatus |= npy_get_floatstatus_barrier((char*)&out);
+#endif
     if (retstatus) {
-        int bufsize, errmask;
-        PyObject *errobj;
-
-        if (PyUFunc_GetPyValues("@name@_scalars", &bufsize, &errmask,
-                                &errobj) < 0) {
-            return NULL;
-        }
-        int first = 1;
-        if (PyUFunc_handlefperr(errmask, errobj, retstatus, &first)) {
-            Py_XDECREF(errobj);
+        if (PyUFunc_GiveFloatingpointErrors("scalar power", retstatus) < 0) {
             return NULL;
         }
-        Py_XDECREF(errobj);
     }
-#endif
 
     ret = PyArrayScalar_New(@Name@);
     if (ret == NULL) {
@@ -1021,78 +1530,28 @@ static PyObject *
 }
 
 
+#undef IS_@name@
 /**end repeat**/
 #undef _IS_ZERO
 
 
 /**begin repeat
  *
- * #name = cfloat, cdouble#
- *
- */
-
-/**begin repeat1
- *
- * #oper = divmod, remainder#
- *
- */
-
-#define @name@_@oper@ NULL
-
-/**end repeat1**/
-
-/**end repeat**/
-
-/**begin repeat
- *
- * #oper = divmod, remainder#
+ * #name = (cfloat, cdouble, clongdouble)*3#
+ * #oper = floor_divide*3, divmod*3, remainder*3#
  *
  */
 
 /* 
-Complex numbers do not support remainder operations. Unfortunately, 
-the type inference for long doubles is complicated, and if a remainder 
-operation is not defined - if the relevant field is left NULL - then 
-operations between long doubles and objects lead to an infinite recursion 
-instead of a TypeError. This should ensure that once everything gets
-converted to complex long doubles you correctly get a reasonably
-informative TypeError. This fixes the last part of bug gh-18548.
-*/
-
+ * Complex numbers do not support remainder so we manually make sure that the
+ * operation is not defined.  This is/was especially important for longdoubles
+ * due to their tendency to recurse for some operations, see gh-18548.
+ * (We need to define the slots to avoid inheriting it.)
+ */
 static PyObject *
-clongdouble_@oper@(PyObject *a, PyObject *b)
+@name@_@oper@(PyObject *NPY_UNUSED(a), PyObject *NPY_UNUSED(b))
 {
-    npy_clongdouble arg1, arg2;
-
-    BINOP_GIVE_UP_IF_NEEDED(a, b, nb_@oper@, clongdouble_@oper@);
-
-    switch(_clongdouble_convert2_to_ctypes(a, &arg1, b, &arg2)) {
-        case 0:
-            break;
-        case -1:
-            /* one of them can't be cast safely must be mixed-types*/
-            return PyArray_Type.tp_as_number->nb_@oper@(a,b);
-        case -2:
-            /* use default handling */
-            if (PyErr_Occurred()) {
-                return NULL;
-            }
-            return PyGenericArrType_Type.tp_as_number->nb_@oper@(a,b);
-        case -3:
-            /*
-             * special case for longdouble and clongdouble
-             * because they have a recursive getitem in their dtype
-             */
-            Py_INCREF(Py_NotImplemented);
-            return Py_NotImplemented;
-    }
-
-    /*
-     * here we do the actual calculation with arg1 and arg2
-     * as a function call.
-     */
-    PyErr_SetString(PyExc_TypeError, "complex long doubles do not support remainder");
-    return NULL;
+    Py_RETURN_NOTIMPLEMENTED;
 }
 
 /**end repeat**/
@@ -1124,6 +1583,14 @@ clongdouble_@oper@(PyObject *a, PyObject *b)
  *         byte, ubyte, short, ushort, int, uint,
  *         long, ulong, longlong, ulonglong#
  *
+ * #Name = (Byte, UByte, Short, UShort, Int, UInt,
+ *             Long, ULong, LongLong, ULongLong,
+ *             Half, Float, Double, LongDouble,
+ *             CFloat, CDouble, CLongDouble)*3,
+ *
+ *         Byte, UByte, Short, UShort, Int, UInt,
+ *         Long, ULong, LongLong, ULongLong#
+ *
  * #type = (npy_byte, npy_ubyte, npy_short, npy_ushort, npy_int, npy_uint,
  *             npy_long, npy_ulong, npy_longlong, npy_ulonglong,
  *             npy_half, npy_float, npy_double, npy_longdouble,
@@ -1161,32 +1628,24 @@ clongdouble_@oper@(PyObject *a, PyObject *b)
 static PyObject *
 @name@_@oper@(PyObject *a)
 {
-    @type@ arg1;
+    @type@ val;
     @otype@ out;
     PyObject *ret;
 
-    switch(_@name@_convert_to_ctype(a, &arg1)) {
-    case 0:
-        break;
-    case -1:
-        /* can't cast both safely use different add function */
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
-    case -2:
-        /* use default handling */
-        if (PyErr_Occurred()) {
+
+    val = PyArrayScalar_VAL(a, @Name@);
+    int retstatus = @name@_ctype_@oper@(val, &out);
+
+    if (retstatus) {
+        if (PyUFunc_GiveFloatingpointErrors("scalar @oper@", retstatus) < 0) {
             return NULL;
         }
-        return PyGenericArrType_Type.tp_as_number->nb_@oper@(a);
     }
 
     /*
-     * here we do the actual calculation with arg1 and arg2
-     * make it a function call.
+     * TODO: Complex absolute should check floating point flags.
      */
 
-    @name@_ctype_@oper@(arg1, &out);
-
     ret = PyArrayScalar_New(@OName@);
     PyArrayScalar_ASSIGN(ret, @OName@, out);
 
@@ -1210,6 +1669,10 @@ static PyObject *
  *         uint, long, ulong, longlong, ulonglong,
  *         half, float, double, longdouble,
  *         cfloat, cdouble, clongdouble#
+ * #Name = Byte, UByte, Short, UShort, Int, UInt,
+ *         Long, ULong, LongLong, ULongLong,
+ *         Half, Float, Double, LongDouble,
+ *         CFloat, CDouble, CLongDouble#
  * #type = npy_byte, npy_ubyte, npy_short, npy_ushort, npy_int,
  *         npy_uint, npy_long, npy_ulong, npy_longlong, npy_ulonglong,
  *         npy_half, npy_float, npy_double, npy_longdouble,
@@ -1221,24 +1684,14 @@ static int
 @name@_bool(PyObject *a)
 {
     int ret;
-    @type@ arg1;
-
-    if (_@name@_convert_to_ctype(a, &arg1) < 0) {
-        if (PyErr_Occurred()) {
-            return -1;
-        }
-        return PyGenericArrType_Type.tp_as_number->nb_bool(a);
-    }
+    @type@ val;
 
-    /*
-     * here we do the actual calculation with arg1 and arg2
-     * make it a function call.
-     */
+    val = PyArrayScalar_VAL(a, @Name@);
 
 #if @simp@
-    ret = @nonzero@(arg1);
+    ret = @nonzero@(val);
 #else
-    ret = (@nonzero@(arg1.real) || @nonzero@(arg1.imag));
+    ret = (@nonzero@(val.real) || @nonzero@(val.imag));
 #endif
 
     return ret;
@@ -1321,7 +1774,7 @@ static PyObject *
  * #to_ctype = , , , , , , , , , , npy_half_to_double, , , , , , #
  * #func = PyFloat_FromDouble*17#
  */
-static NPY_INLINE PyObject *
+static PyObject *
 @name@_float(PyObject *obj)
 {
 #if @cmplx@
@@ -1335,6 +1788,12 @@ static NPY_INLINE PyObject *
 }
 /**end repeat**/
 
+#if __GNUC__ < 10
+    /* At least GCC 9.2 issues spurious warnings for arg2 below. */
+    #pragma GCC diagnostic push  /* matching pop after function and repeat */
+    #pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#endif
+
 /**begin repeat
  * #oper = le, ge, lt, gt, eq, ne#
  * #op = <=, >=, <, >, ==, !=#
@@ -1353,36 +1812,58 @@ static NPY_INLINE PyObject *
  *         long, ulong, longlong, ulonglong,
  *         half, float, double, longdouble,
  *         cfloat, cdouble, clongdouble#
+ * #Name = Byte, UByte, Short, UShort, Int, UInt,
+ *         Long, ULong, LongLong, ULongLong,
+ *         Half, Float, Double, LongDouble,
+ *         CFloat, CDouble, CLongDouble#
+ * #NAME = BYTE, UBYTE, SHORT, USHORT, INT, UINT,
+ *         LONG, ULONG, LONGLONG, ULONGLONG,
+ *         HALF, FLOAT, DOUBLE, LONGDOUBLE,
+ *         CFLOAT, CDOUBLE, CLONGDOUBLE#
  * #simp = def*10, def_half, def*3, cmplx*3#
  */
+#define IS_@name@
+
 static PyObject*
 @name@_richcompare(PyObject *self, PyObject *other, int cmp_op)
 {
     npy_@name@ arg1, arg2;
-    int out=0;
-
-    RICHCMP_GIVE_UP_IF_NEEDED(self, other);
+    int out = 0;
 
-    switch(_@name@_convert2_to_ctypes(self, &arg1, other, &arg2)) {
-    case 0:
-        break;
-    case -1:
-        /* can't cast both safely use different add function */
-    case -2:
-        /* use ufunc */
-        if (PyErr_Occurred()) {
+    /*
+     * Extract the other value (if it is compatible).
+     */
+    npy_bool may_need_deferring;
+    int res = convert_to_@name@(other, &arg2, &may_need_deferring);
+    if (res == CONVERSION_ERROR) {
+        return NULL;  /* an error occurred (should never happen) */
+    }
+    if (may_need_deferring) {
+        RICHCMP_GIVE_UP_IF_NEEDED(self, other);
+    }
+    switch (res) {
+        case DEFER_TO_OTHER_KNOWN_SCALAR:
+            Py_RETURN_NOTIMPLEMENTED;
+        case CONVERSION_SUCCESS:
+            break;  /* successfully extracted value we can proceed */
+        case OTHER_IS_UNKNOWN_OBJECT:
+#if defined(IS_longdouble) || defined(IS_clongdouble)
+            Py_RETURN_NOTIMPLEMENTED;
+#endif
+        case PROMOTION_REQUIRED:
+            return PyGenericArrType_Type.tp_richcompare(self, other, cmp_op);
+        case CONVERT_PYSCALAR:
+            if (@NAME@_setitem(other, (char *)&arg2, NULL) < 0) {
+                return NULL;
+            }
+            break;
+        default:
+            assert(0);  /* error was checked already, impossible to reach */
             return NULL;
-        }
-        return PyGenericArrType_Type.tp_richcompare(self, other, cmp_op);
-    case -3:
-        /*
-         * special case for longdouble and clongdouble
-         * because they have a recursive getitem in their dtype
-         */
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
     }
 
+    arg1 = PyArrayScalar_VAL(self, @Name@);
+
     /* here we do the actual calculation with arg1 and arg2 */
     switch (cmp_op) {
     case Py_EQ:
@@ -1412,8 +1893,15 @@ static PyObject*
         PyArrayScalar_RETURN_FALSE;
     }
 }
+
+#undef IS_@name@
 /**end repeat**/
 
+#if __GNUC__ < 10
+    #pragma GCC diagnostic pop
+#endif
+
+
 /**begin repeat
  *  #name = byte, ubyte, short, ushort, int, uint,
  *          long, ulong, longlong, ulonglong,
diff --git a/numpy/core/src/umath/simd.inc.src b/numpy/core/src/umath/simd.inc.src
index 0e2c1ab8b31b..d6c9a7e65385 100644
--- a/numpy/core/src/umath/simd.inc.src
+++ b/numpy/core/src/umath/simd.inc.src
@@ -88,38 +88,6 @@ run_unary_avx512f_@func@_@TYPE@(char **args, const npy_intp *dimensions, const n
  *****************************************************************************
  */
 
-/**begin repeat
- * #type = npy_float, npy_double, npy_longdouble#
- * #TYPE = FLOAT, DOUBLE, LONGDOUBLE#
- * #EXISTS = 1, 1, 0#
- */
-
-/**begin repeat1
- *  #func = maximum, minimum#
- */
-
-#if defined HAVE_ATTRIBUTE_TARGET_AVX512F_WITH_INTRINSICS && defined NPY_HAVE_SSE2_INTRINSICS && @EXISTS@
-static NPY_INLINE NPY_GCC_TARGET_AVX512F void
-AVX512F_@func@_@TYPE@(char **args, npy_intp const *dimensions, npy_intp const *steps);
-#endif
-
-static NPY_INLINE int
-run_binary_avx512f_@func@_@TYPE@(char **args, npy_intp const *dimensions, npy_intp const *steps)
-{
-#if defined HAVE_ATTRIBUTE_TARGET_AVX512F_WITH_INTRINSICS && defined NPY_HAVE_SSE2_INTRINSICS && @EXISTS@
-    if (IS_BINARY_SMALL_STEPS_AND_NOMEMOVERLAP) {
-        AVX512F_@func@_@TYPE@(args, dimensions, steps);
-        return 1;
-    }
-    else
-        return 0;
-#endif
-    return 0;
-}
-/**end repeat1**/
-
-/**end repeat**/
-
 /**begin repeat
  * #type = npy_float, npy_double, npy_longdouble#
  * #TYPE = FLOAT, DOUBLE, LONGDOUBLE#
@@ -154,47 +122,6 @@ run_@func@_avx512_skx_@TYPE@(char **args, npy_intp const *dimensions, npy_intp c
 /**end repeat1**/
 /**end repeat**/
 
-/**begin repeat
- * #ISA = FMA, AVX512F#
- * #isa = fma, avx512f#
- * #CHK = HAVE_ATTRIBUTE_TARGET_AVX2_WITH_INTRINSICS, HAVE_ATTRIBUTE_TARGET_AVX512F_WITH_INTRINSICS#
- * #REGISTER_SIZE = 32, 64#
- */
-
-/* prototypes */
-
-/**begin repeat1
- * #type = npy_float, npy_double#
- * #TYPE = FLOAT, DOUBLE#
- */
-
-/**begin repeat2
- *  #func = rint, floor, trunc#
- */
-
-#if defined @CHK@ && defined NPY_HAVE_SSE2_INTRINSICS
-static NPY_INLINE NPY_GCC_TARGET_@ISA@ void
-@ISA@_@func@_@TYPE@(@type@ *, @type@ *, const npy_intp n, const npy_intp stride);
-#endif
-
-static NPY_INLINE int
-run_unary_@isa@_@func@_@TYPE@(char **args, npy_intp const *dimensions, npy_intp const *steps)
-{
-#if defined @CHK@ && defined NPY_HAVE_SSE2_INTRINSICS
-    if (IS_OUTPUT_BLOCKABLE_UNARY(sizeof(@type@), sizeof(@type@), @REGISTER_SIZE@)) {
-        @ISA@_@func@_@TYPE@((@type@*)args[1], (@type@*)args[0], dimensions[0], steps[0]);
-        return 1;
-    }
-    else
-        return 0;
-#endif
-    return 0;
-}
-
-/**end repeat2**/
-/**end repeat1**/
-/**end repeat**/
-
 /**begin repeat
  * Float types
  *  #type = npy_float, npy_double, npy_longdouble#
@@ -204,9 +131,9 @@ run_unary_@isa@_@func@_@TYPE@(char **args, npy_intp const *dimensions, npy_intp
  */
 
 /**begin repeat1
- * #func = negative, minimum, maximum#
- * #check = IS_BLOCKABLE_UNARY, IS_BLOCKABLE_REDUCE*2 #
- * #name = unary, unary_reduce*2#
+ * #func = negative#
+ * #check = IS_BLOCKABLE_UNARY#
+ * #name = unary#
  */
 
 #if @vector@ && defined NPY_HAVE_SSE2_INTRINSICS
@@ -231,55 +158,6 @@ run_@name@_simd_@func@_@TYPE@(char **args, npy_intp const *dimensions, npy_intp
 
 /**end repeat1**/
 
-/**begin repeat1
- * #kind = equal, not_equal, less, less_equal, greater, greater_equal,
- *         logical_and, logical_or#
- * #simd = 1, 1, 1, 1, 1, 1, 0, 0#
- */
-
-#if @vector@ && @simd@ && defined NPY_HAVE_SSE2_INTRINSICS
-
-/* prototypes */
-static void
-sse2_binary_@kind@_@TYPE@(npy_bool * op, @type@ * ip1, @type@ * ip2,
-                          npy_intp n);
-static void
-sse2_binary_scalar1_@kind@_@TYPE@(npy_bool * op, @type@ * ip1, @type@ * ip2,
-                                  npy_intp n);
-static void
-sse2_binary_scalar2_@kind@_@TYPE@(npy_bool * op, @type@ * ip1, @type@ * ip2,
-                                  npy_intp n);
-
-#endif
-
-static NPY_INLINE int
-run_binary_simd_@kind@_@TYPE@(char **args, npy_intp const *dimensions, npy_intp const *steps)
-{
-#if @vector@ && @simd@ && defined NPY_HAVE_SSE2_INTRINSICS
-    @type@ * ip1 = (@type@ *)args[0];
-    @type@ * ip2 = (@type@ *)args[1];
-    npy_bool * op = (npy_bool *)args[2];
-    npy_intp n = dimensions[0];
-    /* argument one scalar */
-    if (IS_BLOCKABLE_BINARY_SCALAR1_BOOL(sizeof(@type@), VECTOR_SIZE_BYTES)) {
-        sse2_binary_scalar1_@kind@_@TYPE@(op, ip1, ip2, n);
-        return 1;
-    }
-    /* argument two scalar */
-    else if (IS_BLOCKABLE_BINARY_SCALAR2_BOOL(sizeof(@type@), VECTOR_SIZE_BYTES)) {
-        sse2_binary_scalar2_@kind@_@TYPE@(op, ip1, ip2, n);
-        return 1;
-    }
-    else if (IS_BLOCKABLE_BINARY_BOOL(sizeof(@type@), VECTOR_SIZE_BYTES)) {
-        sse2_binary_@kind@_@TYPE@(op, ip1, ip2, n);
-        return 1;
-    }
-#endif
-    return 0;
-}
-
-/**end repeat1**/
-
 /**begin repeat1
  * #kind = isnan, isfinite, isinf, signbit#
  */
@@ -549,101 +427,6 @@ sse2_@kind@_@TYPE@(npy_bool * op, @type@ * ip1, npy_intp n)
 
 /**end repeat1**/
 
-/**begin repeat1
- * #kind = equal, not_equal, less, less_equal, greater, greater_equal#
- * #OP = ==, !=, <, <=, >, >=#
- * #VOP = cmpeq, cmpneq, cmplt, cmple, cmpgt, cmpge#
-*/
-
-/* sets invalid fpu flag on QNaN for consistency with packed compare */
-NPY_FINLINE int
-sse2_ordered_cmp_@kind@_@TYPE@(const @type@ a, const @type@ b)
-{
-    @vtype@ one = @vpre@_set1_@vsuf@(1);
-    @type@ tmp;
-    @vtype@ v = @vpre@_@VOP@_@vsufs@(@vpre@_load_@vsufs@(&a),
-                                     @vpre@_load_@vsufs@(&b));
-    v = @vpre@_and_@vsuf@(v, one);
-    @vpre@_store_@vsufs@(&tmp, v);
-    return tmp;
-}
-
-static void
-sse2_binary_@kind@_@TYPE@(npy_bool * op, @type@ * ip1, @type@ * ip2, npy_intp n)
-{
-    LOOP_BLOCK_ALIGN_VAR(ip1, @type@, VECTOR_SIZE_BYTES) {
-        op[i] = sse2_ordered_cmp_@kind@_@TYPE@(ip1[i], ip2[i]);
-    }
-    LOOP_BLOCKED(@type@, 4 * VECTOR_SIZE_BYTES) {
-        @vtype@ a1 = @vpre@_load_@vsuf@(&ip1[i + 0 * VECTOR_SIZE_BYTES / sizeof(@type@)]);
-        @vtype@ b1 = @vpre@_load_@vsuf@(&ip1[i + 1 * VECTOR_SIZE_BYTES / sizeof(@type@)]);
-        @vtype@ c1 = @vpre@_load_@vsuf@(&ip1[i + 2 * VECTOR_SIZE_BYTES / sizeof(@type@)]);
-        @vtype@ d1 = @vpre@_load_@vsuf@(&ip1[i + 3 * VECTOR_SIZE_BYTES / sizeof(@type@)]);
-        @vtype@ a2 = @vpre@_loadu_@vsuf@(&ip2[i + 0 * VECTOR_SIZE_BYTES / sizeof(@type@)]);
-        @vtype@ b2 = @vpre@_loadu_@vsuf@(&ip2[i + 1 * VECTOR_SIZE_BYTES / sizeof(@type@)]);
-        @vtype@ c2 = @vpre@_loadu_@vsuf@(&ip2[i + 2 * VECTOR_SIZE_BYTES / sizeof(@type@)]);
-        @vtype@ d2 = @vpre@_loadu_@vsuf@(&ip2[i + 3 * VECTOR_SIZE_BYTES / sizeof(@type@)]);
-        @vtype@ r1 = @vpre@_@VOP@_@vsuf@(a1, a2);
-        @vtype@ r2 = @vpre@_@VOP@_@vsuf@(b1, b2);
-        @vtype@ r3 = @vpre@_@VOP@_@vsuf@(c1, c2);
-        @vtype@ r4 = @vpre@_@VOP@_@vsuf@(d1, d2);
-        sse2_compress4_to_byte_@TYPE@(r1, r2, r3, &r4, &op[i]);
-    }
-    LOOP_BLOCKED_END {
-        op[i] = sse2_ordered_cmp_@kind@_@TYPE@(ip1[i], ip2[i]);
-    }
-}
-
-
-static void
-sse2_binary_scalar1_@kind@_@TYPE@(npy_bool * op, @type@ * ip1, @type@ * ip2, npy_intp n)
-{
-    @vtype@ s = @vpre@_set1_@vsuf@(ip1[0]);
-    LOOP_BLOCK_ALIGN_VAR(ip2, @type@, VECTOR_SIZE_BYTES) {
-        op[i] = sse2_ordered_cmp_@kind@_@TYPE@(ip1[0], ip2[i]);
-    }
-    LOOP_BLOCKED(@type@, 4 * VECTOR_SIZE_BYTES) {
-        @vtype@ a = @vpre@_load_@vsuf@(&ip2[i + 0 * VECTOR_SIZE_BYTES / sizeof(@type@)]);
-        @vtype@ b = @vpre@_load_@vsuf@(&ip2[i + 1 * VECTOR_SIZE_BYTES / sizeof(@type@)]);
-        @vtype@ c = @vpre@_load_@vsuf@(&ip2[i + 2 * VECTOR_SIZE_BYTES / sizeof(@type@)]);
-        @vtype@ d = @vpre@_load_@vsuf@(&ip2[i + 3 * VECTOR_SIZE_BYTES / sizeof(@type@)]);
-        @vtype@ r1 = @vpre@_@VOP@_@vsuf@(s, a);
-        @vtype@ r2 = @vpre@_@VOP@_@vsuf@(s, b);
-        @vtype@ r3 = @vpre@_@VOP@_@vsuf@(s, c);
-        @vtype@ r4 = @vpre@_@VOP@_@vsuf@(s, d);
-        sse2_compress4_to_byte_@TYPE@(r1, r2, r3, &r4, &op[i]);
-    }
-    LOOP_BLOCKED_END {
-        op[i] = sse2_ordered_cmp_@kind@_@TYPE@(ip1[0], ip2[i]);
-    }
-}
-
-
-static void
-sse2_binary_scalar2_@kind@_@TYPE@(npy_bool * op, @type@ * ip1, @type@ * ip2, npy_intp n)
-{
-    @vtype@ s = @vpre@_set1_@vsuf@(ip2[0]);
-    LOOP_BLOCK_ALIGN_VAR(ip1, @type@, VECTOR_SIZE_BYTES) {
-        op[i] = sse2_ordered_cmp_@kind@_@TYPE@(ip1[i], ip2[0]);
-    }
-    LOOP_BLOCKED(@type@, 4 * VECTOR_SIZE_BYTES) {
-        @vtype@ a = @vpre@_load_@vsuf@(&ip1[i + 0 * VECTOR_SIZE_BYTES / sizeof(@type@)]);
-        @vtype@ b = @vpre@_load_@vsuf@(&ip1[i + 1 * VECTOR_SIZE_BYTES / sizeof(@type@)]);
-        @vtype@ c = @vpre@_load_@vsuf@(&ip1[i + 2 * VECTOR_SIZE_BYTES / sizeof(@type@)]);
-        @vtype@ d = @vpre@_load_@vsuf@(&ip1[i + 3 * VECTOR_SIZE_BYTES / sizeof(@type@)]);
-        @vtype@ r1 = @vpre@_@VOP@_@vsuf@(a, s);
-        @vtype@ r2 = @vpre@_@VOP@_@vsuf@(b, s);
-        @vtype@ r3 = @vpre@_@VOP@_@vsuf@(c, s);
-        @vtype@ r4 = @vpre@_@VOP@_@vsuf@(d, s);
-        sse2_compress4_to_byte_@TYPE@(r1, r2, r3, &r4, &op[i]);
-    }
-    LOOP_BLOCKED_END {
-        op[i] = sse2_ordered_cmp_@kind@_@TYPE@(ip1[i], ip2[0]);
-    }
-}
-/**end repeat1**/
-
-
 static void
 sse2_negative_@TYPE@(@type@ * op, @type@ * ip, const npy_intp n)
 {
@@ -678,55 +461,6 @@ sse2_negative_@TYPE@(@type@ * op, @type@ * ip, const npy_intp n)
 }
 /**end repeat1**/
 
-
-/**begin repeat1
- * #kind = maximum, minimum#
- * #VOP = max, min#
- * #OP = >=, <=#
- **/
-/* arguments swapped as unary reduce has the swapped compared to unary */
-static void
-sse2_@kind@_@TYPE@(@type@ * ip, @type@ * op, const npy_intp n)
-{
-    const npy_intp stride = VECTOR_SIZE_BYTES / (npy_intp)sizeof(@type@);
-    LOOP_BLOCK_ALIGN_VAR(ip, @type@, VECTOR_SIZE_BYTES) {
-        /* Order of operations important for MSVC 2015 */
-        *op = (*op @OP@ ip[i] || npy_isnan(*op)) ? *op : ip[i];
-    }
-    assert(n < stride || npy_is_aligned(&ip[i], VECTOR_SIZE_BYTES));
-    if (i + 3 * stride <= n) {
-        /* load the first elements */
-        @vtype@ c1 = @vpre@_load_@vsuf@((@type@*)&ip[i]);
-        @vtype@ c2 = @vpre@_load_@vsuf@((@type@*)&ip[i + stride]);
-        i += 2 * stride;
-
-        /* minps/minpd will set invalid flag if nan is encountered */
-        npy_clear_floatstatus_barrier((char*)&c1);
-        LOOP_BLOCKED(@type@, 2 * VECTOR_SIZE_BYTES) {
-            @vtype@ v1 = @vpre@_load_@vsuf@((@type@*)&ip[i]);
-            @vtype@ v2 = @vpre@_load_@vsuf@((@type@*)&ip[i + stride]);
-            c1 = @vpre@_@VOP@_@vsuf@(c1, v1);
-            c2 = @vpre@_@VOP@_@vsuf@(c2, v2);
-        }
-        c1 = @vpre@_@VOP@_@vsuf@(c1, c2);
-
-        if (npy_get_floatstatus_barrier((char*)&c1) & NPY_FPE_INVALID) {
-            *op = @nan@;
-        }
-        else {
-            @type@ tmp = sse2_horizontal_@VOP@_@vtype@(c1);
-            /* Order of operations important for MSVC 2015 */
-            *op  = (*op @OP@ tmp || npy_isnan(*op)) ? *op : tmp;
-        }
-    }
-    LOOP_BLOCKED_END {
-        /* Order of operations important for MSVC 2015 */
-        *op  = (*op @OP@ ip[i] || npy_isnan(*op)) ? *op : ip[i];
-    }
-    npy_clear_floatstatus_barrier((char*)op);
-}
-/**end repeat1**/
-
 /**end repeat**/
 
 /* bunch of helper functions used in ISA_exp/log_FLOAT*/
@@ -1199,245 +933,6 @@ AVX512_SKX_@func@_@TYPE@(npy_bool* op, @type@* ip, const npy_intp array_size, co
 /**end repeat1**/
 /**end repeat**/
 
-/**begin repeat
- * #type = npy_float, npy_double#
- * #TYPE = FLOAT, DOUBLE#
- * #num_lanes = 16, 8#
- * #vsuffix = ps, pd#
- * #mask = __mmask16, __mmask8#
- * #vtype1 = __m512, __m512d#
- * #vtype2 = __m512i, __m256i#
- * #scale = 4, 8#
- * #vindextype = __m512i, __m256i#
- * #vindexsize = 512, 256#
- * #vindexload = _mm512_loadu_si512, _mm256_loadu_si256#
- * #vtype2_load = _mm512_maskz_loadu_epi32, _mm256_maskz_loadu_epi32#
- * #vtype2_gather = _mm512_mask_i32gather_epi32, _mm256_mmask_i32gather_epi32#
- * #vtype2_store = _mm512_mask_storeu_epi32, _mm256_mask_storeu_epi32#
- * #vtype2_scatter = _mm512_mask_i32scatter_epi32, _mm256_mask_i32scatter_epi32#
- * #setzero = _mm512_setzero_epi32, _mm256_setzero_si256#
- */
-/**begin repeat1
- *  #func = maximum, minimum#
- *  #vectorf = max, min#
- */
-
-#if defined HAVE_ATTRIBUTE_TARGET_AVX512F_WITH_INTRINSICS && defined NPY_HAVE_SSE2_INTRINSICS
-static NPY_INLINE NPY_GCC_TARGET_AVX512F void
-AVX512F_@func@_@TYPE@(char **args, npy_intp const *dimensions, npy_intp const *steps)
-{
-    const npy_intp stride_ip1 = steps[0]/(npy_intp)sizeof(@type@);
-    const npy_intp stride_ip2 = steps[1]/(npy_intp)sizeof(@type@);
-    const npy_intp stride_op = steps[2]/(npy_intp)sizeof(@type@);
-    const npy_intp array_size = dimensions[0];
-    npy_intp num_remaining_elements = array_size;
-    @type@* ip1 = (@type@*) args[0];
-    @type@* ip2 = (@type@*) args[1];
-    @type@* op  = (@type@*) args[2];
-
-    @mask@ load_mask = avx512_get_full_load_mask_@vsuffix@();
-
-    /*
-     * Note: while generally indices are npy_intp, we ensure that our maximum index
-     * will fit in an int32 as a precondition for this function via
-     * IS_BINARY_SMALL_STEPS_AND_NOMEMOVERLAP
-     */
-
-    npy_int32 index_ip1[@num_lanes@], index_ip2[@num_lanes@], index_op[@num_lanes@];
-    for (npy_int32 ii = 0; ii < @num_lanes@; ii++) {
-        index_ip1[ii] = ii*stride_ip1;
-        index_ip2[ii] = ii*stride_ip2;
-        index_op[ii] = ii*stride_op;
-    }
-    @vindextype@ vindex_ip1 = @vindexload@((@vindextype@*)&index_ip1[0]);
-    @vindextype@ vindex_ip2 = @vindexload@((@vindextype@*)&index_ip2[0]);
-    @vindextype@ vindex_op  = @vindexload@((@vindextype@*)&index_op[0]);
-    @vtype1@ zeros_f = _mm512_setzero_@vsuffix@();
-
-    while (num_remaining_elements > 0) {
-        if (num_remaining_elements < @num_lanes@) {
-            load_mask = avx512_get_partial_load_mask_@vsuffix@(
-                                    num_remaining_elements, @num_lanes@);
-        }
-        @vtype1@ x1, x2;
-        if (stride_ip1 == 1) {
-            x1 = avx512_masked_load_@vsuffix@(load_mask, ip1);
-        }
-        else {
-            x1 = avx512_masked_gather_@vsuffix@(zeros_f, ip1, vindex_ip1, load_mask);
-        }
-        if (stride_ip2 == 1) {
-            x2 = avx512_masked_load_@vsuffix@(load_mask, ip2);
-        }
-        else {
-            x2 = avx512_masked_gather_@vsuffix@(zeros_f, ip2, vindex_ip2, load_mask);
-        }
-
-        /*
-         * when only one of the argument is a nan, the maxps/maxpd instruction
-         * returns the second argument. The additional blend instruction fixes
-         * this issue to conform with NumPy behaviour.
-         */
-        @mask@ nan_mask = _mm512_cmp_@vsuffix@_mask(x1, x1, _CMP_NEQ_UQ);
-        @vtype1@ out = _mm512_@vectorf@_@vsuffix@(x1, x2);
-        out = _mm512_mask_blend_@vsuffix@(nan_mask, out, x1);
-
-        if (stride_op == 1) {
-            _mm512_mask_storeu_@vsuffix@(op, load_mask, out);
-        }
-        else {
-            /* scatter! */
-            _mm512_mask_i32scatter_@vsuffix@(op, load_mask, vindex_op, out, @scale@);
-        }
-
-        ip1 += @num_lanes@*stride_ip1;
-        ip2 += @num_lanes@*stride_ip2;
-        op += @num_lanes@*stride_op;
-        num_remaining_elements -= @num_lanes@;
-    }
-}
-#endif
-/**end repeat1**/
-/**end repeat**/
-
-/**begin repeat
- * #ISA = FMA, AVX512F#
- * #isa = fma, avx512#
- * #vsize = 256, 512#
- * #BYTES = 32, 64#
- * #cvtps_epi32 = _mm256_cvtps_epi32, #
- * #mask = __m256, __mmask16#
- * #vsub = , _mask#
- * #vtype = __m256, __m512#
- * #cvtps_epi32 = _mm256_cvtps_epi32, #
- * #masked_store = _mm256_maskstore_ps, _mm512_mask_storeu_ps#
- * #CHK = HAVE_ATTRIBUTE_TARGET_AVX2_WITH_INTRINSICS, HAVE_ATTRIBUTE_TARGET_AVX512F_WITH_INTRINSICS#
- */
-
-/**begin repeat1
- *  #func = rint, floor, trunc#
- *  #vectorf = rint, floor, trunc#
- */
-
-#if defined @CHK@
-static NPY_INLINE NPY_GCC_OPT_3 NPY_GCC_TARGET_@ISA@ void
-@ISA@_@func@_FLOAT(npy_float* op,
-                   npy_float* ip,
-                   const npy_intp array_size,
-                   const npy_intp steps)
-{
-    const npy_intp stride = steps/(npy_intp)sizeof(npy_float);
-    const npy_int num_lanes = @BYTES@/(npy_intp)sizeof(npy_float);
-    npy_intp num_remaining_elements = array_size;
-    @vtype@ ones_f = _mm@vsize@_set1_ps(1.0f);
-    @mask@ load_mask = @isa@_get_full_load_mask_ps();
-    /*
-     * Note: while generally indices are npy_intp, we ensure that our maximum index
-     * will fit in an int32 as a precondition for this function via
-     * IS_OUTPUT_BLOCKABLE_UNARY
-     */
-
-    npy_int32 indexarr[16];
-    for (npy_int32 ii = 0; ii < 16; ii++) {
-        indexarr[ii] = ii*stride;
-    }
-    @vtype@i vindex = _mm@vsize@_loadu_si@vsize@((@vtype@i*)&indexarr[0]);
-
-    while (num_remaining_elements > 0) {
-        if (num_remaining_elements < num_lanes) {
-            load_mask = @isa@_get_partial_load_mask_ps(num_remaining_elements,
-                                                       num_lanes);
-        }
-        @vtype@ x;
-        if (stride == 1) {
-            x = @isa@_masked_load_ps(load_mask, ip);
-        }
-        else {
-            x = @isa@_masked_gather_ps(ones_f, ip, vindex, load_mask);
-        }
-        @vtype@ out = @isa@_@vectorf@_ps(x);
-        @masked_store@(op, @cvtps_epi32@(load_mask), out);
-
-        ip += num_lanes*stride;
-        op += num_lanes;
-        num_remaining_elements -= num_lanes;
-    }
-}
-#endif
-/**end repeat1**/
-/**end repeat**/
-
-/**begin repeat
- * #ISA = FMA, AVX512F#
- * #isa = fma, avx512#
- * #vsize = 256, 512#
- * #BYTES = 32, 64#
- * #cvtps_epi32 = _mm256_cvtps_epi32, #
- * #mask = __m256i, __mmask8#
- * #vsub = , _mask#
- * #vtype = __m256d, __m512d#
- * #vindextype = __m128i, __m256i#
- * #vindexsize = 128, 256#
- * #vindexload = _mm_loadu_si128, _mm256_loadu_si256#
- * #cvtps_epi32 = _mm256_cvtpd_epi32, #
- * #castmask = _mm256_castsi256_pd, #
- * #masked_store = _mm256_maskstore_pd, _mm512_mask_storeu_pd#
- * #CHK = HAVE_ATTRIBUTE_TARGET_AVX2_WITH_INTRINSICS, HAVE_ATTRIBUTE_TARGET_AVX512F_WITH_INTRINSICS#
- */
-
-/**begin repeat1
- *  #func = rint, floor, trunc#
- *  #vectorf =  rint, floor, trunc#
- */
-
-#if defined @CHK@
-static NPY_INLINE NPY_GCC_OPT_3 NPY_GCC_TARGET_@ISA@ void
-@ISA@_@func@_DOUBLE(npy_double* op,
-                    npy_double* ip,
-                    const npy_intp array_size,
-                    const npy_intp steps)
-{
-    const npy_intp stride = steps/(npy_intp)sizeof(npy_double);
-    const npy_int num_lanes = @BYTES@/(npy_intp)sizeof(npy_double);
-    npy_intp num_remaining_elements = array_size;
-    @mask@ load_mask = @isa@_get_full_load_mask_pd();
-    @vtype@ ones_d = _mm@vsize@_set1_pd(1.0f);
-
-    /*
-     * Note: while generally indices are npy_intp, we ensure that our maximum index
-     * will fit in an int32 as a precondition for this function via
-     * IS_OUTPUT_BLOCKABLE_UNARY
-     */
-    npy_int32 indexarr[8];
-    for (npy_int32 ii = 0; ii < 8; ii++) {
-        indexarr[ii] = ii*stride;
-    }
-    @vindextype@ vindex = @vindexload@((@vindextype@*)&indexarr[0]);
-
-    while (num_remaining_elements > 0) {
-        if (num_remaining_elements < num_lanes) {
-            load_mask = @isa@_get_partial_load_mask_pd(num_remaining_elements,
-                                                       num_lanes);
-        }
-        @vtype@ x;
-        if (stride == 1) {
-            x = @isa@_masked_load_pd(load_mask, ip);
-        }
-        else {
-            x = @isa@_masked_gather_pd(ones_d, ip, vindex, @castmask@(load_mask));
-        }
-        @vtype@ out = @isa@_@vectorf@_pd(x);
-        @masked_store@(op, load_mask, out);
-
-        ip += num_lanes*stride;
-        op += num_lanes;
-        num_remaining_elements -= num_lanes;
-    }
-}
-#endif
-/**end repeat1**/
-/**end repeat**/
-
 /**begin repeat
  * #TYPE = CFLOAT, CDOUBLE#
  * #type = npy_float, npy_double#
@@ -1717,3 +1212,4 @@ sse2_@kind@_BOOL(@type@ * op, @type@ * ip, const npy_intp n)
 #undef VECTOR_SIZE_BYTES
 #endif  /* NPY_HAVE_SSE2_INTRINSICS */
 #endif
+
diff --git a/numpy/core/src/umath/string_ufuncs.cpp b/numpy/core/src/umath/string_ufuncs.cpp
new file mode 100644
index 000000000000..5a35c318b5dc
--- /dev/null
+++ b/numpy/core/src/umath/string_ufuncs.cpp
@@ -0,0 +1,449 @@
+#include 
+
+#define NPY_NO_DEPRECATED_API NPY_API_VERSION
+#define _MULTIARRAYMODULE
+#define _UMATHMODULE
+
+#include "numpy/ndarraytypes.h"
+
+#include "numpyos.h"
+#include "dispatching.h"
+#include "dtypemeta.h"
+#include "common_dtype.h"
+#include "convert_datatype.h"
+
+#include "string_ufuncs.h"
+
+
+template 
+static NPY_INLINE int
+character_cmp(character a, character b)
+{
+    if (a == b) {
+        return 0;
+    }
+    else if (a < b) {
+        return -1;
+    }
+    else {
+        return 1;
+    }
+}
+
+
+/*
+ * Compare two strings of different length.  Note that either string may be
+ * zero padded (trailing zeros are ignored in other words, the shorter word
+ * is always padded with zeros).
+ */
+template 
+static NPY_INLINE int
+string_cmp(int len1, const character *str1, int len2, const character *str2)
+{
+    if (rstrip) {
+        /*
+         * Ignore/"trim" trailing whitespace (and 0s).  Note that this function
+         * does not support unicode whitespace (and never has).
+         */
+        while (len1 > 0) {
+            character c = str1[len1-1];
+            if (c != (character)0 && !NumPyOS_ascii_isspace(c)) {
+                break;
+            }
+            len1--;
+        }
+        while (len2 > 0) {
+            character c = str2[len2-1];
+            if (c != (character)0 && !NumPyOS_ascii_isspace(c)) {
+                break;
+            }
+            len2--;
+        }
+    }
+
+    int n = PyArray_MIN(len1, len2);
+
+    if (sizeof(character) == 1) {
+        /*
+         * TODO: `memcmp` makes things 2x faster for longer words that match
+         *       exactly, but at least 2x slower for short or mismatching ones.
+         */
+        int cmp = memcmp(str1, str2, n);
+        if (cmp != 0) {
+            return cmp;
+        }
+        str1 += n;
+        str2 += n;
+    }
+    else {
+        for (int i = 0; i < n; i++) {
+            int cmp = character_cmp(*str1, *str2);
+            if (cmp != 0) {
+                return cmp;
+            }
+            str1++;
+            str2++;
+        }
+    }
+    if (len1 > len2) {
+        for (int i = n; i < len1; i++) {
+            int cmp = character_cmp(*str1, (character)0);
+            if (cmp != 0) {
+                return cmp;
+            }
+            str1++;
+        }
+    }
+    else if (len2 > len1) {
+        for (int i = n; i < len2; i++) {
+            int cmp = character_cmp((character)0, *str2);
+            if (cmp != 0) {
+                return cmp;
+            }
+            str2++;
+        }
+    }
+    return 0;
+}
+
+
+/*
+ * Helper for templating, avoids warnings about uncovered switch paths.
+ */
+enum class COMP {
+    EQ, NE, LT, LE, GT, GE,
+};
+
+static char const *
+comp_name(COMP comp) {
+    switch(comp) {
+        case COMP::EQ: return "equal";
+        case COMP::NE: return "not_equal";
+        case COMP::LT: return "less";
+        case COMP::LE: return "less_equal";
+        case COMP::GT: return "greater";
+        case COMP::GE: return "greater_equal";
+        default:
+            assert(0);
+            return nullptr;
+    }
+}
+
+
+template 
+static int
+string_comparison_loop(PyArrayMethod_Context *context,
+        char *const data[], npy_intp const dimensions[],
+        npy_intp const strides[], NpyAuxData *NPY_UNUSED(auxdata))
+{
+    /*
+     * Note, fetching `elsize` from the descriptor is OK even without the GIL,
+     * however it may be that this should be moved into `auxdata` eventually,
+     * which may also be slightly faster/cleaner (but more involved).
+     */
+    int len1 = context->descriptors[0]->elsize / sizeof(character);
+    int len2 = context->descriptors[1]->elsize / sizeof(character);
+
+    char *in1 = data[0];
+    char *in2 = data[1];
+    char *out = data[2];
+
+    npy_intp N = dimensions[0];
+
+    while (N--) {
+        int cmp = string_cmp(
+                len1, (character *)in1, len2, (character *)in2);
+        npy_bool res;
+        switch (comp) {
+            case COMP::EQ:
+                res = cmp == 0;
+                break;
+            case COMP::NE:
+                res = cmp != 0;
+                break;
+            case COMP::LT:
+                res = cmp < 0;
+                break;
+            case COMP::LE:
+                res = cmp <= 0;
+                break;
+            case COMP::GT:
+                res = cmp > 0;
+                break;
+            case COMP::GE:
+                res = cmp >= 0;
+                break;
+        }
+        *(npy_bool *)out = res;
+
+        in1 += strides[0];
+        in2 += strides[1];
+        out += strides[2];
+    }
+    return 0;
+}
+
+
+/*
+ * Machinery to add the string loops to the existing ufuncs.
+ */
+
+/*
+ * This function replaces the strided loop with the passed in one,
+ * and registers it with the given ufunc.
+ */
+static int
+add_loop(PyObject *umath, const char *ufunc_name,
+         PyArrayMethod_Spec *spec, PyArrayMethod_StridedLoop *loop)
+{
+    PyObject *name = PyUnicode_FromString(ufunc_name);
+    if (name == nullptr) {
+        return -1;
+    }
+    PyObject *ufunc = PyObject_GetItem(umath, name);
+    Py_DECREF(name);
+    if (ufunc == nullptr) {
+        return -1;
+    }
+    spec->slots[0].pfunc = (void *)loop;
+
+    int res = PyUFunc_AddLoopFromSpec(ufunc, spec);
+    Py_DECREF(ufunc);
+    return res;
+}
+
+
+template
+struct add_loops;
+
+template
+struct add_loops {
+    int operator()(PyObject*, PyArrayMethod_Spec*) {
+        return 0;
+    }
+};
+
+template
+struct add_loops {
+    int operator()(PyObject* umath, PyArrayMethod_Spec* spec) {
+        PyArrayMethod_StridedLoop* loop = string_comparison_loop;
+
+        if (add_loop(umath, comp_name(comp), spec, loop) < 0) {
+            return -1;
+        }
+        else {
+            return add_loops()(umath, spec);
+        }
+    }
+};
+
+
+NPY_NO_EXPORT int
+init_string_ufuncs(PyObject *umath)
+{
+    int res = -1;
+    /* NOTE: This should receive global symbols? */
+    PyArray_DTypeMeta *String = PyArray_DTypeFromTypeNum(NPY_STRING);
+    PyArray_DTypeMeta *Unicode = PyArray_DTypeFromTypeNum(NPY_UNICODE);
+    PyArray_DTypeMeta *Bool = PyArray_DTypeFromTypeNum(NPY_BOOL);
+
+    /* We start with the string loops: */
+    PyArray_DTypeMeta *dtypes[] = {String, String, Bool};
+    /*
+     * We only have one loop right now, the strided one.  The default type
+     * resolver ensures native byte order/canonical representation.
+     */
+    PyType_Slot slots[] = {
+        {NPY_METH_strided_loop, nullptr},
+        {0, nullptr}
+    };
+
+    PyArrayMethod_Spec spec = {};
+    spec.name = "templated_string_comparison";
+    spec.nin = 2;
+    spec.nout = 1;
+    spec.dtypes = dtypes;
+    spec.slots = slots;
+    spec.flags = NPY_METH_NO_FLOATINGPOINT_ERRORS;
+
+    /* All String loops */
+    using string_looper = add_loops;
+    if (string_looper()(umath, &spec) < 0) {
+        goto finish;
+    }
+
+    /* All Unicode loops */
+    using ucs_looper = add_loops;
+    dtypes[0] = Unicode;
+    dtypes[1] = Unicode;
+    if (ucs_looper()(umath, &spec) < 0) {
+        goto finish;
+    }
+
+    res = 0;
+  finish:
+    Py_DECREF(String);
+    Py_DECREF(Unicode);
+    Py_DECREF(Bool);
+    return res;
+}
+
+
+template 
+static PyArrayMethod_StridedLoop *
+get_strided_loop(int comp)
+{
+    switch (comp) {
+        case Py_EQ:
+            return string_comparison_loop;
+        case Py_NE:
+            return string_comparison_loop;
+        case Py_LT:
+            return string_comparison_loop;
+        case Py_LE:
+            return string_comparison_loop;
+        case Py_GT:
+            return string_comparison_loop;
+        case Py_GE:
+            return string_comparison_loop;
+        default:
+            assert(false);  /* caller ensures this */
+    }
+    return nullptr;
+}
+
+
+/*
+ * This function is used for `compare_chararrays` and currently also void
+ * comparisons (unstructured voids).  The first could probably be deprecated
+ * and removed but is used by `np.char.chararray` the latter should also be
+ * moved to the ufunc probably (removing the need for manual looping).
+ *
+ * The `rstrip` mechanism is presumably for some fortran compat, but the
+ * question is whether it would not be better to have/use `rstrip` on such
+ * an array first...
+ *
+ * NOTE: This function is also used for unstructured voids, this works because
+ *       `npy_byte` is correct.
+ */
+NPY_NO_EXPORT PyObject *
+_umath_strings_richcompare(
+        PyArrayObject *self, PyArrayObject *other, int cmp_op, int rstrip)
+{
+    NpyIter *iter = nullptr;
+    PyObject *result = nullptr;
+
+    char **dataptr = nullptr;
+    npy_intp *strides = nullptr;
+    npy_intp *countptr = nullptr;
+    npy_intp size = 0;
+
+    PyArrayMethod_Context context = {};
+    NpyIter_IterNextFunc *iternext = nullptr;
+
+    npy_uint32 it_flags = (
+            NPY_ITER_EXTERNAL_LOOP | NPY_ITER_ZEROSIZE_OK |
+            NPY_ITER_BUFFERED | NPY_ITER_GROWINNER);
+    npy_uint32 op_flags[3] = {
+            NPY_ITER_READONLY | NPY_ITER_ALIGNED,
+            NPY_ITER_READONLY | NPY_ITER_ALIGNED,
+            NPY_ITER_WRITEONLY | NPY_ITER_ALLOCATE | NPY_ITER_ALIGNED};
+
+    PyArrayMethod_StridedLoop *strided_loop = nullptr;
+    NPY_BEGIN_THREADS_DEF;
+
+    if (PyArray_TYPE(self) != PyArray_TYPE(other)) {
+        /*
+         * Comparison between Bytes and Unicode is not defined in Py3K;
+         * we follow.
+         * TODO: This makes no sense at all for `compare_chararrays`, kept
+         *       only under the assumption that we are more likely to deprecate
+         *       than fix it to begin with.
+         */
+        Py_INCREF(Py_NotImplemented);
+        return Py_NotImplemented;
+    }
+
+    PyArrayObject *ops[3] = {self, other, nullptr};
+    PyArray_Descr *descrs[3] = {nullptr, nullptr, PyArray_DescrFromType(NPY_BOOL)};
+    /* TODO: ensuring native byte order is not really necessary for == and != */
+    descrs[0] = NPY_DT_CALL_ensure_canonical(PyArray_DESCR(self));
+    if (descrs[0] == nullptr) {
+        goto finish;
+    }
+    descrs[1] = NPY_DT_CALL_ensure_canonical(PyArray_DESCR(other));
+    if (descrs[1] == nullptr) {
+        goto finish;
+    }
+
+    /*
+     * Create the iterator:
+     */
+    iter = NpyIter_AdvancedNew(
+            3, ops, it_flags, NPY_KEEPORDER, NPY_SAFE_CASTING, op_flags, descrs,
+            -1, nullptr, nullptr, 0);
+    if (iter == nullptr) {
+        goto finish;
+    }
+
+    size = NpyIter_GetIterSize(iter);
+    if (size == 0) {
+        result = (PyObject *)NpyIter_GetOperandArray(iter)[2];
+        Py_INCREF(result);
+        goto finish;
+    }
+
+    iternext = NpyIter_GetIterNext(iter, nullptr);
+    if (iternext == nullptr) {
+        goto finish;
+    }
+
+    /*
+     * Prepare the inner-loop and execute it (we only need descriptors to be
+     * passed in).
+     */
+    context.descriptors = descrs;
+
+    dataptr = NpyIter_GetDataPtrArray(iter);
+    strides = NpyIter_GetInnerStrideArray(iter);
+    countptr = NpyIter_GetInnerLoopSizePtr(iter);
+
+    if (rstrip == 0) {
+        /* NOTE: Also used for VOID, so can be STRING, UNICODE, or VOID: */
+        if (descrs[0]->type_num != NPY_UNICODE) {
+            strided_loop = get_strided_loop(cmp_op);
+        }
+        else {
+            strided_loop = get_strided_loop(cmp_op);
+        }
+    }
+    else {
+        if (descrs[0]->type_num != NPY_UNICODE) {
+            strided_loop = get_strided_loop(cmp_op);
+        }
+        else {
+            strided_loop = get_strided_loop(cmp_op);
+        }
+    }
+
+    NPY_BEGIN_THREADS_THRESHOLDED(size);
+
+    do {
+         /* We know the loop cannot fail */
+         strided_loop(&context, dataptr, countptr, strides, nullptr);
+    } while (iternext(iter) != 0);
+
+    NPY_END_THREADS;
+
+    result = (PyObject *)NpyIter_GetOperandArray(iter)[2];
+    Py_INCREF(result);
+
+ finish:
+    if (NpyIter_Deallocate(iter) < 0) {
+        Py_CLEAR(result);
+    }
+    Py_XDECREF(descrs[0]);
+    Py_XDECREF(descrs[1]);
+    Py_XDECREF(descrs[2]);
+    return result;
+}
diff --git a/numpy/core/src/umath/string_ufuncs.h b/numpy/core/src/umath/string_ufuncs.h
new file mode 100644
index 000000000000..aa17199541e7
--- /dev/null
+++ b/numpy/core/src/umath/string_ufuncs.h
@@ -0,0 +1,19 @@
+#ifndef _NPY_CORE_SRC_UMATH_STRING_UFUNCS_H_
+#define _NPY_CORE_SRC_UMATH_STRING_UFUNCS_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+NPY_NO_EXPORT int
+init_string_ufuncs(PyObject *umath);
+
+NPY_NO_EXPORT PyObject *
+_umath_strings_richcompare(
+        PyArrayObject *self, PyArrayObject *other, int cmp_op, int rstrip);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  /* _NPY_CORE_SRC_UMATH_STRING_UFUNCS_H_ */
\ No newline at end of file
diff --git a/numpy/core/src/umath/ufunc_object.c b/numpy/core/src/umath/ufunc_object.c
index 186f18a620bb..3c977cb1cf1d 100644
--- a/numpy/core/src/umath/ufunc_object.c
+++ b/numpy/core/src/umath/ufunc_object.c
@@ -49,7 +49,10 @@
 #include "override.h"
 #include "npy_import.h"
 #include "extobj.h"
+
+#include "arrayobject.h"
 #include "common.h"
+#include "ctors.h"
 #include "dtypemeta.h"
 #include "numpyos.h"
 #include "dispatching.h"
@@ -57,6 +60,10 @@
 #include "legacy_array_method.h"
 #include "abstractdtypes.h"
 
+/* TODO: Only for `NpyIter_GetTransferFlags` until it is public */
+#define NPY_ITERATOR_IMPLEMENTATION_CODE
+#include "nditer_impl.h"
+
 /********** PRINTF DEBUG TRACING **************/
 #define NPY_UF_DBG_TRACING 0
 
@@ -941,6 +948,7 @@ convert_ufunc_arguments(PyUFuncObject *ufunc,
         ufunc_full_args full_args, PyArrayObject *out_op[],
         PyArray_DTypeMeta *out_op_DTypes[],
         npy_bool *force_legacy_promotion, npy_bool *allow_legacy_promotion,
+        npy_bool *promoting_pyscalars,
         PyObject *order_obj, NPY_ORDER *out_order,
         PyObject *casting_obj, NPY_CASTING *out_casting,
         PyObject *subok_obj, npy_bool *out_subok,
@@ -957,6 +965,7 @@ convert_ufunc_arguments(PyUFuncObject *ufunc,
     npy_bool any_scalar = NPY_FALSE;
     *allow_legacy_promotion = NPY_TRUE;
     *force_legacy_promotion = NPY_FALSE;
+    *promoting_pyscalars = NPY_FALSE;
     for (int i = 0; i < nin; i++) {
         obj = PyTuple_GET_ITEM(full_args.in, i);
 
@@ -976,6 +985,8 @@ convert_ufunc_arguments(PyUFuncObject *ufunc,
 
         if (!NPY_DT_is_legacy(out_op_DTypes[i])) {
             *allow_legacy_promotion = NPY_FALSE;
+            // TODO: A subclass of int, float, complex could reach here and
+            //       it should not be flagged as "weak" if it does.
         }
         if (PyArray_NDIM(out_op[i]) == 0) {
             any_scalar = NPY_TRUE;
@@ -984,24 +995,27 @@ convert_ufunc_arguments(PyUFuncObject *ufunc,
             all_scalar = NPY_FALSE;
             continue;
         }
+
+        // TODO: Is this equivalent/better by removing the logic which enforces
+        //       that we always use weak promotion in the core?
+        if (npy_promotion_state == NPY_USE_LEGACY_PROMOTION) {
+            continue;  /* Skip use of special dtypes */
+        }
+
         /*
-         * TODO: we need to special case scalars here, if the input is a
-         *       Python int, float, or complex, we have to use the "weak"
-         *       DTypes: `PyArray_PyIntAbstractDType`, etc.
-         *       This is to allow e.g. `float32(1.) + 1` to return `float32`.
-         *       The correct array dtype can only be found after promotion for
-         *       such a "weak scalar".  We could avoid conversion here, but
-         *       must convert it for use in the legacy promotion.
-         *       There is still a small chance that this logic can instead
-         *       happen inside the Python operators.
+         * Handle the "weak" Python scalars/literals.  We use a special DType
+         * for these.
+         * Further, we mark the operation array with a special flag to indicate
+         * this.  This is because the legacy dtype resolution makes use of
+         * `np.can_cast(operand, dtype)`.  The flag is local to this use, but
+         * necessary to propagate the information to the legacy type resolution.
          */
+        if (npy_mark_tmp_array_if_pyscalar(obj, out_op[i], &out_op_DTypes[i])) {
+            *promoting_pyscalars = NPY_TRUE;
+        }
     }
     if (*allow_legacy_promotion && (!all_scalar && any_scalar)) {
         *force_legacy_promotion = should_use_min_scalar(nin, out_op, 0, NULL);
-        /*
-         * TODO: if this is False, we end up in a "very slow" path that should
-         *       be avoided.  This makes `int_arr + 0.` ~40% slower.
-         */
     }
 
     /* Convert and fill in output arguments */
@@ -1077,13 +1091,15 @@ check_for_trivial_loop(PyArrayMethodObject *ufuncimpl,
         int must_copy = !PyArray_ISALIGNED(op[i]);
 
         if (dtypes[i] != PyArray_DESCR(op[i])) {
-            NPY_CASTING safety = PyArray_GetCastSafety(
-                    PyArray_DESCR(op[i]), dtypes[i], NULL);
+            npy_intp view_offset;
+            NPY_CASTING safety = PyArray_GetCastInfo(
+                    PyArray_DESCR(op[i]), dtypes[i], NULL, &view_offset);
             if (safety < 0 && PyErr_Occurred()) {
                 /* A proper error during a cast check, should be rare */
                 return -1;
             }
-            if (!(safety & _NPY_CAST_IS_VIEW)) {
+            if (view_offset != 0) {
+                /* NOTE: Could possibly implement non-zero view offsets */
                 must_copy = 1;
             }
 
@@ -1208,6 +1224,7 @@ prepare_ufunc_output(PyUFuncObject *ufunc,
  * cannot broadcast any other array (as it requires a single stride).
  * The function accepts all 1-D arrays, and N-D arrays that are either all
  * C- or all F-contiguous.
+ * NOTE: Broadcast outputs are implicitly rejected in the overlap detection.
  *
  * Returns -2 if a trivial loop is not possible, 0 on success and -1 on error.
  */
@@ -1244,7 +1261,7 @@ try_trivial_single_output_loop(PyArrayMethod_Context *context,
         int op_ndim = PyArray_NDIM(op[iop]);
 
         /* Special case 0-D since we can handle broadcasting using a 0-stride */
-        if (op_ndim == 0) {
+        if (op_ndim == 0 && iop < nin) {
             fixed_strides[iop] = 0;
             continue;
         }
@@ -1255,7 +1272,7 @@ try_trivial_single_output_loop(PyArrayMethod_Context *context,
             operation_shape = PyArray_SHAPE(op[iop]);
         }
         else if (op_ndim != operation_ndim) {
-            return -2;  /* dimension mismatch (except 0-d ops) */
+            return -2;  /* dimension mismatch (except 0-d input ops) */
         }
         else if (!PyArray_CompareLists(
                 operation_shape, PyArray_DIMS(op[iop]), op_ndim)) {
@@ -1323,6 +1340,10 @@ try_trivial_single_output_loop(PyArrayMethod_Context *context,
      */
     char *data[NPY_MAXARGS];
     npy_intp count = PyArray_MultiplyList(operation_shape, operation_ndim);
+    if (count == 0) {
+        /* Nothing to do */
+        return 0;
+    }
     NPY_BEGIN_THREADS_DEF;
 
     PyArrayMethod_StridedLoop *strided_loop;
@@ -1541,10 +1562,6 @@ execute_ufunc_loop(PyArrayMethod_Context *context, int masked,
     if (masked) {
         baseptrs[nop] = PyArray_BYTES(op_it[nop]);
     }
-    if (NpyIter_ResetBasePointers(iter, baseptrs, NULL) != NPY_SUCCEED) {
-        NpyIter_Deallocate(iter);
-        return -1;
-    }
 
     /*
      * Get the inner loop, with the possibility of specialization
@@ -1581,17 +1598,25 @@ execute_ufunc_loop(PyArrayMethod_Context *context, int masked,
     char **dataptr = NpyIter_GetDataPtrArray(iter);
     npy_intp *strides = NpyIter_GetInnerStrideArray(iter);
     npy_intp *countptr = NpyIter_GetInnerLoopSizePtr(iter);
-    int needs_api = NpyIter_IterationNeedsAPI(iter);
 
     NPY_BEGIN_THREADS_DEF;
 
+    flags = PyArrayMethod_COMBINED_FLAGS(flags, NpyIter_GetTransferFlags(iter));
+
     if (!(flags & NPY_METH_NO_FLOATINGPOINT_ERRORS)) {
         npy_clear_floatstatus_barrier((char *)context);
     }
-    if (!needs_api && !(flags & NPY_METH_REQUIRES_PYAPI)) {
+    if (!(flags & NPY_METH_REQUIRES_PYAPI)) {
         NPY_BEGIN_THREADS_THRESHOLDED(full_size);
     }
 
+    /* The reset may copy the first buffer chunk, which could cause FPEs */
+    if (NpyIter_ResetBasePointers(iter, baseptrs, NULL) != NPY_SUCCEED) {
+        NPY_AUXDATA_FREE(auxdata);
+        NpyIter_Deallocate(iter);
+        return -1;
+    }
+
     NPY_UF_DBG_PRINT("Actual inner loop:\n");
     /* Execute the loop */
     int res;
@@ -2385,7 +2410,8 @@ PyUFunc_GeneralizedFunctionInternal(PyUFuncObject *ufunc,
                  NPY_ITER_MULTI_INDEX |
                  NPY_ITER_REFS_OK |
                  NPY_ITER_ZEROSIZE_OK |
-                 NPY_ITER_COPY_IF_OVERLAP;
+                 NPY_ITER_COPY_IF_OVERLAP |
+                 NPY_ITER_DELAY_BUFALLOC;
 
     /* Create the iterator */
     iter = NpyIter_AdvancedNew(nop, op, iter_flags,
@@ -2706,7 +2732,7 @@ PyUFunc_GenericFunction(PyUFuncObject *NPY_UNUSED(ufunc),
  * @param out_descrs New references to the resolved descriptors (on success).
  * @param method The ufunc method, "reduce", "reduceat", or "accumulate".
 
- * @returns ufuncimpl The `ArrayMethod` implemention to use. Or NULL if an
+ * @returns ufuncimpl The `ArrayMethod` implementation to use. Or NULL if an
  *          error occurred.
  */
 static PyArrayMethodObject *
@@ -2714,14 +2740,62 @@ reducelike_promote_and_resolve(PyUFuncObject *ufunc,
         PyArrayObject *arr, PyArrayObject *out,
         PyArray_DTypeMeta *signature[3],
         npy_bool enforce_uniform_args, PyArray_Descr *out_descrs[3],
-        char *method)
+        NPY_CASTING casting, char *method)
 {
+     /*
+      * If no dtype is specified and out is not specified, we override the
+      * integer and bool dtype used for add and multiply.
+      *
+      * TODO: The following should be handled by a promoter!
+      */
+    if (signature[0] == NULL && out == NULL) {
+        /*
+         * For integer types --- make sure at least a long
+         * is used for add and multiply reduction to avoid overflow
+         */
+        int typenum = PyArray_TYPE(arr);
+        if ((PyTypeNum_ISBOOL(typenum) || PyTypeNum_ISINTEGER(typenum))
+                && ((strcmp(ufunc->name, "add") == 0)
+                    || (strcmp(ufunc->name, "multiply") == 0))) {
+            if (PyTypeNum_ISBOOL(typenum)) {
+                typenum = NPY_LONG;
+            }
+            else if ((size_t)PyArray_DESCR(arr)->elsize < sizeof(long)) {
+                if (PyTypeNum_ISUNSIGNED(typenum)) {
+                    typenum = NPY_ULONG;
+                }
+                else {
+                    typenum = NPY_LONG;
+                }
+            }
+            signature[0] = PyArray_DTypeFromTypeNum(typenum);
+        }
+    }
+    assert(signature[2] == NULL);  /* we always fill it here */
+    Py_XINCREF(signature[0]);
+    signature[2] = signature[0];
+
     /*
-     * Note that the `ops` is not realy correct.  But legacy resolution
+     * Note that the `ops` is not really correct.  But legacy resolution
      * cannot quite handle the correct ops (e.g. a NULL first item if `out`
-     * is NULL), and it should only matter in very strange cases.
+     * is NULL) so we pass `arr` instead in that case.
      */
-    PyArrayObject *ops[3] = {arr, arr, NULL};
+    PyArrayObject *ops[3] = {out ? out : arr, arr, out};
+
+    /*
+     * TODO: This is a dangerous hack, that works by relying on the GIL, it is
+     *       terrible, terrifying, and trusts that nobody does crazy stuff
+     *       in their type-resolvers.
+     *       By mutating the `out` dimension, we ensure that reduce-likes
+     *       live in a future without value-based promotion even when legacy
+     *       promotion has to be used.
+     */
+    npy_bool evil_ndim_mutating_hack = NPY_FALSE;
+    if (out != NULL && PyArray_NDIM(out) == 0 && PyArray_NDIM(arr) != 0) {
+        evil_ndim_mutating_hack = NPY_TRUE;
+        ((PyArrayObject_fields *)out)->nd = 1;
+    }
+
     /*
      * TODO: If `out` is not provided, arguably `initial` could define
      *       the first DType (and maybe also the out one), that way
@@ -2741,12 +2815,15 @@ reducelike_promote_and_resolve(PyUFuncObject *ufunc,
     }
 
     PyArrayMethodObject *ufuncimpl = promote_and_get_ufuncimpl(ufunc,
-            ops, signature, operation_DTypes, NPY_FALSE, NPY_TRUE);
-    Py_DECREF(operation_DTypes[1]);
-    if (out != NULL) {
-        Py_DECREF(operation_DTypes[0]);
-        Py_DECREF(operation_DTypes[2]);
-    }
+            ops, signature, operation_DTypes, NPY_FALSE, NPY_TRUE,
+            NPY_FALSE, NPY_TRUE);
+    if (evil_ndim_mutating_hack) {
+        ((PyArrayObject_fields *)out)->nd = 0;
+    }
+    /* DTypes may currently get filled in fallbacks and XDECREF for error: */
+    Py_XDECREF(operation_DTypes[0]);
+    Py_XDECREF(operation_DTypes[1]);
+    Py_XDECREF(operation_DTypes[2]);
     if (ufuncimpl == NULL) {
         return NULL;
     }
@@ -2759,7 +2836,7 @@ reducelike_promote_and_resolve(PyUFuncObject *ufunc,
      * (although this should possibly happen through a deprecation)
      */
     if (resolve_descriptors(3, ufunc, ufuncimpl,
-            ops, out_descrs, signature, NPY_UNSAFE_CASTING) < 0) {
+            ops, out_descrs, signature, casting) < 0) {
         return NULL;
     }
 
@@ -2767,17 +2844,22 @@ reducelike_promote_and_resolve(PyUFuncObject *ufunc,
      * The first operand and output should be the same array, so they should
      * be identical.  The second argument can be different for reductions,
      * but is checked to be identical for accumulate and reduceat.
+     * Ideally, the type-resolver ensures that all are identical, but we do
+     * not enforce this here strictly.  Otherwise correct handling of
+     * byte-order changes (or metadata) requires a lot of care; see gh-20699.
      */
-    if (out_descrs[0] != out_descrs[2] || (
-            enforce_uniform_args && out_descrs[0] != out_descrs[1])) {
+    if (!PyArray_EquivTypes(out_descrs[0], out_descrs[2]) || (
+            enforce_uniform_args && !PyArray_EquivTypes(
+                    out_descrs[0], out_descrs[1]))) {
         PyErr_Format(PyExc_TypeError,
-                "the resolved dtypes are not compatible with %s.%s",
-                ufunc_get_name_cstr(ufunc), method);
+                "the resolved dtypes are not compatible with %s.%s. "
+                "Resolved (%R, %R, %R)",
+                ufunc_get_name_cstr(ufunc), method,
+                out_descrs[0], out_descrs[1], out_descrs[2]);
         goto fail;
     }
     /* TODO: This really should _not_ be unsafe casting (same above)! */
-    if (validate_casting(ufuncimpl,
-            ufunc, ops, out_descrs, NPY_UNSAFE_CASTING) < 0) {
+    if (validate_casting(ufuncimpl, ufunc, ops, out_descrs, casting) < 0) {
         goto fail;
     }
 
@@ -2785,7 +2867,7 @@ reducelike_promote_and_resolve(PyUFuncObject *ufunc,
 
   fail:
     for (int i = 0; i < 3; ++i) {
-        Py_DECREF(out_descrs[i]);
+        Py_CLEAR(out_descrs[i]);
     }
     return NULL;
 }
@@ -2798,7 +2880,7 @@ reduce_loop(PyArrayMethod_Context *context,
         npy_intp const *countptr, NpyIter_IterNextFunc *iternext,
         int needs_api, npy_intp skip_first_count)
 {
-    int retval;
+    int retval = 0;
     char *dataptrs_copy[4];
     npy_intp strides_copy[4];
     npy_bool masked;
@@ -2828,19 +2910,20 @@ reduce_loop(PyArrayMethod_Context *context,
                     count = 0;
                 }
             }
-
-            /* Turn the two items into three for the inner loop */
-            dataptrs_copy[0] = dataptrs[0];
-            dataptrs_copy[1] = dataptrs[1];
-            dataptrs_copy[2] = dataptrs[0];
-            strides_copy[0] = strides[0];
-            strides_copy[1] = strides[1];
-            strides_copy[2] = strides[0];
-
-            retval = strided_loop(context,
-                    dataptrs_copy, &count, strides_copy, auxdata);
-            if (retval < 0) {
-                goto finish_loop;
+            if (count > 0) {
+                /* Turn the two items into three for the inner loop */
+                dataptrs_copy[0] = dataptrs[0];
+                dataptrs_copy[1] = dataptrs[1];
+                dataptrs_copy[2] = dataptrs[0];
+                strides_copy[0] = strides[0];
+                strides_copy[1] = strides[1];
+                strides_copy[2] = strides[0];
+
+                retval = strided_loop(context,
+                        dataptrs_copy, &count, strides_copy, auxdata);
+                if (retval < 0) {
+                    goto finish_loop;
+                }
             }
 
             /* Advance loop, and abort on error (or finish) */
@@ -2908,6 +2991,7 @@ PyUFunc_Reduce(PyUFuncObject *ufunc,
     int iaxes, ndim;
     npy_bool reorderable;
     npy_bool axis_flags[NPY_MAXDIMS];
+    PyArrayObject *result = NULL;
     PyObject *identity;
     const char *ufunc_name = ufunc_get_name_cstr(ufunc);
     /* These parameters come from a TLS global */
@@ -2933,11 +3017,21 @@ PyUFunc_Reduce(PyUFuncObject *ufunc,
         return NULL;
     }
 
+    /*
+     * Promote and fetch ufuncimpl (currently needed to fix up the identity).
+     */
+    PyArray_Descr *descrs[3];
+    PyArrayMethodObject *ufuncimpl = reducelike_promote_and_resolve(ufunc,
+            arr, out, signature, NPY_FALSE, descrs, NPY_UNSAFE_CASTING, "reduce");
+    if (ufuncimpl == NULL) {
+        return NULL;
+    }
+
     /* Get the identity */
     /* TODO: Both of these should be provided by the ArrayMethod! */
     identity = _get_identity(ufunc, &reorderable);
     if (identity == NULL) {
-        return NULL;
+        goto finish;
     }
 
     /* Get the initial value */
@@ -2953,33 +3047,42 @@ PyUFunc_Reduce(PyUFuncObject *ufunc,
             initial = Py_None;
             Py_INCREF(initial);
         }
+        else if (PyTypeNum_ISUNSIGNED(descrs[2]->type_num)
+                    && PyLong_CheckExact(initial)) {
+            /*
+             * This is a bit of a hack until we have truly loop specific
+             * identities.  Python -1 cannot be cast to unsigned so convert
+             * it to a NumPy scalar, but we use -1 for bitwise functions to
+             * signal all 1s.
+             * (A builtin identity would not overflow here, although we may
+             * unnecessary convert 0 and 1.)
+             */
+            Py_SETREF(initial, PyObject_CallFunctionObjArgs(
+                        (PyObject *)&PyLongArrType_Type, initial, NULL));
+            if (initial == NULL) {
+                goto finish;
+            }
+        }
     } else {
         Py_DECREF(identity);
         Py_INCREF(initial);  /* match the reference count in the if above */
     }
 
-    PyArray_Descr *descrs[3];
-    PyArrayMethodObject *ufuncimpl = reducelike_promote_and_resolve(ufunc,
-            arr, out, signature, NPY_FALSE, descrs, "reduce");
-    if (ufuncimpl == NULL) {
-        Py_DECREF(initial);
-        return NULL;
-    }
-
     PyArrayMethod_Context context = {
         .caller = (PyObject *)ufunc,
         .method = ufuncimpl,
         .descriptors = descrs,
     };
 
-    PyArrayObject *result = PyUFunc_ReduceWrapper(&context,
+    result = PyUFunc_ReduceWrapper(&context,
             arr, out, wheremask, axis_flags, reorderable, keepdims,
             initial, reduce_loop, ufunc, buffersize, ufunc_name, errormask);
 
+  finish:
     for (int i = 0; i < 3; i++) {
         Py_DECREF(descrs[i]);
     }
-    Py_DECREF(initial);
+    Py_XDECREF(initial);
     return result;
 }
 
@@ -3024,13 +3127,18 @@ PyUFunc_Accumulate(PyUFuncObject *ufunc, PyArrayObject *arr, PyArrayObject *out,
 
     PyArray_Descr *descrs[3];
     PyArrayMethodObject *ufuncimpl = reducelike_promote_and_resolve(ufunc,
-            arr, out, signature, NPY_TRUE, descrs, "accumulate");
+            arr, out, signature, NPY_TRUE, descrs, NPY_UNSAFE_CASTING,
+            "accumulate");
     if (ufuncimpl == NULL) {
         return NULL;
     }
 
-    /* The below code assumes that all descriptors are identical: */
-    assert(descrs[0] == descrs[1] && descrs[0] == descrs[2]);
+    /*
+     * The below code assumes that all descriptors are interchangeable, we
+     * allow them to not be strictly identical (but they typically should be)
+     */
+    assert(PyArray_EquivTypes(descrs[0], descrs[1])
+           && PyArray_EquivTypes(descrs[0], descrs[2]));
 
     if (PyDataType_REFCHK(descrs[2]) && descrs[2]->type_num != NPY_OBJECT) {
         /* This can be removed, but the initial element copy needs fixing */
@@ -3437,13 +3545,18 @@ PyUFunc_Reduceat(PyUFuncObject *ufunc, PyArrayObject *arr, PyArrayObject *ind,
 
     PyArray_Descr *descrs[3];
     PyArrayMethodObject *ufuncimpl = reducelike_promote_and_resolve(ufunc,
-            arr, out, signature, NPY_TRUE, descrs, "reduceat");
+            arr, out, signature, NPY_TRUE, descrs, NPY_UNSAFE_CASTING,
+            "reduceat");
     if (ufuncimpl == NULL) {
         return NULL;
     }
 
-    /* The below code assumes that all descriptors are identical: */
-    assert(descrs[0] == descrs[1] && descrs[0] == descrs[2]);
+    /*
+     * The below code assumes that all descriptors are interchangeable, we
+     * allow them to not be strictly identical (but they typically should be)
+     */
+    assert(PyArray_EquivTypes(descrs[0], descrs[1])
+           && PyArray_EquivTypes(descrs[0], descrs[2]));
 
     if (PyDataType_REFCHK(descrs[2]) && descrs[2]->type_num != NPY_OBJECT) {
         /* This can be removed, but the initial element copy needs fixing */
@@ -4091,38 +4204,6 @@ PyUFunc_GenericReduction(PyUFuncObject *ufunc,
         }
     }
 
-     /*
-      * If no dtype is specified and out is not specified, we override the
-      * integer and bool dtype used for add and multiply.
-      *
-      * TODO: The following should be handled by a promoter!
-      */
-    if (signature[0] == NULL && out == NULL) {
-        /*
-         * For integer types --- make sure at least a long
-         * is used for add and multiply reduction to avoid overflow
-         */
-        int typenum = PyArray_TYPE(mp);
-        if ((PyTypeNum_ISBOOL(typenum) || PyTypeNum_ISINTEGER(typenum))
-                && ((strcmp(ufunc->name, "add") == 0)
-                    || (strcmp(ufunc->name, "multiply") == 0))) {
-            if (PyTypeNum_ISBOOL(typenum)) {
-                typenum = NPY_LONG;
-            }
-            else if ((size_t)PyArray_DESCR(mp)->elsize < sizeof(long)) {
-                if (PyTypeNum_ISUNSIGNED(typenum)) {
-                    typenum = NPY_ULONG;
-                }
-                else {
-                    typenum = NPY_LONG;
-                }
-            }
-            signature[0] = PyArray_DTypeFromTypeNum(typenum);
-        }
-    }
-    Py_XINCREF(signature[0]);
-    signature[2] = signature[0];
-
     switch(operation) {
     case UFUNC_REDUCE:
         ret = PyUFunc_Reduce(ufunc,
@@ -4283,23 +4364,16 @@ _get_dtype(PyObject *dtype_obj) {
         }
         else if (NPY_UNLIKELY(out->singleton != descr)) {
             /* This does not warn about `metadata`, but units is important. */
-            if (!PyArray_EquivTypes(out->singleton, descr)) {
-                /* Deprecated NumPy 1.21.2 (was an accidental error in 1.21) */
-                if (DEPRECATE(
+            if (out->singleton == NULL
+                    || !PyArray_EquivTypes(out->singleton, descr)) {
+                PyErr_SetString(PyExc_TypeError,
                         "The `dtype` and `signature` arguments to "
                         "ufuncs only select the general DType and not details "
-                        "such as the byte order or time unit (with rare "
-                        "exceptions see release notes).  To avoid this warning "
-                        "please use the scalar types `np.float64`, or string "
-                        "notation.\n"
-                        "In rare cases where the time unit was preserved, "
-                        "either cast the inputs or provide an output array. "
-                        "In the future NumPy may transition to allow providing "
-                        "`dtype=` to denote the outputs `dtype` as well. "
-                        "(Deprecated NumPy 1.21)") < 0) {
-                    Py_DECREF(descr);
-                    return NULL;
-                }
+                        "such as the byte order or time unit. "
+                        "You can avoid this error by using the scalar types "
+                        "`np.float64` or the dtype string notation.");
+                Py_DECREF(descr);
+                return NULL;
             }
         }
         Py_INCREF(out);
@@ -4511,8 +4585,10 @@ resolve_descriptors(int nop,
 
     if (ufuncimpl->resolve_descriptors != &wrapped_legacy_resolve_descriptors) {
         /* The default: use the `ufuncimpl` as nature intended it */
+        npy_intp view_offset = NPY_MIN_INTP;  /* currently ignored */
+
         NPY_CASTING safety = ufuncimpl->resolve_descriptors(ufuncimpl,
-                signature, original_dtypes, dtypes);
+                signature, original_dtypes, dtypes, &view_offset);
         if (safety < 0) {
             goto finish;
         }
@@ -4829,10 +4905,13 @@ ufunc_generic_fastcall(PyUFuncObject *ufunc,
     int keepdims = -1;  /* We need to know if it was passed */
     npy_bool force_legacy_promotion;
     npy_bool allow_legacy_promotion;
+    npy_bool promoting_pyscalars;
     if (convert_ufunc_arguments(ufunc,
             /* extract operand related information: */
             full_args, operands,
-            operand_DTypes, &force_legacy_promotion, &allow_legacy_promotion,
+            operand_DTypes,
+            &force_legacy_promotion, &allow_legacy_promotion,
+            &promoting_pyscalars,
             /* extract general information: */
             order_obj, &order,
             casting_obj, &casting,
@@ -4852,7 +4931,8 @@ ufunc_generic_fastcall(PyUFuncObject *ufunc,
      */
     PyArrayMethodObject *ufuncimpl = promote_and_get_ufuncimpl(ufunc,
             operands, signature,
-            operand_DTypes, force_legacy_promotion, allow_legacy_promotion);
+            operand_DTypes, force_legacy_promotion, allow_legacy_promotion,
+            promoting_pyscalars, NPY_FALSE);
     if (ufuncimpl == NULL) {
         goto fail;
     }
@@ -4863,6 +4943,41 @@ ufunc_generic_fastcall(PyUFuncObject *ufunc,
         goto fail;
     }
 
+    if (promoting_pyscalars) {
+        /*
+         * Python integers need to be cast specially.  For other python
+         * scalars it does not hurt either.  It would be nice to never create
+         * the array in this case, but that is difficult until value-based
+         * promotion rules are gone.  (After that, we may get away with using
+         * dummy arrays rather than real arrays for the legacy resolvers.)
+         */
+        for (int i = 0; i < nin; i++) {
+            int orig_flags = PyArray_FLAGS(operands[i]);
+            if (!(orig_flags & NPY_ARRAY_WAS_PYTHON_LITERAL)) {
+                continue;
+            }
+            /* If the descriptor matches, no need to worry about conversion */
+            if (PyArray_EquivTypes(
+                    PyArray_DESCR(operands[i]), operation_descrs[i])) {
+                continue;
+            }
+            /* Otherwise, replace the operand with a new array */
+            PyArray_Descr *descr = operation_descrs[i];
+            Py_INCREF(descr);
+            PyArrayObject *new = (PyArrayObject *)PyArray_NewFromDescr(
+                    &PyArray_Type, descr, 0, NULL, NULL, NULL, 0, NULL);
+            Py_SETREF(operands[i], new);
+            if (operands[i] == NULL) {
+                goto fail;
+            }
+
+            PyObject *value = PyTuple_GET_ITEM(full_args.in, i);
+            if (PyArray_SETITEM(new, PyArray_BYTES(operands[i]), value) < 0) {
+                goto fail;
+            }
+        }
+    }
+
     if (subok) {
         _find_array_prepare(full_args, output_array_prepare, nout);
     }
@@ -4892,6 +5007,7 @@ ufunc_generic_fastcall(PyUFuncObject *ufunc,
      */
     Py_XDECREF(wheremask);
     for (int i = 0; i < nop; i++) {
+        Py_DECREF(signature[i]);
         Py_XDECREF(operand_DTypes[i]);
         Py_DECREF(operation_descrs[i]);
         if (i < nin) {
@@ -4915,6 +5031,7 @@ ufunc_generic_fastcall(PyUFuncObject *ufunc,
     Py_XDECREF(wheremask);
     for (int i = 0; i < ufunc->nargs; i++) {
         Py_XDECREF(operands[i]);
+        Py_XDECREF(signature[i]);
         Py_XDECREF(operand_DTypes[i]);
         Py_XDECREF(operation_descrs[i]);
         if (i < nout) {
@@ -5190,9 +5307,22 @@ PyUFunc_FromFuncAndDataAndSignatureAndIdentity(PyUFuncGenericFunction *func, voi
 
         info = add_and_return_legacy_wrapping_ufunc_loop(ufunc, op_dtypes, 1);
         if (info == NULL) {
+            Py_DECREF(ufunc);
             return NULL;
         }
     }
+    /*
+     * TODO: I tried adding a default promoter here (either all object for
+     *       some special cases, or all homogeneous).  Those are reasonable
+     *       defaults, but short-cut a deprecated SciPy loop, where the
+     *       homogeneous loop `ddd->d` was deprecated, but an inhomogeneous
+     *       one `dld->d` should be picked.
+     *       The default promoter *is* a reasonable default, but switched that
+     *       behaviour.
+     *       Another problem appeared due to buggy type-resolution for
+     *       datetimes, this meant that `timedelta.sum(dtype="f8")` returned
+     *       datetimes (and not floats or error), arguably wrong, but...
+     */
     return (PyObject *)ufunc;
 }
 
@@ -5841,6 +5971,13 @@ ufunc_at(PyUFuncObject *ufunc, PyObject *args)
 
     NPY_BEGIN_THREADS_DEF;
 
+    if (ufunc->core_enabled) {
+        PyErr_Format(PyExc_TypeError,
+            "%s.at does not support ufunc with non-trivial signature: %s has signature %s.",
+            ufunc->name, ufunc->name, ufunc->core_signature);
+        return NULL;
+    }
+
     if (ufunc->nin > 2) {
         PyErr_SetString(PyExc_ValueError,
             "Only unary and binary ufuncs supported at this time");
@@ -5963,7 +6100,8 @@ ufunc_at(PyUFuncObject *ufunc, PyObject *args)
 
     PyArrayMethodObject *ufuncimpl = promote_and_get_ufuncimpl(ufunc,
             operands, signature, operand_DTypes,
-            force_legacy_promotion, allow_legacy_promotion);
+            force_legacy_promotion, allow_legacy_promotion,
+            NPY_FALSE, NPY_FALSE);
     if (ufuncimpl == NULL) {
         goto fail;
     }
@@ -6141,7 +6279,9 @@ ufunc_at(PyUFuncObject *ufunc, PyObject *args)
     Py_XDECREF(op2_array);
     Py_XDECREF(iter);
     Py_XDECREF(iter2);
-    for (int i = 0; i < 3; i++) {
+    for (int i = 0; i < nop; i++) {
+        Py_DECREF(signature[i]);
+        Py_XDECREF(operand_DTypes[i]);
         Py_XDECREF(operation_descrs[i]);
         Py_XDECREF(array_operands[i]);
     }
@@ -6167,6 +6307,8 @@ ufunc_at(PyUFuncObject *ufunc, PyObject *args)
     Py_XDECREF(iter);
     Py_XDECREF(iter2);
     for (int i = 0; i < 3; i++) {
+        Py_XDECREF(signature[i]);
+        Py_XDECREF(operand_DTypes[i]);
         Py_XDECREF(operation_descrs[i]);
         Py_XDECREF(array_operands[i]);
     }
@@ -6176,6 +6318,403 @@ ufunc_at(PyUFuncObject *ufunc, PyObject *args)
 }
 
 
+typedef struct {
+    PyArrayMethod_StridedLoop *strided_loop;
+    PyArrayMethod_Context *context;
+    NpyAuxData *auxdata;
+    /* Should move to flags, but lets keep it bools for now: */
+    npy_bool requires_pyapi;
+    npy_bool no_floatingpoint_errors;
+    PyArrayMethod_Context _full_context;
+    PyArray_Descr *_descrs[];
+} ufunc_call_info;
+
+
+void
+free_ufunc_call_info(PyObject *self)
+{
+    ufunc_call_info *call_info = PyCapsule_GetPointer(
+            self, "numpy_1.24_ufunc_call_info");
+
+    PyArrayMethod_Context *context = call_info->context;
+
+    int nargs = context->method->nin + context->method->nout;
+    for (int i = 0; i < nargs; i++) {
+        Py_DECREF(context->descriptors[i]);
+    }
+    Py_DECREF(context->caller);
+    Py_DECREF(context->method);
+    NPY_AUXDATA_FREE(call_info->auxdata);
+
+    PyObject_Free(call_info);
+}
+
+
+/*
+ * Python entry-point to ufunc promotion and dtype/descr resolution.
+ *
+ * This function does most of the work required to execute ufunc without
+ * actually executing it.
+ * This can be very useful for downstream libraries that reimplement NumPy
+ * functionality, such as Numba or Dask.
+ */
+static PyObject *
+py_resolve_dtypes_generic(PyUFuncObject *ufunc, npy_bool return_context,
+        PyObject *const *args, Py_ssize_t len_args, PyObject *kwnames)
+{
+    NPY_PREPARE_ARGPARSER;
+
+    PyObject *descrs_tuple;
+    PyObject *signature_obj = NULL;
+    NPY_CASTING casting = NPY_DEFAULT_ASSIGN_CASTING;
+    npy_bool reduction = NPY_FALSE;
+
+    if (npy_parse_arguments("resolve_dtypes", args, len_args, kwnames,
+            "", NULL, &descrs_tuple,
+            "$signature", NULL, &signature_obj,
+            "$casting", &PyArray_CastingConverter, &casting,
+            "$reduction", &PyArray_BoolConverter, &reduction,
+            NULL, NULL, NULL) < 0) {
+        return NULL;
+    }
+
+    if (reduction && (ufunc->nin != 2 || ufunc->nout != 1)) {
+        PyErr_SetString(PyExc_ValueError,
+                "ufunc is not compatible with reduction operations.");
+        return NULL;
+    }
+
+    /*
+     * Legacy type resolvers expect NumPy arrays as input.  Until NEP 50 is
+     * adopted, it is most convenient to ensure that we have an "array" object
+     * before calling the type promotion.  Eventually, this hack may be moved
+     * into the legacy type resolution code itself (probably after NumPy stops
+     * using legacy type resolution itself for the most part).
+     *
+     * We make the pretty safe assumptions here that:
+     * - Nobody will actually do anything with the array objects besides
+     *   checking the descriptor or calling CanCast.
+     * - No type resolver will cause weird paths that mess with our promotion
+     *   state (or mind us messing with it).
+     */
+    PyObject *result = NULL;
+    PyObject *result_dtype_tuple = NULL;
+
+    PyArrayObject *dummy_arrays[NPY_MAXARGS] = {NULL};
+    PyArray_DTypeMeta *DTypes[NPY_MAXARGS] = {NULL};
+    PyArray_DTypeMeta *signature[NPY_MAXARGS] = {NULL};
+    PyArray_Descr *operation_descrs[NPY_MAXARGS] = {NULL};
+
+    /* This entry-point to promotion lives in the NEP 50 future: */
+    int original_promotion_state = npy_promotion_state;
+    npy_promotion_state = NPY_USE_WEAK_PROMOTION;
+
+    npy_bool promoting_pyscalars = NPY_FALSE;
+    npy_bool allow_legacy_promotion = NPY_TRUE;
+
+    if (_get_fixed_signature(ufunc, NULL, signature_obj, signature) < 0) {
+        goto finish;
+    }
+
+    if (!PyTuple_CheckExact(descrs_tuple)
+            || PyTuple_Size(descrs_tuple) != ufunc->nargs)  {
+        PyErr_SetString(PyExc_TypeError,
+                "resolve_dtypes: The dtypes must be a tuple of "
+                "`ufunc.nargs` length.");
+        goto finish;
+    }
+    for (int i=0; i < ufunc->nargs; i++) {
+        /*
+         * We create dummy arrays for now.  It should be OK to make this
+         * truly "dummy" (not even proper objects), but that is a hack better
+         * left for the legacy_type_resolution wrapper when NEP 50 is done.
+         */
+        PyObject *descr_obj = PyTuple_GET_ITEM(descrs_tuple, i);
+        PyArray_Descr *descr;
+
+        if (PyArray_DescrCheck(descr_obj)) {
+            descr = (PyArray_Descr *)descr_obj;
+            Py_INCREF(descr);
+            dummy_arrays[i] = (PyArrayObject *)PyArray_NewFromDescr_int(
+                    &PyArray_Type, descr, 0, NULL, NULL, NULL,
+                    0, NULL, NULL, 0, 1);
+            if (dummy_arrays[i] == NULL) {
+                goto finish;
+            }
+            if (PyArray_DESCR(dummy_arrays[i]) != descr) {
+                PyErr_SetString(PyExc_NotImplementedError,
+                    "dtype was replaced during array creation, the dtype is "
+                    "unsupported currently (a subarray dtype?).");
+                goto finish;
+            }
+            DTypes[i] = NPY_DTYPE(descr);
+            Py_INCREF(DTypes[i]);
+            if (!NPY_DT_is_legacy(DTypes[i])) {
+                allow_legacy_promotion = NPY_FALSE;
+            }
+        }
+         /* Explicitly allow int, float, and complex for the "weak" types. */
+        else if (descr_obj == (PyObject *)&PyLong_Type) {
+            descr = PyArray_DescrFromType(NPY_LONG);
+            dummy_arrays[i] = (PyArrayObject *)PyArray_Empty(0, NULL, descr, 0);
+            if (dummy_arrays[i] == NULL) {
+                goto finish;
+            }
+            PyArray_ENABLEFLAGS(dummy_arrays[i], NPY_ARRAY_WAS_PYTHON_INT);
+            Py_INCREF(&PyArray_PyIntAbstractDType);
+            DTypes[i] = &PyArray_PyIntAbstractDType;
+            promoting_pyscalars = NPY_TRUE;
+        }
+        else if (descr_obj == (PyObject *)&PyFloat_Type) {
+            descr = PyArray_DescrFromType(NPY_DOUBLE);
+            dummy_arrays[i] = (PyArrayObject *)PyArray_Empty(0, NULL, descr, 0);
+            if (dummy_arrays[i] == NULL) {
+                goto finish;
+            }
+            PyArray_ENABLEFLAGS(dummy_arrays[i], NPY_ARRAY_WAS_PYTHON_FLOAT);
+            Py_INCREF(&PyArray_PyFloatAbstractDType);
+            DTypes[i] = &PyArray_PyFloatAbstractDType;
+            promoting_pyscalars = NPY_TRUE;
+        }
+        else if (descr_obj == (PyObject *)&PyComplex_Type) {
+            descr = PyArray_DescrFromType(NPY_CDOUBLE);
+            dummy_arrays[i] = (PyArrayObject *)PyArray_Empty(0, NULL, descr, 0);
+            if (dummy_arrays[i] == NULL) {
+                goto finish;
+            }
+            PyArray_ENABLEFLAGS(dummy_arrays[i], NPY_ARRAY_WAS_PYTHON_COMPLEX);
+            Py_INCREF(&PyArray_PyComplexAbstractDType);
+            DTypes[i] = &PyArray_PyComplexAbstractDType;
+            promoting_pyscalars = NPY_TRUE;
+        }
+        else if (descr_obj == Py_None) {
+            if (i < ufunc->nin && !(reduction && i == 0)) {
+                PyErr_SetString(PyExc_TypeError,
+                        "All input dtypes must be provided "
+                        "(except the first one in reductions)");
+                goto finish;
+            }
+        }
+        else {
+            PyErr_SetString(PyExc_TypeError,
+                    "Provided dtype must be a valid NumPy dtype, "
+                    "int, float, complex, or None.");
+            goto finish;
+        }
+    }
+
+    PyArrayMethodObject *ufuncimpl;
+    if (!reduction) {
+        ufuncimpl = promote_and_get_ufuncimpl(ufunc,
+                dummy_arrays, signature, DTypes, NPY_FALSE,
+                allow_legacy_promotion, promoting_pyscalars, NPY_FALSE);
+        if (ufuncimpl == NULL) {
+            goto finish;
+        }
+
+        /* Find the correct descriptors for the operation */
+        if (resolve_descriptors(ufunc->nargs, ufunc, ufuncimpl,
+                dummy_arrays, operation_descrs, signature, casting) < 0) {
+            goto finish;
+        }
+
+        if (validate_casting(
+                ufuncimpl, ufunc, dummy_arrays, operation_descrs, casting) < 0) {
+            goto finish;
+        }
+    }
+    else {  /* reduction */
+        if (signature[2] != NULL) {
+            PyErr_SetString(PyExc_ValueError,
+                    "Reduction signature must end with None, instead pass "
+                    "the first DType in the signature.");
+            goto finish;
+        }
+
+        if (dummy_arrays[2] != NULL) {
+            PyErr_SetString(PyExc_TypeError,
+                    "Output dtype must not be passed for reductions, "
+                    "pass the first input instead.");
+            goto finish;
+        }
+
+        ufuncimpl = reducelike_promote_and_resolve(ufunc,
+                dummy_arrays[1], dummy_arrays[0], signature, NPY_FALSE,
+                operation_descrs, casting, "resolve_dtypes");
+
+        if (ufuncimpl == NULL) {
+            goto finish;
+        }
+    }
+
+    result = PyArray_TupleFromItems(
+            ufunc->nargs, (PyObject **)operation_descrs, 0);
+
+    if (result == NULL || !return_context) {
+        goto finish;
+    }
+    /* Result will be (dtype_tuple, call_info), so move it and clear result */
+    result_dtype_tuple = result;
+    result = NULL;
+
+    /* We may have to return the context: */
+    ufunc_call_info *call_info;
+    call_info = PyObject_Malloc(sizeof(ufunc_call_info)
+                              + ufunc->nargs * sizeof(PyArray_Descr *));
+    if (call_info == NULL) {
+        PyErr_NoMemory();
+        goto finish;
+    }
+    call_info->strided_loop = NULL;
+    call_info->auxdata = NULL;
+    call_info->context = &call_info->_full_context;
+
+    /*
+     * We create a capsule with NumPy 1.24 in the name to signal that it is
+     * prone to change in version updates (it doesn't have to).
+     * This capsule is documented in the `ufunc._resolve_dtypes_and_context`
+     * docstring.
+     */
+    PyObject *capsule = PyCapsule_New(
+            call_info, "numpy_1.24_ufunc_call_info", &free_ufunc_call_info);
+    if (capsule == NULL) {
+        PyObject_Free(call_info);
+        goto finish;
+    }
+
+    PyArrayMethod_Context *context = call_info->context;
+
+    Py_INCREF(ufunc);
+    context->caller = (PyObject *)ufunc;
+    Py_INCREF(ufuncimpl);
+    context->method = ufuncimpl;
+    context->descriptors = call_info->_descrs;
+    for (int i=0; i < ufunc->nargs; i++) {
+        Py_INCREF(operation_descrs[i]);
+        context->descriptors[i] = operation_descrs[i];
+    }
+
+    result = PyTuple_Pack(2, result_dtype_tuple, capsule);
+    /* cleanup and return */
+    Py_DECREF(capsule);
+
+  finish:
+    npy_promotion_state = original_promotion_state;
+
+    Py_XDECREF(result_dtype_tuple);
+    for (int i = 0; i < ufunc->nargs; i++) {
+        Py_XDECREF(signature[i]);
+        Py_XDECREF(dummy_arrays[i]);
+        Py_XDECREF(operation_descrs[i]);
+        Py_XDECREF(DTypes[i]);
+    }
+
+    return result;
+}
+
+
+static PyObject *
+py_resolve_dtypes(PyUFuncObject *ufunc,
+        PyObject *const *args, Py_ssize_t len_args, PyObject *kwnames)
+{
+    return py_resolve_dtypes_generic(ufunc, NPY_FALSE, args, len_args, kwnames);
+}
+
+
+static PyObject *
+py_resolve_dtypes_and_context(PyUFuncObject *ufunc,
+        PyObject *const *args, Py_ssize_t len_args, PyObject *kwnames)
+{
+    return py_resolve_dtypes_generic(ufunc, NPY_TRUE, args, len_args, kwnames);
+}
+
+
+static PyObject *
+py_get_strided_loop(PyUFuncObject *ufunc,
+        PyObject *const *args, Py_ssize_t len_args, PyObject *kwnames)
+{
+    NPY_PREPARE_ARGPARSER;
+
+    PyObject *call_info_obj;
+    PyObject *fixed_strides_obj = Py_None;
+    npy_intp fixed_strides[NPY_MAXARGS];
+
+    if (npy_parse_arguments("_get_strided_loop", args, len_args, kwnames,
+            "", NULL, &call_info_obj,
+            "$fixed_strides", NULL, &fixed_strides_obj,
+            NULL, NULL, NULL) < 0) {
+        return NULL;
+    }
+
+    ufunc_call_info *call_info = PyCapsule_GetPointer(
+                call_info_obj, "numpy_1.24_ufunc_call_info");
+    if (call_info == NULL) {
+        /* Cannot have a context with NULL inside... */
+        assert(PyErr_Occurred());
+        return NULL;
+    }
+    if (call_info->strided_loop != NULL) {
+        PyErr_SetString(PyExc_TypeError,
+                "ufunc call_info has already been filled/used!");
+        return NULL;
+    }
+
+    if (call_info->context->caller != (PyObject *)ufunc) {
+        PyErr_SetString(PyExc_TypeError,
+                "calling get_strided_loop with incompatible context");
+        return NULL;
+    }
+
+    /*
+     * Strict conversion of fixed_strides, None, or tuple of int or None.
+     */
+    if (fixed_strides_obj == Py_None) {
+        for (int i = 0; i < ufunc->nargs; i++) {
+            fixed_strides[i] = NPY_MAX_INTP;
+        }
+    }
+    else if (PyTuple_CheckExact(fixed_strides_obj)
+            && PyTuple_Size(fixed_strides_obj) == ufunc->nargs) {
+        for (int i = 0; i < ufunc->nargs; i++) {
+            PyObject *stride = PyTuple_GET_ITEM(fixed_strides_obj, i);
+            if (PyLong_CheckExact(stride)) {
+                fixed_strides[i] = PyLong_AsSsize_t(stride);
+                if (error_converting(fixed_strides[i])) {
+                    return NULL;
+                }
+            }
+            else if (stride == Py_None) {
+                fixed_strides[i] = NPY_MAX_INTP;
+            }
+            else {
+                PyErr_SetString(PyExc_TypeError,
+                    "_get_strided_loop(): fixed_strides tuple must contain "
+                    "Python ints or None");
+                return NULL;
+            }
+        }
+    }
+    else {
+        PyErr_SetString(PyExc_TypeError,
+            "_get_strided_loop(): fixed_strides must be a tuple or None");
+        return NULL;
+    }
+
+    NPY_ARRAYMETHOD_FLAGS flags;
+    if (call_info->context->method->get_strided_loop(call_info->context,
+            1, 0, fixed_strides, &call_info->strided_loop, &call_info->auxdata,
+            &flags) < 0) {
+        return NULL;
+    }
+
+    call_info->requires_pyapi = flags & NPY_METH_REQUIRES_PYAPI;
+    call_info->no_floatingpoint_errors = (
+            flags & NPY_METH_NO_FLOATINGPOINT_ERRORS);
+
+    Py_RETURN_NONE;
+}
+
+
 static struct PyMethodDef ufunc_methods[] = {
     {"reduce",
         (PyCFunction)ufunc_reduce,
@@ -6192,6 +6731,21 @@ static struct PyMethodDef ufunc_methods[] = {
     {"at",
         (PyCFunction)ufunc_at,
         METH_VARARGS, NULL},
+    /* Lower level methods: */
+    {"resolve_dtypes",
+        (PyCFunction)py_resolve_dtypes,
+        METH_FASTCALL | METH_KEYWORDS, NULL},
+    /*
+     * The following two functions are public API, but underscored since they
+     * are C-user specific and allow direct access to the core of ufunc loops.
+     * (See their documentation for API stability.)
+     */
+    {"_resolve_dtypes_and_context",
+        (PyCFunction)py_resolve_dtypes_and_context,
+        METH_FASTCALL | METH_KEYWORDS, NULL},
+    {"_get_strided_loop",
+        (PyCFunction)py_get_strided_loop,
+        METH_FASTCALL | METH_KEYWORDS, NULL},
     {NULL, NULL, 0, NULL}           /* sentinel */
 };
 
@@ -6372,6 +6926,7 @@ NPY_NO_EXPORT PyTypeObject PyUFunc_Type = {
     .tp_name = "numpy.ufunc",
     .tp_basicsize = sizeof(PyUFuncObject),
     .tp_dealloc = (destructor)ufunc_dealloc,
+    .tp_vectorcall_offset = offsetof(PyUFuncObject, vectorcall),
     .tp_repr = (reprfunc)ufunc_repr,
     .tp_call = &PyVectorcall_Call,
     .tp_str = (reprfunc)ufunc_repr,
@@ -6381,7 +6936,6 @@ NPY_NO_EXPORT PyTypeObject PyUFunc_Type = {
     .tp_traverse = (traverseproc)ufunc_traverse,
     .tp_methods = ufunc_methods,
     .tp_getset = ufunc_getset,
-    .tp_vectorcall_offset = offsetof(PyUFuncObject, vectorcall),
 };
 
 /* End of code for ufunc objects */
diff --git a/numpy/core/src/umath/ufunc_object.h b/numpy/core/src/umath/ufunc_object.h
index 6d4fed7c02d2..32af6c58ed6a 100644
--- a/numpy/core/src/umath/ufunc_object.h
+++ b/numpy/core/src/umath/ufunc_object.h
@@ -13,6 +13,7 @@ NPY_NO_EXPORT const char*
 ufunc_get_name_cstr(PyUFuncObject *ufunc);
 
 /* strings from umathmodule.c that are interned on umath import */
+NPY_VISIBILITY_HIDDEN extern PyObject *npy_um_str_array_ufunc;
 NPY_VISIBILITY_HIDDEN extern PyObject *npy_um_str_array_prepare;
 NPY_VISIBILITY_HIDDEN extern PyObject *npy_um_str_array_wrap;
 NPY_VISIBILITY_HIDDEN extern PyObject *npy_um_str_pyvals_name;
diff --git a/numpy/core/src/umath/ufunc_type_resolution.c b/numpy/core/src/umath/ufunc_type_resolution.c
index 9ed923cf56e7..707f39e94513 100644
--- a/numpy/core/src/umath/ufunc_type_resolution.c
+++ b/numpy/core/src/umath/ufunc_type_resolution.c
@@ -41,6 +41,7 @@
 #include "ufunc_object.h"
 #include "common.h"
 #include "convert_datatype.h"
+#include "dtypemeta.h"
 
 #include "mem_overlap.h"
 #if defined(HAVE_CBLAS)
@@ -48,6 +49,7 @@
 #endif
 
 #include 
+#include 
 
 static PyObject *
 npy_casting_to_py_object(NPY_CASTING casting)
@@ -380,53 +382,9 @@ PyUFunc_SimpleBinaryComparisonTypeResolver(PyUFuncObject *ufunc,
         }
     }
     else {
-        PyArray_Descr *descr;
-        /*
-         * DEPRECATED 2021-03, NumPy 1.20
-         *
-         * If the type tuple was originally a single element (probably),
-         * issue a deprecation warning, but otherwise accept it.  Since the
-         * result dtype is always boolean, this is not actually valid unless it
-         * is `object` (but if there is an object input we already deferred).
-         *
-         * TODO: Once this deprecation is gone, the special case for
-         *       `PyUFunc_SimpleBinaryComparisonTypeResolver` in dispatching.c
-         *       can be removed.
-         */
-        if (PyTuple_Check(type_tup) && PyTuple_GET_SIZE(type_tup) == 3 &&
-                PyTuple_GET_ITEM(type_tup, 0) == Py_None &&
-                PyTuple_GET_ITEM(type_tup, 1) == Py_None &&
-                PyArray_DescrCheck(PyTuple_GET_ITEM(type_tup, 2))) {
-            descr = (PyArray_Descr *)PyTuple_GET_ITEM(type_tup, 2);
-            if (descr->type_num == NPY_OBJECT) {
-                if (DEPRECATE_FUTUREWARNING(
-                        "using `dtype=object` (or equivalent signature) will "
-                        "return object arrays in the future also when the "
-                        "inputs do not already have `object` dtype.") < 0) {
-                    return -1;
-                }
-            }
-            else if (descr->type_num != NPY_BOOL) {
-                if (DEPRECATE(
-                        "using `dtype=` in comparisons is only useful for "
-                        "`dtype=object` (and will do nothing for bool). "
-                        "This operation will fail in the future.") < 0) {
-                    return -1;
-                }
-            }
-        }
-        else {
-            /* Usually a failure, but let the the default version handle it */
-            return PyUFunc_DefaultTypeResolver(ufunc, casting,
-                    operands, type_tup, out_dtypes);
-        }
-
-        out_dtypes[0] = ensure_dtype_nbo(descr);
-        if (out_dtypes[0] == NULL) {
-            return -1;
-        }
-        out_dtypes[1] = out_dtypes[0];
-        Py_INCREF(out_dtypes[1]);
+        /* Usually a failure, but let the default version handle it */
+        return PyUFunc_DefaultTypeResolver(ufunc, casting,
+                operands, type_tup, out_dtypes);
     }
 
     /* Output type is always boolean */
@@ -545,7 +503,8 @@ PyUFunc_SimpleUniformOperationTypeResolver(
     if (type_tup == NULL) {
         /* PyArray_ResultType forgets to force a byte order when n == 1 */
         if (ufunc->nin == 1){
-            out_dtypes[0] = ensure_dtype_nbo(PyArray_DESCR(operands[0]));
+            out_dtypes[0] = NPY_DT_CALL_ensure_canonical(
+                    PyArray_DESCR(operands[0]));
         }
         else {
             int iop;
@@ -629,7 +588,7 @@ PyUFunc_SimpleUniformOperationTypeResolver(
             /* Prefer the input descriptor if it matches (preserve metadata) */
             descr = PyArray_DESCR(operands[0]);
         }
-        out_dtypes[0] = ensure_dtype_nbo(descr);
+        out_dtypes[0] = NPY_DT_CALL_ensure_canonical(descr);
     }
 
     /* All types are the same - copy the first one to the rest */
@@ -691,11 +650,11 @@ PyUFunc_IsNaTTypeResolver(PyUFuncObject *ufunc,
 {
     if (!PyTypeNum_ISDATETIME(PyArray_DESCR(operands[0])->type_num)) {
         PyErr_SetString(PyExc_TypeError,
-                "ufunc 'isnat' is only defined for datetime and timedelta.");
+                "ufunc 'isnat' is only defined for np.datetime64 and np.timedelta64.");
         return -1;
     }
 
-    out_dtypes[0] = ensure_dtype_nbo(PyArray_DESCR(operands[0]));
+    out_dtypes[0] = NPY_DT_CALL_ensure_canonical(PyArray_DESCR(operands[0]));
     out_dtypes[1] = PyArray_DescrFromType(NPY_BOOL);
 
     return 0;
@@ -714,7 +673,7 @@ PyUFunc_IsFiniteTypeResolver(PyUFuncObject *ufunc,
                                     type_tup, out_dtypes);
     }
 
-    out_dtypes[0] = ensure_dtype_nbo(PyArray_DESCR(operands[0]));
+    out_dtypes[0] = NPY_DT_CALL_ensure_canonical(PyArray_DESCR(operands[0]));
     out_dtypes[1] = PyArray_DescrFromType(NPY_BOOL);
 
     return 0;
@@ -816,7 +775,8 @@ PyUFunc_AdditionTypeResolver(PyUFuncObject *ufunc,
         /* m8[] + int => m8[] + m8[] */
         else if (PyTypeNum_ISINTEGER(type_num2) ||
                                     PyTypeNum_ISBOOL(type_num2)) {
-            out_dtypes[0] = ensure_dtype_nbo(PyArray_DESCR(operands[0]));
+            out_dtypes[0] = NPY_DT_CALL_ensure_canonical(
+                    PyArray_DESCR(operands[0]));
             if (out_dtypes[0] == NULL) {
                 return -1;
             }
@@ -852,7 +812,8 @@ PyUFunc_AdditionTypeResolver(PyUFuncObject *ufunc,
         /* M8[] + int => M8[] + m8[] */
         else if (PyTypeNum_ISINTEGER(type_num2) ||
                     PyTypeNum_ISBOOL(type_num2)) {
-            out_dtypes[0] = ensure_dtype_nbo(PyArray_DESCR(operands[0]));
+            out_dtypes[0] = NPY_DT_CALL_ensure_canonical(
+                    PyArray_DESCR(operands[0]));
             if (out_dtypes[0] == NULL) {
                 return -1;
             }
@@ -876,7 +837,8 @@ PyUFunc_AdditionTypeResolver(PyUFuncObject *ufunc,
     else if (PyTypeNum_ISINTEGER(type_num1) || PyTypeNum_ISBOOL(type_num1)) {
         /* int + m8[] => m8[] + m8[] */
         if (type_num2 == NPY_TIMEDELTA) {
-            out_dtypes[0] = ensure_dtype_nbo(PyArray_DESCR(operands[1]));
+            out_dtypes[0] = NPY_DT_CALL_ensure_canonical(
+                    PyArray_DESCR(operands[1]));
             if (out_dtypes[0] == NULL) {
                 return -1;
             }
@@ -894,7 +856,8 @@ PyUFunc_AdditionTypeResolver(PyUFuncObject *ufunc,
             if (out_dtypes[0] == NULL) {
                 return -1;
             }
-            out_dtypes[1] = ensure_dtype_nbo(PyArray_DESCR(operands[1]));
+            out_dtypes[1] = NPY_DT_CALL_ensure_canonical(
+                    PyArray_DESCR(operands[1]));
             if (out_dtypes[1] == NULL) {
                 Py_DECREF(out_dtypes[0]);
                 out_dtypes[0] = NULL;
@@ -985,7 +948,8 @@ PyUFunc_SubtractionTypeResolver(PyUFuncObject *ufunc,
         /* m8[] - int => m8[] - m8[] */
         else if (PyTypeNum_ISINTEGER(type_num2) ||
                                         PyTypeNum_ISBOOL(type_num2)) {
-            out_dtypes[0] = ensure_dtype_nbo(PyArray_DESCR(operands[0]));
+            out_dtypes[0] = NPY_DT_CALL_ensure_canonical(
+                    PyArray_DESCR(operands[0]));
             if (out_dtypes[0] == NULL) {
                 return -1;
             }
@@ -1021,7 +985,8 @@ PyUFunc_SubtractionTypeResolver(PyUFuncObject *ufunc,
         /* M8[] - int => M8[] - m8[] */
         else if (PyTypeNum_ISINTEGER(type_num2) ||
                     PyTypeNum_ISBOOL(type_num2)) {
-            out_dtypes[0] = ensure_dtype_nbo(PyArray_DESCR(operands[0]));
+            out_dtypes[0] = NPY_DT_CALL_ensure_canonical(
+                    PyArray_DESCR(operands[0]));
             if (out_dtypes[0] == NULL) {
                 return -1;
             }
@@ -1061,7 +1026,8 @@ PyUFunc_SubtractionTypeResolver(PyUFuncObject *ufunc,
     else if (PyTypeNum_ISINTEGER(type_num1) || PyTypeNum_ISBOOL(type_num1)) {
         /* int - m8[] => m8[] - m8[] */
         if (type_num2 == NPY_TIMEDELTA) {
-            out_dtypes[0] = ensure_dtype_nbo(PyArray_DESCR(operands[1]));
+            out_dtypes[0] = NPY_DT_CALL_ensure_canonical(
+                    PyArray_DESCR(operands[1]));
             if (out_dtypes[0] == NULL) {
                 return -1;
             }
@@ -1122,7 +1088,8 @@ PyUFunc_MultiplicationTypeResolver(PyUFuncObject *ufunc,
     if (type_num1 == NPY_TIMEDELTA) {
         /* m8[] * int## => m8[] * int64 */
         if (PyTypeNum_ISINTEGER(type_num2) || PyTypeNum_ISBOOL(type_num2)) {
-            out_dtypes[0] = ensure_dtype_nbo(PyArray_DESCR(operands[0]));
+            out_dtypes[0] = NPY_DT_CALL_ensure_canonical(
+                    PyArray_DESCR(operands[0]));
             if (out_dtypes[0] == NULL) {
                 return -1;
             }
@@ -1139,7 +1106,8 @@ PyUFunc_MultiplicationTypeResolver(PyUFuncObject *ufunc,
         }
         /* m8[] * float## => m8[] * float64 */
         else if (PyTypeNum_ISFLOAT(type_num2)) {
-            out_dtypes[0] = ensure_dtype_nbo(PyArray_DESCR(operands[0]));
+            out_dtypes[0] = NPY_DT_CALL_ensure_canonical(
+                    PyArray_DESCR(operands[0]));
             if (out_dtypes[0] == NULL) {
                 return -1;
             }
@@ -1165,7 +1133,8 @@ PyUFunc_MultiplicationTypeResolver(PyUFuncObject *ufunc,
             if (out_dtypes[0] == NULL) {
                 return -1;
             }
-            out_dtypes[1] = ensure_dtype_nbo(PyArray_DESCR(operands[1]));
+            out_dtypes[1] = NPY_DT_CALL_ensure_canonical(
+                    PyArray_DESCR(operands[1]));
             if (out_dtypes[1] == NULL) {
                 Py_DECREF(out_dtypes[0]);
                 out_dtypes[0] = NULL;
@@ -1187,7 +1156,8 @@ PyUFunc_MultiplicationTypeResolver(PyUFuncObject *ufunc,
             if (out_dtypes[0] == NULL) {
                 return -1;
             }
-            out_dtypes[1] = ensure_dtype_nbo(PyArray_DESCR(operands[1]));
+            out_dtypes[1] = NPY_DT_CALL_ensure_canonical(
+                    PyArray_DESCR(operands[1]));
             if (out_dtypes[1] == NULL) {
                 Py_DECREF(out_dtypes[0]);
                 out_dtypes[0] = NULL;
@@ -1278,7 +1248,8 @@ PyUFunc_DivisionTypeResolver(PyUFuncObject *ufunc,
         }
         /* m8[] / int## => m8[] / int64 */
         else if (PyTypeNum_ISINTEGER(type_num2)) {
-            out_dtypes[0] = ensure_dtype_nbo(PyArray_DESCR(operands[0]));
+            out_dtypes[0] = NPY_DT_CALL_ensure_canonical(
+                    PyArray_DESCR(operands[0]));
             if (out_dtypes[0] == NULL) {
                 return -1;
             }
@@ -1295,7 +1266,8 @@ PyUFunc_DivisionTypeResolver(PyUFuncObject *ufunc,
         }
         /* m8[] / float## => m8[] / float64 */
         else if (PyTypeNum_ISFLOAT(type_num2)) {
-            out_dtypes[0] = ensure_dtype_nbo(PyArray_DESCR(operands[0]));
+            out_dtypes[0] = NPY_DT_CALL_ensure_canonical(
+                    PyArray_DESCR(operands[0]));
             if (out_dtypes[0] == NULL) {
                 return -1;
             }
@@ -1528,7 +1500,7 @@ PyUFunc_DefaultLegacyInnerLoopSelector(PyUFuncObject *ufunc,
         }
         if (j == nargs) {
             *out_innerloop = ufunc->functions[i];
-            *out_innerloopdata = ufunc->data[i];
+            *out_innerloopdata = (ufunc->data == NULL) ? NULL : ufunc->data[i];
             return 0;
         }
 
@@ -1672,7 +1644,8 @@ set_ufunc_loop_data_types(PyUFuncObject *self, PyArrayObject **op,
         }
         else if (op[i] != NULL &&
                  PyArray_DESCR(op[i])->type_num == type_nums[i]) {
-            out_dtypes[i] = ensure_dtype_nbo(PyArray_DESCR(op[i]));
+            out_dtypes[i] = NPY_DT_CALL_ensure_canonical(
+                    PyArray_DESCR(op[i]));
         }
         /*
          * For outputs, copy the dtype from op[0] if the type_num
@@ -1680,7 +1653,8 @@ set_ufunc_loop_data_types(PyUFuncObject *self, PyArrayObject **op,
          */
         else if (i >= nin && op[0] != NULL &&
                             PyArray_DESCR(op[0])->type_num == type_nums[i]) {
-            out_dtypes[i] = ensure_dtype_nbo(PyArray_DESCR(op[0]));
+            out_dtypes[i] = NPY_DT_CALL_ensure_canonical(
+                    PyArray_DESCR(op[0]));
         }
         /* Otherwise create a plain descr from the type number */
         else {
@@ -1912,14 +1886,21 @@ linear_search_type_resolver(PyUFuncObject *self,
     int types[NPY_MAXARGS];
     const char *ufunc_name;
     int no_castable_output = 0;
-    int use_min_scalar;
 
     /* For making a better error message on coercion error */
     char err_dst_typecode = '-', err_src_typecode = '-';
 
     ufunc_name = ufunc_get_name_cstr(self);
 
-    use_min_scalar = should_use_min_scalar(nin, op, 0, NULL);
+    assert(npy_promotion_state != NPY_USE_WEAK_PROMOTION_AND_WARN);
+    /* Always "use" with new promotion in case of Python int/float/complex */
+    int use_min_scalar;
+    if (npy_promotion_state == NPY_USE_LEGACY_PROMOTION) {
+        use_min_scalar = should_use_min_scalar(nin, op, 0, NULL);
+    }
+    else {
+        use_min_scalar = should_use_min_scalar_weak_literals(nin, op);
+    }
 
     /* If the ufunc has userloops, search for them. */
     if (self->userloops) {
@@ -2109,11 +2090,19 @@ type_tuple_type_resolver(PyUFuncObject *self,
     int nin = self->nin, nop = nin + self->nout;
     int specified_types[NPY_MAXARGS];
     const char *ufunc_name;
-    int no_castable_output = 0, use_min_scalar;
+    int no_castable_output = 0;
 
     ufunc_name = ufunc_get_name_cstr(self);
 
-    use_min_scalar = should_use_min_scalar(nin, op, 0, NULL);
+    assert(npy_promotion_state != NPY_USE_WEAK_PROMOTION_AND_WARN);
+    /* Always "use" with new promotion in case of Python int/float/complex */
+    int use_min_scalar;
+    if (npy_promotion_state == NPY_USE_LEGACY_PROMOTION) {
+        use_min_scalar = should_use_min_scalar(nin, op, 0, NULL);
+    }
+    else {
+        use_min_scalar = should_use_min_scalar_weak_literals(nin, op);
+    }
 
     /* Fill in specified_types from the tuple or string */
     const char *bad_type_tup_msg = (
diff --git a/numpy/core/src/umath/umathmodule.c b/numpy/core/src/umath/umathmodule.c
index 272555704cf5..0aa32820d0ad 100644
--- a/numpy/core/src/umath/umathmodule.c
+++ b/numpy/core/src/umath/umathmodule.c
@@ -14,6 +14,9 @@
 #include 
 
 #include "npy_config.h"
+#include "npy_cpu_features.h"
+#include "npy_cpu_dispatch.h"
+#include "numpy/npy_cpu.h"
 
 #include "numpy/arrayobject.h"
 #include "numpy/ufuncobject.h"
@@ -23,6 +26,12 @@
 #include "numpy/npy_math.h"
 #include "number.h"
 #include "dispatching.h"
+#include "string_ufuncs.h"
+
+/* Automatically generated code to define all ufuncs: */
+#include "funcs.inc"
+#include "__umath_generated.c"
+
 
 static PyUFuncGenericFunction pyfunc_functions[] = {PyUFunc_On_Om};
 
@@ -56,7 +65,7 @@ object_ufunc_loop_selector(PyUFuncObject *ufunc,
                             int *out_needs_api)
 {
     *out_innerloop = ufunc->functions[0];
-    *out_innerloopdata = ufunc->data[0];
+    *out_innerloopdata = (ufunc->data == NULL) ? NULL : ufunc->data[0];
     *out_needs_api = 1;
 
     return 0;
@@ -209,6 +218,7 @@ add_newdoc_ufunc(PyObject *NPY_UNUSED(dummy), PyObject *args)
  *****************************************************************************
  */
 
+NPY_VISIBILITY_HIDDEN PyObject *npy_um_str_array_ufunc = NULL;
 NPY_VISIBILITY_HIDDEN PyObject *npy_um_str_array_prepare = NULL;
 NPY_VISIBILITY_HIDDEN PyObject *npy_um_str_array_wrap = NULL;
 NPY_VISIBILITY_HIDDEN PyObject *npy_um_str_pyvals_name = NULL;
@@ -217,6 +227,10 @@ NPY_VISIBILITY_HIDDEN PyObject *npy_um_str_pyvals_name = NULL;
 static int
 intern_strings(void)
 {
+    npy_um_str_array_ufunc = PyUnicode_InternFromString("__array_ufunc__");
+    if (npy_um_str_array_ufunc == NULL) {
+        return -1;
+    }
     npy_um_str_array_prepare = PyUnicode_InternFromString("__array_prepare__");
     if (npy_um_str_array_prepare == NULL) {
         return -1;
@@ -246,6 +260,10 @@ int initumath(PyObject *m)
     /* Add some symbolic constants to the module */
     d = PyModule_GetDict(m);
 
+    if (InitOperators(d) < 0) {
+        return -1;
+    }
+
     PyDict_SetItemString(d, "pi", s = PyFloat_FromDouble(NPY_PI));
     Py_DECREF(s);
     PyDict_SetItemString(d, "e", s = PyFloat_FromDouble(NPY_E));
@@ -288,8 +306,8 @@ int initumath(PyObject *m)
     PyModule_AddObject(m, "NZERO", PyFloat_FromDouble(NPY_NZERO));
     PyModule_AddObject(m, "NAN", PyFloat_FromDouble(NPY_NAN));
 
-    s = PyDict_GetItemString(d, "true_divide");
-    PyDict_SetItemString(d, "divide", s);
+    s = PyDict_GetItemString(d, "divide");
+    PyDict_SetItemString(d, "true_divide", s);
 
     s = PyDict_GetItemString(d, "conjugate");
     s2 = PyDict_GetItemString(d, "remainder");
@@ -334,5 +352,10 @@ int initumath(PyObject *m)
     if (install_logical_ufunc_promoter(s) < 0) {
         return -1;
     }
+
+    if (init_string_ufuncs(d) < 0) {
+        return -1;
+    }
+
     return 0;
 }
diff --git a/numpy/core/src/umath/wrapping_array_method.c b/numpy/core/src/umath/wrapping_array_method.c
new file mode 100644
index 000000000000..9f8f036e8a65
--- /dev/null
+++ b/numpy/core/src/umath/wrapping_array_method.c
@@ -0,0 +1,301 @@
+/*
+ * This file defines most of the machinery in order to wrap an existing ufunc
+ * loop for use with a different set of dtypes.
+ *
+ * There are two approaches for this, one is to teach the NumPy core about
+ * the possibility that the loop descriptors do not match exactly the result
+ * descriptors.
+ * The other is to handle this fully by "wrapping", so that NumPy core knows
+ * nothing about this going on.
+ * The slight difficulty here is that `context` metadata needs to be mutated.
+ * It also adds a tiny bit of overhead, since we have to "fix" the descriptors
+ * and unpack the auxdata.
+ *
+ * This means that this currently needs to live within NumPy, as it needs both
+ * extensive API exposure to do it outside, as well as some thoughts on how to
+ * expose the `context` without breaking ABI forward compatibility.
+ * (I.e. we probably need to allocate the context and provide a copy function
+ * or so.)
+ */
+#define NPY_NO_DEPRECATED_API NPY_API_VERSION
+#define _MULTIARRAYMODULE
+#define _UMATHMODULE
+
+#define PY_SSIZE_T_CLEAN
+#include 
+
+#include "numpy/ndarraytypes.h"
+
+#include "common.h"
+#include "array_method.h"
+#include "legacy_array_method.h"
+#include "dtypemeta.h"
+#include "dispatching.h"
+
+
+static NPY_CASTING
+wrapping_method_resolve_descriptors(
+        PyArrayMethodObject *self,
+        PyArray_DTypeMeta *dtypes[],
+        PyArray_Descr *given_descrs[],
+        PyArray_Descr *loop_descrs[],
+        npy_intp *view_offset)
+{
+    int nin = self->nin, nout = self->nout, nargs = nin + nout;
+    PyArray_Descr *orig_given_descrs[NPY_MAXARGS];
+    PyArray_Descr *orig_loop_descrs[NPY_MAXARGS];
+
+    if (self->translate_given_descrs(
+            nin, nout, self->wrapped_dtypes,
+            given_descrs, orig_given_descrs) < 0) {
+        return -1;
+    }
+    NPY_CASTING casting = self->wrapped_meth->resolve_descriptors(
+            self->wrapped_meth, self->wrapped_dtypes,
+            orig_given_descrs, orig_loop_descrs, view_offset);
+    for (int i = 0; i < nargs; i++) {
+        Py_XDECREF(orig_given_descrs);
+    }
+    if (casting < 0) {
+        return -1;
+    }
+    int res = self->translate_loop_descrs(
+            nin, nout, dtypes, given_descrs, orig_loop_descrs, loop_descrs);
+    for (int i = 0; i < nargs; i++) {
+        Py_DECREF(orig_given_descrs);
+    }
+    if (res < 0) {
+        return -1;
+    }
+    return casting;
+}
+
+
+typedef struct {
+    NpyAuxData base;
+    /* Note that if context is expanded this may become trickier: */
+    PyArrayMethod_Context orig_context;
+    PyArrayMethod_StridedLoop *orig_loop;
+    NpyAuxData *orig_auxdata;
+    PyArray_Descr *descriptors[NPY_MAXARGS];
+} wrapping_auxdata;
+
+
+#define WRAPPING_AUXDATA_FREELIST_SIZE 5
+static int wrapping_auxdata_freenum = 0;
+static wrapping_auxdata *wrapping_auxdata_freelist[WRAPPING_AUXDATA_FREELIST_SIZE] = {NULL};
+
+
+static void
+wrapping_auxdata_free(wrapping_auxdata *wrapping_auxdata)
+{
+    /* Free auxdata, everything else is borrowed: */
+    NPY_AUXDATA_FREE(wrapping_auxdata->orig_auxdata);
+    wrapping_auxdata->orig_auxdata = NULL;
+
+    if (wrapping_auxdata_freenum < WRAPPING_AUXDATA_FREELIST_SIZE) {
+        wrapping_auxdata_freelist[wrapping_auxdata_freenum] = wrapping_auxdata;
+    }
+    else {
+        PyMem_Free(wrapping_auxdata);
+    }
+}
+
+
+static wrapping_auxdata *
+get_wrapping_auxdata(void)
+{
+    wrapping_auxdata *res;
+    if (wrapping_auxdata_freenum > 0) {
+        wrapping_auxdata_freenum--;
+        res = wrapping_auxdata_freelist[wrapping_auxdata_freenum];
+    }
+    else {
+        res = PyMem_Calloc(1, sizeof(wrapping_auxdata));
+        if (res < 0) {
+            PyErr_NoMemory();
+            return NULL;
+        }
+        res->base.free = (void *)wrapping_auxdata_free;
+        res->orig_context.descriptors = res->descriptors;
+    }
+
+    return res;
+}
+
+
+static int
+wrapping_method_strided_loop(PyArrayMethod_Context *NPY_UNUSED(context),
+        char *const data[], npy_intp const dimensions[],
+        npy_intp const strides[], wrapping_auxdata *auxdata)
+{
+    /*
+     * If more things get stored on the context, it could be possible that
+     * we would have to copy it here.  But currently, we do not.
+     */
+    return auxdata->orig_loop(
+            &auxdata->orig_context, data, dimensions, strides,
+            auxdata->orig_auxdata);
+}
+
+
+static int
+wrapping_method_get_loop(
+        PyArrayMethod_Context *context,
+        int aligned, int move_references, const npy_intp *strides,
+        PyArrayMethod_StridedLoop **out_loop, NpyAuxData **out_transferdata,
+        NPY_ARRAYMETHOD_FLAGS *flags)
+{
+    assert(move_references == 0);  /* only used internally for "decref" funcs */
+    int nin = context->method->nin, nout = context->method->nout;
+
+    wrapping_auxdata *auxdata = get_wrapping_auxdata();
+    if (auxdata == NULL) {
+        return -1;
+    }
+
+    auxdata->orig_context.method = context->method->wrapped_meth;
+    auxdata->orig_context.caller = context->caller;
+
+    if (context->method->translate_given_descrs(
+            nin, nout, context->method->wrapped_dtypes,
+            context->descriptors, auxdata->orig_context.descriptors) < 0) {
+        NPY_AUXDATA_FREE((NpyAuxData *)auxdata);
+        return -1;
+    }
+    if (context->method->wrapped_meth->get_strided_loop(
+            &auxdata->orig_context, aligned, 0, strides,
+            &auxdata->orig_loop, &auxdata->orig_auxdata,
+            flags) < 0) {
+        NPY_AUXDATA_FREE((NpyAuxData *)auxdata);
+        return -1;
+    }
+
+    *out_loop = (PyArrayMethod_StridedLoop *)&wrapping_method_strided_loop;
+    *out_transferdata = (NpyAuxData *)auxdata;
+    return 0;
+}
+
+
+/**
+ * Allows creating of a fairly lightweight wrapper around an existing ufunc
+ * loop.  The idea is mainly for units, as this is currently slightly limited
+ * in that it enforces that you cannot use a loop from another ufunc.
+ *
+ * @param ufunc_obj
+ * @param new_dtypes
+ * @param wrapped_dtypes
+ * @param translate_given_descrs See typedef comment
+ * @param translate_loop_descrs See typedef comment
+ * @return 0 on success -1 on failure
+ */
+NPY_NO_EXPORT int
+PyUFunc_AddWrappingLoop(PyObject *ufunc_obj,
+        PyArray_DTypeMeta *new_dtypes[], PyArray_DTypeMeta *wrapped_dtypes[],
+        translate_given_descrs_func *translate_given_descrs,
+        translate_loop_descrs_func *translate_loop_descrs)
+{
+    int res = -1;
+    PyUFuncObject *ufunc = (PyUFuncObject *)ufunc_obj;
+    PyObject *wrapped_dt_tuple = NULL;
+    PyObject *new_dt_tuple = NULL;
+    PyArrayMethodObject *meth = NULL;
+
+    if (!PyObject_TypeCheck(ufunc_obj, &PyUFunc_Type)) {
+        PyErr_SetString(PyExc_TypeError,
+                "ufunc object passed is not a ufunc!");
+        return -1;
+    }
+
+    wrapped_dt_tuple = PyArray_TupleFromItems(
+            ufunc->nargs, (PyObject **)wrapped_dtypes, 1);
+    if (wrapped_dt_tuple == NULL) {
+        goto finish;
+    }
+
+    PyArrayMethodObject *wrapped_meth = NULL;
+    PyObject *loops = ufunc->_loops;
+    Py_ssize_t length = PyList_Size(loops);
+    for (Py_ssize_t i = 0; i < length; i++) {
+        PyObject *item = PyList_GetItem(loops, i);
+        PyObject *cur_DType_tuple = PyTuple_GetItem(item, 0);
+        int cmp = PyObject_RichCompareBool(cur_DType_tuple, wrapped_dt_tuple, Py_EQ);
+        if (cmp < 0) {
+            goto finish;
+        }
+        if (cmp == 0) {
+            continue;
+        }
+        wrapped_meth = (PyArrayMethodObject *)PyTuple_GET_ITEM(item, 1);
+        if (!PyObject_TypeCheck(wrapped_meth, &PyArrayMethod_Type)) {
+            PyErr_SetString(PyExc_TypeError,
+                    "Matching loop was not an ArrayMethod.");
+            goto finish;
+        }
+        break;
+    }
+    if (wrapped_meth == NULL) {
+        PyErr_SetString(PyExc_TypeError,
+                "Did not find the to-be-wrapped loop in the ufunc.");
+        goto finish;
+    }
+
+    PyType_Slot slots[] = {
+        {NPY_METH_resolve_descriptors, &wrapping_method_resolve_descriptors},
+        {NPY_METH_get_loop, &wrapping_method_get_loop},
+        {0, NULL}
+    };
+
+    PyArrayMethod_Spec spec = {
+        .name = "wrapped-method",
+        .nin = wrapped_meth->nin,
+        .nout = wrapped_meth->nout,
+        .casting = wrapped_meth->casting,
+        .flags = wrapped_meth->flags,
+        .dtypes = new_dtypes,
+        .slots = slots,
+    };
+    PyBoundArrayMethodObject *bmeth = PyArrayMethod_FromSpec_int(&spec, 1);
+    if (bmeth == NULL) {
+        goto finish;
+    }
+
+    Py_INCREF(bmeth->method);
+    meth = bmeth->method;
+    Py_SETREF(bmeth, NULL);
+
+    /* Finalize the "wrapped" part of the new ArrayMethod */
+    meth->wrapped_dtypes = PyMem_Malloc(ufunc->nargs * sizeof(PyArray_DTypeMeta *));
+    if (meth->wrapped_dtypes == NULL) {
+        goto finish;
+    }
+
+    Py_INCREF(wrapped_meth);
+    meth->wrapped_meth = wrapped_meth;
+    meth->translate_given_descrs = translate_given_descrs;
+    meth->translate_loop_descrs = translate_loop_descrs;
+    for (int i = 0; i < ufunc->nargs; i++) {
+        Py_XINCREF(wrapped_dtypes[i]);
+        meth->wrapped_dtypes[i] = wrapped_dtypes[i];
+    }
+
+    new_dt_tuple = PyArray_TupleFromItems(
+            ufunc->nargs, (PyObject **)new_dtypes, 1);
+    if (new_dt_tuple == NULL) {
+        goto finish;
+    }
+
+    PyObject *info = PyTuple_Pack(2, new_dt_tuple, meth);
+    if (info == NULL) {
+        goto finish;
+    }
+
+    res = PyUFunc_AddLoop(ufunc, info, 0);
+    Py_DECREF(info);
+
+  finish:
+    Py_XDECREF(wrapped_dt_tuple);
+    Py_XDECREF(new_dt_tuple);
+    Py_XDECREF(meth);
+    return res;
+}
diff --git a/numpy/core/tests/_locales.py b/numpy/core/tests/_locales.py
index ce7b81f001b9..b1dc55a9b2dc 100644
--- a/numpy/core/tests/_locales.py
+++ b/numpy/core/tests/_locales.py
@@ -57,12 +57,12 @@ class CommaDecimalPointLocale:
     """
     (cur_locale, tst_locale) = find_comma_decimal_point_locale()
 
-    def setup(self):
+    def setup_method(self):
         if self.tst_locale is None:
             pytest.skip("No French locale available")
         locale.setlocale(locale.LC_NUMERIC, locale=self.tst_locale)
 
-    def teardown(self):
+    def teardown_method(self):
         locale.setlocale(locale.LC_NUMERIC, locale=self.cur_locale)
 
     def __enter__(self):
diff --git a/numpy/core/tests/data/generate_umath_validation_data.cpp b/numpy/core/tests/data/generate_umath_validation_data.cpp
index 418eae67006f..51ee12501d86 100644
--- a/numpy/core/tests/data/generate_umath_validation_data.cpp
+++ b/numpy/core/tests/data/generate_umath_validation_data.cpp
@@ -1,10 +1,10 @@
 #include 
 #include 
 #include 
-#include 
+#include 
 #include 
-#include 
-#include 
+#include 
+#include 
 #include 
 
 struct ufunc {
diff --git a/numpy/core/tests/data/umath-validation-set-exp.csv b/numpy/core/tests/data/umath-validation-set-exp.csv
index 7c5ef3b334fb..071fb312932f 100644
--- a/numpy/core/tests/data/umath-validation-set-exp.csv
+++ b/numpy/core/tests/data/umath-validation-set-exp.csv
@@ -135,278 +135,278 @@ np.float32,0xc2867878,0x0effff15,3
 np.float32,0xc2a2324a,0x04fffff4,3
 #float64
 ## near zero ##
-np.float64,0x8000000000000000,0x3ff0000000000000,1
-np.float64,0x8010000000000000,0x3ff0000000000000,1
-np.float64,0x8000000000000001,0x3ff0000000000000,1
-np.float64,0x8360000000000000,0x3ff0000000000000,1
-np.float64,0x9a70000000000000,0x3ff0000000000000,1
-np.float64,0xb9b0000000000000,0x3ff0000000000000,1
-np.float64,0xb810000000000000,0x3ff0000000000000,1
-np.float64,0xbc30000000000000,0x3ff0000000000000,1
-np.float64,0xb6a0000000000000,0x3ff0000000000000,1
-np.float64,0x0000000000000000,0x3ff0000000000000,1
-np.float64,0x0010000000000000,0x3ff0000000000000,1
-np.float64,0x0000000000000001,0x3ff0000000000000,1
-np.float64,0x0360000000000000,0x3ff0000000000000,1
-np.float64,0x1a70000000000000,0x3ff0000000000000,1
-np.float64,0x3c30000000000000,0x3ff0000000000000,1
-np.float64,0x36a0000000000000,0x3ff0000000000000,1
-np.float64,0x39b0000000000000,0x3ff0000000000000,1
-np.float64,0x3810000000000000,0x3ff0000000000000,1
+np.float64,0x8000000000000000,0x3ff0000000000000,2
+np.float64,0x8010000000000000,0x3ff0000000000000,2
+np.float64,0x8000000000000001,0x3ff0000000000000,2
+np.float64,0x8360000000000000,0x3ff0000000000000,2
+np.float64,0x9a70000000000000,0x3ff0000000000000,2
+np.float64,0xb9b0000000000000,0x3ff0000000000000,2
+np.float64,0xb810000000000000,0x3ff0000000000000,2
+np.float64,0xbc30000000000000,0x3ff0000000000000,2
+np.float64,0xb6a0000000000000,0x3ff0000000000000,2
+np.float64,0x0000000000000000,0x3ff0000000000000,2
+np.float64,0x0010000000000000,0x3ff0000000000000,2
+np.float64,0x0000000000000001,0x3ff0000000000000,2
+np.float64,0x0360000000000000,0x3ff0000000000000,2
+np.float64,0x1a70000000000000,0x3ff0000000000000,2
+np.float64,0x3c30000000000000,0x3ff0000000000000,2
+np.float64,0x36a0000000000000,0x3ff0000000000000,2
+np.float64,0x39b0000000000000,0x3ff0000000000000,2
+np.float64,0x3810000000000000,0x3ff0000000000000,2
 ## underflow ##
-np.float64,0xc0c6276800000000,0x0000000000000000,1
-np.float64,0xc0c62d918ce2421d,0x0000000000000000,1
-np.float64,0xc0c62d918ce2421e,0x0000000000000000,1
-np.float64,0xc0c62d91a0000000,0x0000000000000000,1
-np.float64,0xc0c62d9180000000,0x0000000000000000,1
-np.float64,0xc0c62dea45ee3e06,0x0000000000000000,1
-np.float64,0xc0c62dea45ee3e07,0x0000000000000000,1
-np.float64,0xc0c62dea40000000,0x0000000000000000,1
-np.float64,0xc0c62dea60000000,0x0000000000000000,1
-np.float64,0xc0875f1120000000,0x0000000000000000,1
-np.float64,0xc0875f113c30b1c8,0x0000000000000000,1
-np.float64,0xc0875f1140000000,0x0000000000000000,1
-np.float64,0xc093480000000000,0x0000000000000000,1
-np.float64,0xffefffffffffffff,0x0000000000000000,1
-np.float64,0xc7efffffe0000000,0x0000000000000000,1
+np.float64,0xc0c6276800000000,0x0000000000000000,2
+np.float64,0xc0c62d918ce2421d,0x0000000000000000,2
+np.float64,0xc0c62d918ce2421e,0x0000000000000000,2
+np.float64,0xc0c62d91a0000000,0x0000000000000000,2
+np.float64,0xc0c62d9180000000,0x0000000000000000,2
+np.float64,0xc0c62dea45ee3e06,0x0000000000000000,2
+np.float64,0xc0c62dea45ee3e07,0x0000000000000000,2
+np.float64,0xc0c62dea40000000,0x0000000000000000,2
+np.float64,0xc0c62dea60000000,0x0000000000000000,2
+np.float64,0xc0875f1120000000,0x0000000000000000,2
+np.float64,0xc0875f113c30b1c8,0x0000000000000000,2
+np.float64,0xc0875f1140000000,0x0000000000000000,2
+np.float64,0xc093480000000000,0x0000000000000000,2
+np.float64,0xffefffffffffffff,0x0000000000000000,2
+np.float64,0xc7efffffe0000000,0x0000000000000000,2
 ## overflow ##
-np.float64,0x40862e52fefa39ef,0x7ff0000000000000,1
-np.float64,0x40872e42fefa39ef,0x7ff0000000000000,1
+np.float64,0x40862e52fefa39ef,0x7ff0000000000000,2
+np.float64,0x40872e42fefa39ef,0x7ff0000000000000,2
 ## +/- INF, +/- NAN ##
-np.float64,0x7ff0000000000000,0x7ff0000000000000,1
-np.float64,0xfff0000000000000,0x0000000000000000,1
-np.float64,0x7ff8000000000000,0x7ff8000000000000,1
-np.float64,0xfff8000000000000,0xfff8000000000000,1
+np.float64,0x7ff0000000000000,0x7ff0000000000000,2
+np.float64,0xfff0000000000000,0x0000000000000000,2
+np.float64,0x7ff8000000000000,0x7ff8000000000000,2
+np.float64,0xfff8000000000000,0xfff8000000000000,2
 ## output denormal ##
-np.float64,0xc087438520000000,0x0000000000000001,1
-np.float64,0xc08743853f2f4461,0x0000000000000001,1
-np.float64,0xc08743853f2f4460,0x0000000000000001,1
-np.float64,0xc087438540000000,0x0000000000000001,1
+np.float64,0xc087438520000000,0x0000000000000001,2
+np.float64,0xc08743853f2f4461,0x0000000000000001,2
+np.float64,0xc08743853f2f4460,0x0000000000000001,2
+np.float64,0xc087438540000000,0x0000000000000001,2
 ## between -745.13321910 and 709.78271289 ##
-np.float64,0xbff760cd14774bd9,0x3fcdb14ced00ceb6,1
-np.float64,0xbff760cd20000000,0x3fcdb14cd7993879,1
-np.float64,0xbff760cd00000000,0x3fcdb14d12fbd264,1
-np.float64,0xc07f1cf360000000,0x130c1b369af14fda,1
-np.float64,0xbeb0000000000000,0x3feffffe00001000,1
-np.float64,0xbd70000000000000,0x3fefffffffffe000,1
-np.float64,0xc084fd46e5c84952,0x0360000000000139,1
-np.float64,0xc084fd46e5c84953,0x035ffffffffffe71,1
-np.float64,0xc084fd46e0000000,0x0360000b9096d32c,1
-np.float64,0xc084fd4700000000,0x035fff9721d12104,1
-np.float64,0xc086232bc0000000,0x0010003af5e64635,1
-np.float64,0xc086232bdd7abcd2,0x001000000000007c,1
-np.float64,0xc086232bdd7abcd3,0x000ffffffffffe7c,1
-np.float64,0xc086232be0000000,0x000ffffaf57a6fc9,1
-np.float64,0xc086233920000000,0x000fe590e3b45eb0,1
-np.float64,0xc086233938000000,0x000fe56133493c57,1
-np.float64,0xc086233940000000,0x000fe5514deffbbc,1
-np.float64,0xc086234c98000000,0x000fbf1024c32ccb,1
-np.float64,0xc086234ca0000000,0x000fbf0065bae78d,1
-np.float64,0xc086234c80000000,0x000fbf3f623a7724,1
-np.float64,0xc086234ec0000000,0x000fbad237c846f9,1
-np.float64,0xc086234ec8000000,0x000fbac27cfdec97,1
-np.float64,0xc086234ee0000000,0x000fba934cfd3dc2,1
-np.float64,0xc086234ef0000000,0x000fba73d7f618d9,1
-np.float64,0xc086234f00000000,0x000fba54632dddc0,1
-np.float64,0xc0862356e0000000,0x000faae0945b761a,1
-np.float64,0xc0862356f0000000,0x000faac13eb9a310,1
-np.float64,0xc086235700000000,0x000faaa1e9567b0a,1
-np.float64,0xc086236020000000,0x000f98cd75c11ed7,1
-np.float64,0xc086236ca0000000,0x000f8081b4d93f89,1
-np.float64,0xc086236cb0000000,0x000f8062b3f4d6c5,1
-np.float64,0xc086236cc0000000,0x000f8043b34e6f8c,1
-np.float64,0xc086238d98000000,0x000f41220d9b0d2c,1
-np.float64,0xc086238da0000000,0x000f4112cc80a01f,1
-np.float64,0xc086238d80000000,0x000f414fd145db5b,1
-np.float64,0xc08624fd00000000,0x000cbfce8ea1e6c4,1
-np.float64,0xc086256080000000,0x000c250747fcd46e,1
-np.float64,0xc08626c480000000,0x000a34f4bd975193,1
-np.float64,0xbf50000000000000,0x3feff800ffeaac00,1
-np.float64,0xbe10000000000000,0x3fefffffff800000,1
-np.float64,0xbcd0000000000000,0x3feffffffffffff8,1
-np.float64,0xc055d589e0000000,0x38100004bf94f63e,1
-np.float64,0xc055d58a00000000,0x380ffff97f292ce8,1
-np.float64,0xbfd962d900000000,0x3fe585a4b00110e1,1
-np.float64,0x3ff4bed280000000,0x400d411e7a58a303,1
-np.float64,0x3fff0b3620000000,0x401bd7737ffffcf3,1
-np.float64,0x3ff0000000000000,0x4005bf0a8b145769,1
-np.float64,0x3eb0000000000000,0x3ff0000100000800,1
-np.float64,0x3d70000000000000,0x3ff0000000001000,1
-np.float64,0x40862e42e0000000,0x7fefff841808287f,1
-np.float64,0x40862e42fefa39ef,0x7fefffffffffff2a,1
-np.float64,0x40862e0000000000,0x7feef85a11e73f2d,1
-np.float64,0x4000000000000000,0x401d8e64b8d4ddae,1
-np.float64,0x4009242920000000,0x40372a52c383a488,1
-np.float64,0x4049000000000000,0x44719103e4080b45,1
-np.float64,0x4008000000000000,0x403415e5bf6fb106,1
-np.float64,0x3f50000000000000,0x3ff00400800aab55,1
-np.float64,0x3e10000000000000,0x3ff0000000400000,1
-np.float64,0x3cd0000000000000,0x3ff0000000000004,1
-np.float64,0x40562e40a0000000,0x47effed088821c3f,1
-np.float64,0x40562e42e0000000,0x47effff082e6c7ff,1
-np.float64,0x40562e4300000000,0x47f00000417184b8,1
-np.float64,0x3fe8000000000000,0x4000ef9db467dcf8,1
-np.float64,0x402b12e8d4f33589,0x412718f68c71a6fe,1
-np.float64,0x402b12e8d4f3358a,0x412718f68c71a70a,1
-np.float64,0x402b12e8c0000000,0x412718f59a7f472e,1
-np.float64,0x402b12e8e0000000,0x412718f70c0eac62,1
+np.float64,0xbff760cd14774bd9,0x3fcdb14ced00ceb6,2
+np.float64,0xbff760cd20000000,0x3fcdb14cd7993879,2
+np.float64,0xbff760cd00000000,0x3fcdb14d12fbd264,2
+np.float64,0xc07f1cf360000000,0x130c1b369af14fda,2
+np.float64,0xbeb0000000000000,0x3feffffe00001000,2
+np.float64,0xbd70000000000000,0x3fefffffffffe000,2
+np.float64,0xc084fd46e5c84952,0x0360000000000139,2
+np.float64,0xc084fd46e5c84953,0x035ffffffffffe71,2
+np.float64,0xc084fd46e0000000,0x0360000b9096d32c,2
+np.float64,0xc084fd4700000000,0x035fff9721d12104,2
+np.float64,0xc086232bc0000000,0x0010003af5e64635,2
+np.float64,0xc086232bdd7abcd2,0x001000000000007c,2
+np.float64,0xc086232bdd7abcd3,0x000ffffffffffe7c,2
+np.float64,0xc086232be0000000,0x000ffffaf57a6fc9,2
+np.float64,0xc086233920000000,0x000fe590e3b45eb0,2
+np.float64,0xc086233938000000,0x000fe56133493c57,2
+np.float64,0xc086233940000000,0x000fe5514deffbbc,2
+np.float64,0xc086234c98000000,0x000fbf1024c32ccb,2
+np.float64,0xc086234ca0000000,0x000fbf0065bae78d,2
+np.float64,0xc086234c80000000,0x000fbf3f623a7724,2
+np.float64,0xc086234ec0000000,0x000fbad237c846f9,2
+np.float64,0xc086234ec8000000,0x000fbac27cfdec97,2
+np.float64,0xc086234ee0000000,0x000fba934cfd3dc2,2
+np.float64,0xc086234ef0000000,0x000fba73d7f618d9,2
+np.float64,0xc086234f00000000,0x000fba54632dddc0,2
+np.float64,0xc0862356e0000000,0x000faae0945b761a,2
+np.float64,0xc0862356f0000000,0x000faac13eb9a310,2
+np.float64,0xc086235700000000,0x000faaa1e9567b0a,2
+np.float64,0xc086236020000000,0x000f98cd75c11ed7,2
+np.float64,0xc086236ca0000000,0x000f8081b4d93f89,2
+np.float64,0xc086236cb0000000,0x000f8062b3f4d6c5,2
+np.float64,0xc086236cc0000000,0x000f8043b34e6f8c,2
+np.float64,0xc086238d98000000,0x000f41220d9b0d2c,2
+np.float64,0xc086238da0000000,0x000f4112cc80a01f,2
+np.float64,0xc086238d80000000,0x000f414fd145db5b,2
+np.float64,0xc08624fd00000000,0x000cbfce8ea1e6c4,2
+np.float64,0xc086256080000000,0x000c250747fcd46e,2
+np.float64,0xc08626c480000000,0x000a34f4bd975193,2
+np.float64,0xbf50000000000000,0x3feff800ffeaac00,2
+np.float64,0xbe10000000000000,0x3fefffffff800000,2
+np.float64,0xbcd0000000000000,0x3feffffffffffff8,2
+np.float64,0xc055d589e0000000,0x38100004bf94f63e,2
+np.float64,0xc055d58a00000000,0x380ffff97f292ce8,2
+np.float64,0xbfd962d900000000,0x3fe585a4b00110e1,2
+np.float64,0x3ff4bed280000000,0x400d411e7a58a303,2
+np.float64,0x3fff0b3620000000,0x401bd7737ffffcf3,2
+np.float64,0x3ff0000000000000,0x4005bf0a8b145769,2
+np.float64,0x3eb0000000000000,0x3ff0000100000800,2
+np.float64,0x3d70000000000000,0x3ff0000000001000,2
+np.float64,0x40862e42e0000000,0x7fefff841808287f,2
+np.float64,0x40862e42fefa39ef,0x7fefffffffffff2a,2
+np.float64,0x40862e0000000000,0x7feef85a11e73f2d,2
+np.float64,0x4000000000000000,0x401d8e64b8d4ddae,2
+np.float64,0x4009242920000000,0x40372a52c383a488,2
+np.float64,0x4049000000000000,0x44719103e4080b45,2
+np.float64,0x4008000000000000,0x403415e5bf6fb106,2
+np.float64,0x3f50000000000000,0x3ff00400800aab55,2
+np.float64,0x3e10000000000000,0x3ff0000000400000,2
+np.float64,0x3cd0000000000000,0x3ff0000000000004,2
+np.float64,0x40562e40a0000000,0x47effed088821c3f,2
+np.float64,0x40562e42e0000000,0x47effff082e6c7ff,2
+np.float64,0x40562e4300000000,0x47f00000417184b8,2
+np.float64,0x3fe8000000000000,0x4000ef9db467dcf8,2
+np.float64,0x402b12e8d4f33589,0x412718f68c71a6fe,2
+np.float64,0x402b12e8d4f3358a,0x412718f68c71a70a,2
+np.float64,0x402b12e8c0000000,0x412718f59a7f472e,2
+np.float64,0x402b12e8e0000000,0x412718f70c0eac62,2
 ##use 1th entry
-np.float64,0x40631659AE147CB4,0x4db3a95025a4890f,1
-np.float64,0xC061B87D2E85A4E2,0x332640c8e2de2c51,1
-np.float64,0x405A4A50BE243AF4,0x496a45e4b7f0339a,1
-np.float64,0xC0839898B98EC5C6,0x0764027828830df4,1
+np.float64,0x40631659AE147CB4,0x4db3a95025a4890f,2
+np.float64,0xC061B87D2E85A4E2,0x332640c8e2de2c51,2
+np.float64,0x405A4A50BE243AF4,0x496a45e4b7f0339a,2
+np.float64,0xC0839898B98EC5C6,0x0764027828830df4,2
 #use 2th entry
-np.float64,0xC072428C44B6537C,0x2596ade838b96f3e,1
-np.float64,0xC053057C5E1AE9BF,0x3912c8fad18fdadf,1
-np.float64,0x407E89C78328BAA3,0x6bfe35d5b9a1a194,1
-np.float64,0x4083501B6DD87112,0x77a855503a38924e,1
+np.float64,0xC072428C44B6537C,0x2596ade838b96f3e,2
+np.float64,0xC053057C5E1AE9BF,0x3912c8fad18fdadf,2
+np.float64,0x407E89C78328BAA3,0x6bfe35d5b9a1a194,2
+np.float64,0x4083501B6DD87112,0x77a855503a38924e,2
 #use 3th entry
-np.float64,0x40832C6195F24540,0x7741e73c80e5eb2f,1
-np.float64,0xC083D4CD557C2EC9,0x06b61727c2d2508e,1
-np.float64,0x400C48F5F67C99BD,0x404128820f02b92e,1
-np.float64,0x4056E36D9B2DF26A,0x4830f52ff34a8242,1
+np.float64,0x40832C6195F24540,0x7741e73c80e5eb2f,2
+np.float64,0xC083D4CD557C2EC9,0x06b61727c2d2508e,2
+np.float64,0x400C48F5F67C99BD,0x404128820f02b92e,2
+np.float64,0x4056E36D9B2DF26A,0x4830f52ff34a8242,2
 #use 4th entry
-np.float64,0x4080FF700D8CBD06,0x70fa70df9bc30f20,1
-np.float64,0x406C276D39E53328,0x543eb8e20a8f4741,1
-np.float64,0xC070D6159BBD8716,0x27a4a0548c904a75,1
-np.float64,0xC052EBCF8ED61F83,0x391c0e92368d15e4,1
+np.float64,0x4080FF700D8CBD06,0x70fa70df9bc30f20,2
+np.float64,0x406C276D39E53328,0x543eb8e20a8f4741,2
+np.float64,0xC070D6159BBD8716,0x27a4a0548c904a75,2
+np.float64,0xC052EBCF8ED61F83,0x391c0e92368d15e4,2
 #use 5th entry
-np.float64,0xC061F892A8AC5FBE,0x32f807a89efd3869,1
-np.float64,0x4021D885D2DBA085,0x40bd4dc86d3e3270,1
-np.float64,0x40767AEEEE7D4FCF,0x605e22851ee2afb7,1
-np.float64,0xC0757C5D75D08C80,0x20f0751599b992a2,1
+np.float64,0xC061F892A8AC5FBE,0x32f807a89efd3869,2
+np.float64,0x4021D885D2DBA085,0x40bd4dc86d3e3270,2
+np.float64,0x40767AEEEE7D4FCF,0x605e22851ee2afb7,2
+np.float64,0xC0757C5D75D08C80,0x20f0751599b992a2,2
 #use 6th entry
-np.float64,0x405ACF7A284C4CE3,0x499a4e0b7a27027c,1
-np.float64,0xC085A6C9E80D7AF5,0x0175914009d62ec2,1
-np.float64,0xC07E4C02F86F1DAE,0x1439269b29a9231e,1
-np.float64,0x4080D80F9691CC87,0x7088a6cdafb041de,1
+np.float64,0x405ACF7A284C4CE3,0x499a4e0b7a27027c,2
+np.float64,0xC085A6C9E80D7AF5,0x0175914009d62ec2,2
+np.float64,0xC07E4C02F86F1DAE,0x1439269b29a9231e,2
+np.float64,0x4080D80F9691CC87,0x7088a6cdafb041de,2
 #use 7th entry
-np.float64,0x407FDFD84FBA0AC1,0x6deb1ae6f9bc4767,1
-np.float64,0x40630C06A1A2213D,0x4dac7a9d51a838b7,1
-np.float64,0x40685FDB30BB8B4F,0x5183f5cc2cac9e79,1
-np.float64,0x408045A2208F77F4,0x6ee299e08e2aa2f0,1
+np.float64,0x407FDFD84FBA0AC1,0x6deb1ae6f9bc4767,2
+np.float64,0x40630C06A1A2213D,0x4dac7a9d51a838b7,2
+np.float64,0x40685FDB30BB8B4F,0x5183f5cc2cac9e79,2
+np.float64,0x408045A2208F77F4,0x6ee299e08e2aa2f0,2
 #use 8th entry
-np.float64,0xC08104E391F5078B,0x0ed397b7cbfbd230,1
-np.float64,0xC031501CAEFAE395,0x3e6040fd1ea35085,1
-np.float64,0xC079229124F6247C,0x1babf4f923306b1e,1
-np.float64,0x407FB65F44600435,0x6db03beaf2512b8a,1
+np.float64,0xC08104E391F5078B,0x0ed397b7cbfbd230,2
+np.float64,0xC031501CAEFAE395,0x3e6040fd1ea35085,2
+np.float64,0xC079229124F6247C,0x1babf4f923306b1e,2
+np.float64,0x407FB65F44600435,0x6db03beaf2512b8a,2
 #use 9th entry
-np.float64,0xC07EDEE8E8E8A5AC,0x136536cec9cbef48,1
-np.float64,0x4072BB4086099A14,0x5af4d3c3008b56cc,1
-np.float64,0x4050442A2EC42CB4,0x45cd393bd8fad357,1
-np.float64,0xC06AC28FB3D419B4,0x2ca1b9d3437df85f,1
+np.float64,0xC07EDEE8E8E8A5AC,0x136536cec9cbef48,2
+np.float64,0x4072BB4086099A14,0x5af4d3c3008b56cc,2
+np.float64,0x4050442A2EC42CB4,0x45cd393bd8fad357,2
+np.float64,0xC06AC28FB3D419B4,0x2ca1b9d3437df85f,2
 #use 10th entry
-np.float64,0x40567FC6F0A68076,0x480c977fd5f3122e,1
-np.float64,0x40620A2F7EDA59BB,0x4cf278e96f4ce4d7,1
-np.float64,0xC085044707CD557C,0x034aad6c968a045a,1
-np.float64,0xC07374EA5AC516AA,0x23dd6afdc03e83d5,1
+np.float64,0x40567FC6F0A68076,0x480c977fd5f3122e,2
+np.float64,0x40620A2F7EDA59BB,0x4cf278e96f4ce4d7,2
+np.float64,0xC085044707CD557C,0x034aad6c968a045a,2
+np.float64,0xC07374EA5AC516AA,0x23dd6afdc03e83d5,2
 #use 11th entry
-np.float64,0x4073CC95332619C1,0x5c804b1498bbaa54,1
-np.float64,0xC0799FEBBE257F31,0x1af6a954c43b87d2,1
-np.float64,0x408159F19EA424F6,0x7200858efcbfc84d,1
-np.float64,0x404A81F6F24C0792,0x44b664a07ce5bbfa,1
+np.float64,0x4073CC95332619C1,0x5c804b1498bbaa54,2
+np.float64,0xC0799FEBBE257F31,0x1af6a954c43b87d2,2
+np.float64,0x408159F19EA424F6,0x7200858efcbfc84d,2
+np.float64,0x404A81F6F24C0792,0x44b664a07ce5bbfa,2
 #use 12th entry
-np.float64,0x40295FF1EFB9A741,0x4113c0e74c52d7b0,1
-np.float64,0x4073975F4CC411DA,0x5c32be40b4fec2c1,1
-np.float64,0x406E9DE52E82A77E,0x56049c9a3f1ae089,1
-np.float64,0x40748C2F52560ED9,0x5d93bc14fd4cd23b,1
+np.float64,0x40295FF1EFB9A741,0x4113c0e74c52d7b0,2
+np.float64,0x4073975F4CC411DA,0x5c32be40b4fec2c1,2
+np.float64,0x406E9DE52E82A77E,0x56049c9a3f1ae089,2
+np.float64,0x40748C2F52560ED9,0x5d93bc14fd4cd23b,2
 #use 13th entry
-np.float64,0x4062A553CDC4D04C,0x4d6266bfde301318,1
-np.float64,0xC079EC1D63598AB7,0x1a88cb184dab224c,1
-np.float64,0xC0725C1CB3167427,0x25725b46f8a081f6,1
-np.float64,0x407888771D9B45F9,0x6353b1ec6bd7ce80,1
+np.float64,0x4062A553CDC4D04C,0x4d6266bfde301318,2
+np.float64,0xC079EC1D63598AB7,0x1a88cb184dab224c,2
+np.float64,0xC0725C1CB3167427,0x25725b46f8a081f6,2
+np.float64,0x407888771D9B45F9,0x6353b1ec6bd7ce80,2
 #use 14th entry
-np.float64,0xC082CBA03AA89807,0x09b383723831ce56,1
-np.float64,0xC083A8961BB67DD7,0x0735b118d5275552,1
-np.float64,0xC076BC6ECA12E7E3,0x1f2222679eaef615,1
-np.float64,0xC072752503AA1A5B,0x254eb832242c77e1,1
+np.float64,0xC082CBA03AA89807,0x09b383723831ce56,2
+np.float64,0xC083A8961BB67DD7,0x0735b118d5275552,2
+np.float64,0xC076BC6ECA12E7E3,0x1f2222679eaef615,2
+np.float64,0xC072752503AA1A5B,0x254eb832242c77e1,2
 #use 15th entry
-np.float64,0xC058800792125DEC,0x371882372a0b48d4,1
-np.float64,0x4082909FD863E81C,0x7580d5f386920142,1
-np.float64,0xC071616F8FB534F9,0x26dbe20ef64a412b,1
-np.float64,0x406D1AB571CAA747,0x54ee0d55cb38ac20,1
+np.float64,0xC058800792125DEC,0x371882372a0b48d4,2
+np.float64,0x4082909FD863E81C,0x7580d5f386920142,2
+np.float64,0xC071616F8FB534F9,0x26dbe20ef64a412b,2
+np.float64,0x406D1AB571CAA747,0x54ee0d55cb38ac20,2
 #use 16th entry
-np.float64,0x406956428B7DAD09,0x52358682c271237f,1
-np.float64,0xC07EFC2D9D17B621,0x133b3e77c27a4d45,1
-np.float64,0xC08469BAC5BA3CCA,0x050863e5f42cc52f,1
-np.float64,0x407189D9626386A5,0x593cb1c0b3b5c1d3,1
+np.float64,0x406956428B7DAD09,0x52358682c271237f,2
+np.float64,0xC07EFC2D9D17B621,0x133b3e77c27a4d45,2
+np.float64,0xC08469BAC5BA3CCA,0x050863e5f42cc52f,2
+np.float64,0x407189D9626386A5,0x593cb1c0b3b5c1d3,2
 #use 17th entry
-np.float64,0x4077E652E3DEB8C6,0x6269a10dcbd3c752,1
-np.float64,0x407674C97DB06878,0x605485dcc2426ec2,1
-np.float64,0xC07CE9969CF4268D,0x16386cf8996669f2,1
-np.float64,0x40780EE32D5847C4,0x62a436bd1abe108d,1
+np.float64,0x4077E652E3DEB8C6,0x6269a10dcbd3c752,2
+np.float64,0x407674C97DB06878,0x605485dcc2426ec2,2
+np.float64,0xC07CE9969CF4268D,0x16386cf8996669f2,2
+np.float64,0x40780EE32D5847C4,0x62a436bd1abe108d,2
 #use 18th entry
-np.float64,0x4076C3AA5E1E8DA1,0x60c62f56a5e72e24,1
-np.float64,0xC0730AFC7239B9BE,0x24758ead095cec1e,1
-np.float64,0xC085CC2B9C420DDB,0x0109cdaa2e5694c1,1
-np.float64,0x406D0765CB6D7AA4,0x54e06f8dd91bd945,1
+np.float64,0x4076C3AA5E1E8DA1,0x60c62f56a5e72e24,2
+np.float64,0xC0730AFC7239B9BE,0x24758ead095cec1e,2
+np.float64,0xC085CC2B9C420DDB,0x0109cdaa2e5694c1,2
+np.float64,0x406D0765CB6D7AA4,0x54e06f8dd91bd945,2
 #use 19th entry
-np.float64,0xC082D011F3B495E7,0x09a6647661d279c2,1
-np.float64,0xC072826AF8F6AFBC,0x253acd3cd224507e,1
-np.float64,0x404EB9C4810CEA09,0x457933dbf07e8133,1
-np.float64,0x408284FBC97C58CE,0x755f6eb234aa4b98,1
+np.float64,0xC082D011F3B495E7,0x09a6647661d279c2,2
+np.float64,0xC072826AF8F6AFBC,0x253acd3cd224507e,2
+np.float64,0x404EB9C4810CEA09,0x457933dbf07e8133,2
+np.float64,0x408284FBC97C58CE,0x755f6eb234aa4b98,2
 #use 20th entry
-np.float64,0x40856008CF6EDC63,0x7d9c0b3c03f4f73c,1
-np.float64,0xC077CB2E9F013B17,0x1d9b3d3a166a55db,1
-np.float64,0xC0479CA3C20AD057,0x3bad40e081555b99,1
-np.float64,0x40844CD31107332A,0x7a821d70aea478e2,1
+np.float64,0x40856008CF6EDC63,0x7d9c0b3c03f4f73c,2
+np.float64,0xC077CB2E9F013B17,0x1d9b3d3a166a55db,2
+np.float64,0xC0479CA3C20AD057,0x3bad40e081555b99,2
+np.float64,0x40844CD31107332A,0x7a821d70aea478e2,2
 #use 21th entry
-np.float64,0xC07C8FCC0BFCC844,0x16ba1cc8c539d19b,1
-np.float64,0xC085C4E9A3ABA488,0x011ff675ba1a2217,1
-np.float64,0x4074D538B32966E5,0x5dfd9d78043c6ad9,1
-np.float64,0xC0630CA16902AD46,0x3231a446074cede6,1
+np.float64,0xC07C8FCC0BFCC844,0x16ba1cc8c539d19b,2
+np.float64,0xC085C4E9A3ABA488,0x011ff675ba1a2217,2
+np.float64,0x4074D538B32966E5,0x5dfd9d78043c6ad9,2
+np.float64,0xC0630CA16902AD46,0x3231a446074cede6,2
 #use 22th entry
-np.float64,0xC06C826733D7D0B7,0x2b5f1078314d41e1,1
-np.float64,0xC0520DF55B2B907F,0x396c13a6ce8e833e,1
-np.float64,0xC080712072B0F437,0x107eae02d11d98ea,1
-np.float64,0x40528A6150E19EFB,0x469fdabda02228c5,1
+np.float64,0xC06C826733D7D0B7,0x2b5f1078314d41e1,2
+np.float64,0xC0520DF55B2B907F,0x396c13a6ce8e833e,2
+np.float64,0xC080712072B0F437,0x107eae02d11d98ea,2
+np.float64,0x40528A6150E19EFB,0x469fdabda02228c5,2
 #use 23th entry
-np.float64,0xC07B1D74B6586451,0x18d1253883ae3b48,1
-np.float64,0x4045AFD7867DAEC0,0x43d7d634fc4c5d98,1
-np.float64,0xC07A08B91F9ED3E2,0x1a60973e6397fc37,1
-np.float64,0x407B3ECF0AE21C8C,0x673e03e9d98d7235,1
+np.float64,0xC07B1D74B6586451,0x18d1253883ae3b48,2
+np.float64,0x4045AFD7867DAEC0,0x43d7d634fc4c5d98,2
+np.float64,0xC07A08B91F9ED3E2,0x1a60973e6397fc37,2
+np.float64,0x407B3ECF0AE21C8C,0x673e03e9d98d7235,2
 #use 24th entry
-np.float64,0xC078AEB6F30CEABF,0x1c530b93ab54a1b3,1
-np.float64,0x4084495006A41672,0x7a775b6dc7e63064,1
-np.float64,0x40830B1C0EBF95DD,0x76e1e6eed77cfb89,1
-np.float64,0x407D93E8F33D8470,0x6a9adbc9e1e4f1e5,1
+np.float64,0xC078AEB6F30CEABF,0x1c530b93ab54a1b3,2
+np.float64,0x4084495006A41672,0x7a775b6dc7e63064,2
+np.float64,0x40830B1C0EBF95DD,0x76e1e6eed77cfb89,2
+np.float64,0x407D93E8F33D8470,0x6a9adbc9e1e4f1e5,2
 #use 25th entry
-np.float64,0x4066B11A09EFD9E8,0x504dd528065c28a7,1
-np.float64,0x408545823723AEEB,0x7d504a9b1844f594,1
-np.float64,0xC068C711F2CA3362,0x2e104f3496ea118e,1
-np.float64,0x407F317FCC3CA873,0x6cf0732c9948ebf4,1
+np.float64,0x4066B11A09EFD9E8,0x504dd528065c28a7,2
+np.float64,0x408545823723AEEB,0x7d504a9b1844f594,2
+np.float64,0xC068C711F2CA3362,0x2e104f3496ea118e,2
+np.float64,0x407F317FCC3CA873,0x6cf0732c9948ebf4,2
 #use 26th entry
-np.float64,0x407AFB3EBA2ED50F,0x66dc28a129c868d5,1
-np.float64,0xC075377037708ADE,0x21531a329f3d793e,1
-np.float64,0xC07C30066A1F3246,0x174448baa16ded2b,1
-np.float64,0xC06689A75DE2ABD3,0x2fad70662fae230b,1
+np.float64,0x407AFB3EBA2ED50F,0x66dc28a129c868d5,2
+np.float64,0xC075377037708ADE,0x21531a329f3d793e,2
+np.float64,0xC07C30066A1F3246,0x174448baa16ded2b,2
+np.float64,0xC06689A75DE2ABD3,0x2fad70662fae230b,2
 #use 27th entry
-np.float64,0x4081514E9FCCF1E0,0x71e673b9efd15f44,1
-np.float64,0xC0762C710AF68460,0x1ff1ed7d8947fe43,1
-np.float64,0xC0468102FF70D9C4,0x3be0c3a8ff3419a3,1
-np.float64,0xC07EA4CEEF02A83E,0x13b908f085102c61,1
+np.float64,0x4081514E9FCCF1E0,0x71e673b9efd15f44,2
+np.float64,0xC0762C710AF68460,0x1ff1ed7d8947fe43,2
+np.float64,0xC0468102FF70D9C4,0x3be0c3a8ff3419a3,2
+np.float64,0xC07EA4CEEF02A83E,0x13b908f085102c61,2
 #use 28th entry
-np.float64,0xC06290B04AE823C4,0x328a83da3c2e3351,1
-np.float64,0xC0770EB1D1C395FB,0x1eab281c1f1db5fe,1
-np.float64,0xC06F5D4D838A5BAE,0x29500ea32fb474ea,1
-np.float64,0x40723B3133B54C5D,0x5a3c82c7c3a2b848,1
+np.float64,0xC06290B04AE823C4,0x328a83da3c2e3351,2
+np.float64,0xC0770EB1D1C395FB,0x1eab281c1f1db5fe,2
+np.float64,0xC06F5D4D838A5BAE,0x29500ea32fb474ea,2
+np.float64,0x40723B3133B54C5D,0x5a3c82c7c3a2b848,2
 #use 29th entry
-np.float64,0x4085E6454CE3B4AA,0x7f20319b9638d06a,1
-np.float64,0x408389F2A0585D4B,0x7850667c58aab3d0,1
-np.float64,0xC0382798F9C8AE69,0x3dc1c79fe8739d6d,1
-np.float64,0xC08299D827608418,0x0a4335f76cdbaeb5,1
+np.float64,0x4085E6454CE3B4AA,0x7f20319b9638d06a,2
+np.float64,0x408389F2A0585D4B,0x7850667c58aab3d0,2
+np.float64,0xC0382798F9C8AE69,0x3dc1c79fe8739d6d,2
+np.float64,0xC08299D827608418,0x0a4335f76cdbaeb5,2
 #use 30th entry
-np.float64,0xC06F3DED43301BF1,0x2965670ae46750a8,1
-np.float64,0xC070CAF6BDD577D9,0x27b4aa4ffdd29981,1
-np.float64,0x4078529AD4B2D9F2,0x6305c12755d5e0a6,1
-np.float64,0xC055B14E75A31B96,0x381c2eda6d111e5d,1
+np.float64,0xC06F3DED43301BF1,0x2965670ae46750a8,2
+np.float64,0xC070CAF6BDD577D9,0x27b4aa4ffdd29981,2
+np.float64,0x4078529AD4B2D9F2,0x6305c12755d5e0a6,2
+np.float64,0xC055B14E75A31B96,0x381c2eda6d111e5d,2
 #use 31th entry
-np.float64,0x407B13EE414FA931,0x6700772c7544564d,1
-np.float64,0x407EAFDE9DE3EC54,0x6c346a0e49724a3c,1
-np.float64,0xC08362F398B9530D,0x07ffeddbadf980cb,1
-np.float64,0x407E865CDD9EEB86,0x6bf866cac5e0d126,1
+np.float64,0x407B13EE414FA931,0x6700772c7544564d,2
+np.float64,0x407EAFDE9DE3EC54,0x6c346a0e49724a3c,2
+np.float64,0xC08362F398B9530D,0x07ffeddbadf980cb,2
+np.float64,0x407E865CDD9EEB86,0x6bf866cac5e0d126,2
 #use 32th entry
-np.float64,0x407FB62DBC794C86,0x6db009f708ac62cb,1
-np.float64,0xC063D0BAA68CDDDE,0x31a3b2a51ce50430,1
-np.float64,0xC05E7706A2231394,0x34f24bead6fab5c9,1
-np.float64,0x4083E3A06FDE444E,0x79527b7a386d1937,1
+np.float64,0x407FB62DBC794C86,0x6db009f708ac62cb,2
+np.float64,0xC063D0BAA68CDDDE,0x31a3b2a51ce50430,2
+np.float64,0xC05E7706A2231394,0x34f24bead6fab5c9,2
+np.float64,0x4083E3A06FDE444E,0x79527b7a386d1937,2
diff --git a/numpy/core/tests/data/umath-validation-set-log.csv b/numpy/core/tests/data/umath-validation-set-log.csv
index b8f6b08757d5..7717745d59bb 100644
--- a/numpy/core/tests/data/umath-validation-set-log.csv
+++ b/numpy/core/tests/data/umath-validation-set-log.csv
@@ -118,154 +118,154 @@ np.float32,0x3f4884e8,0xbe7a214a,4
 np.float32,0x3f486945,0xbe7aae76,4
 #float64
 ## +ve denormal ##
-np.float64,0x0000000000000001,0xc0874385446d71c3,1
-np.float64,0x0001000000000000,0xc086395a2079b70c,1
-np.float64,0x000fffffffffffff,0xc086232bdd7abcd2,1
-np.float64,0x0007ad63e2168cb6,0xc086290bc0b2980f,1
+np.float64,0x0000000000000001,0xc0874385446d71c3,2
+np.float64,0x0001000000000000,0xc086395a2079b70c,2
+np.float64,0x000fffffffffffff,0xc086232bdd7abcd2,2
+np.float64,0x0007ad63e2168cb6,0xc086290bc0b2980f,2
 ## -ve denormal ##
-np.float64,0x8000000000000001,0xfff8000000000001,1
-np.float64,0x8001000000000000,0xfff8000000000001,1
-np.float64,0x800fffffffffffff,0xfff8000000000001,1
-np.float64,0x8007ad63e2168cb6,0xfff8000000000001,1
+np.float64,0x8000000000000001,0xfff8000000000001,2
+np.float64,0x8001000000000000,0xfff8000000000001,2
+np.float64,0x800fffffffffffff,0xfff8000000000001,2
+np.float64,0x8007ad63e2168cb6,0xfff8000000000001,2
 ## +/-0.0f, MAX, MIN##
-np.float64,0x0000000000000000,0xfff0000000000000,1
-np.float64,0x8000000000000000,0xfff0000000000000,1
-np.float64,0x7fefffffffffffff,0x40862e42fefa39ef,1
-np.float64,0xffefffffffffffff,0xfff8000000000001,1
+np.float64,0x0000000000000000,0xfff0000000000000,2
+np.float64,0x8000000000000000,0xfff0000000000000,2
+np.float64,0x7fefffffffffffff,0x40862e42fefa39ef,2
+np.float64,0xffefffffffffffff,0xfff8000000000001,2
 ## near 1.0f ##
-np.float64,0x3ff0000000000000,0x0000000000000000,1
-np.float64,0x3fe8000000000000,0xbfd269621134db92,1
-np.float64,0x3ff0000000000001,0x3cafffffffffffff,1
-np.float64,0x3ff0000020000000,0x3e7fffffe000002b,1
-np.float64,0x3ff0000000000001,0x3cafffffffffffff,1
-np.float64,0x3fefffffe0000000,0xbe70000008000005,1
-np.float64,0x3fefffffffffffff,0xbca0000000000000,1
+np.float64,0x3ff0000000000000,0x0000000000000000,2
+np.float64,0x3fe8000000000000,0xbfd269621134db92,2
+np.float64,0x3ff0000000000001,0x3cafffffffffffff,2
+np.float64,0x3ff0000020000000,0x3e7fffffe000002b,2
+np.float64,0x3ff0000000000001,0x3cafffffffffffff,2
+np.float64,0x3fefffffe0000000,0xbe70000008000005,2
+np.float64,0x3fefffffffffffff,0xbca0000000000000,2
 ## random numbers ##
-np.float64,0x02500186f3d9da56,0xc0855b8abf135773,1
-np.float64,0x09200815a3951173,0xc082ff1ad7131bdc,1
-np.float64,0x0da029623b0243d4,0xc0816fc994695bb5,1
-np.float64,0x48703b8ac483a382,0x40579213a313490b,1
-np.float64,0x09207b74c87c9860,0xc082fee20ff349ef,1
-np.float64,0x62c077698e8df947,0x407821c996d110f0,1
-np.float64,0x2350b45e87c3cfb0,0xc073d6b16b51d072,1
-np.float64,0x3990a23f9ff2b623,0xc051aa60eadd8c61,1
-np.float64,0x0d011386a116c348,0xc081a6cc7ea3b8fb,1
-np.float64,0x1fe0f0303ebe273a,0xc0763870b78a81ca,1
-np.float64,0x0cd1260121d387da,0xc081b7668d61a9d1,1
-np.float64,0x1e6135a8f581d422,0xc077425ac10f08c2,1
-np.float64,0x622168db5fe52d30,0x4077b3c669b9fadb,1
-np.float64,0x69f188e1ec6d1718,0x407d1e2f18c63889,1
-np.float64,0x3aa1bf1d9c4dd1a3,0xc04d682e24bde479,1
-np.float64,0x6c81c4011ce4f683,0x407ee5190e8a8e6a,1
-np.float64,0x2191fa55aa5a5095,0xc0750c0c318b5e2d,1
-np.float64,0x32a1f602a32bf360,0xc06270caa493fc17,1
-np.float64,0x16023c90ba93249b,0xc07d0f88e0801638,1
-np.float64,0x1c525fe6d71fa9ff,0xc078af49c66a5d63,1
-np.float64,0x1a927675815d65b7,0xc079e5bdd7fe376e,1
-np.float64,0x41227b8fe70da028,0x402aa0c9f9a84c71,1
-np.float64,0x4962bb6e853fe87d,0x405a34aa04c83747,1
-np.float64,0x23d2cda00b26b5a4,0xc0737c13a06d00ea,1
-np.float64,0x2d13083fd62987fa,0xc06a25055aeb474e,1
-np.float64,0x10e31e4c9b4579a1,0xc0804e181929418e,1
-np.float64,0x26d3247d556a86a9,0xc0716774171da7e8,1
-np.float64,0x6603379398d0d4ac,0x407a64f51f8a887b,1
-np.float64,0x02d38af17d9442ba,0xc0852d955ac9dd68,1
-np.float64,0x6a2382b4818dd967,0x407d4129d688e5d4,1
-np.float64,0x2ee3c403c79b3934,0xc067a091fefaf8b6,1
-np.float64,0x6493a699acdbf1a4,0x4079663c8602bfc5,1
-np.float64,0x1c8413c4f0de3100,0xc0788c99697059b6,1
-np.float64,0x4573f1ed350d9622,0x404e9bd1e4c08920,1
-np.float64,0x2f34265c9200b69c,0xc067310cfea4e986,1
-np.float64,0x19b43e65fa22029b,0xc07a7f8877de22d6,1
-np.float64,0x0af48ab7925ed6bc,0xc0825c4fbc0e5ade,1
-np.float64,0x4fa49699cad82542,0x4065c76d2a318235,1
-np.float64,0x7204a15e56ade492,0x40815bb87484dffb,1
-np.float64,0x4734aa08a230982d,0x40542a4bf7a361a9,1
-np.float64,0x1ae4ed296c2fd749,0xc079ac4921f20abb,1
-np.float64,0x472514ea4370289c,0x4053ff372bd8f18f,1
-np.float64,0x53a54b3f73820430,0x406b5411fc5f2e33,1
-np.float64,0x64754de5a15684fa,0x407951592e99a5ab,1
-np.float64,0x69358e279868a7c3,0x407c9c671a882c31,1
-np.float64,0x284579ec61215945,0xc0706688e55f0927,1
-np.float64,0x68b5c58806447adc,0x407c43d6f4eff760,1
-np.float64,0x1945a83f98b0e65d,0xc07acc15eeb032cc,1
-np.float64,0x0fc5eb98a16578bf,0xc080b0d02eddca0e,1
-np.float64,0x6a75e208f5784250,0x407d7a7383bf8f05,1
-np.float64,0x0fe63a029c47645d,0xc080a59ca1e98866,1
-np.float64,0x37963ac53f065510,0xc057236281f7bdb6,1
-np.float64,0x135661bb07067ff7,0xc07ee924930c21e4,1
-np.float64,0x4b4699469d458422,0x405f73843756e887,1
-np.float64,0x1a66d73e4bf4881b,0xc07a039ba1c63adf,1
-np.float64,0x12a6b9b119a7da59,0xc07f62e49c6431f3,1
-np.float64,0x24c719aa8fd1bdb5,0xc072d26da4bf84d3,1
-np.float64,0x0fa6ff524ffef314,0xc080bb8514662e77,1
-np.float64,0x1db751d66fdd4a9a,0xc077b77cb50d7c92,1
-np.float64,0x4947374c516da82c,0x4059e9acfc7105bf,1
-np.float64,0x1b1771ab98f3afc8,0xc07989326b8e1f66,1
-np.float64,0x25e78805baac8070,0xc0720a818e6ef080,1
-np.float64,0x4bd7a148225d3687,0x406082d004ea3ee7,1
-np.float64,0x53d7d6b2bbbda00a,0x406b9a398967cbd5,1
-np.float64,0x6997fb9f4e1c685f,0x407ce0a703413eba,1
-np.float64,0x069802c2ff71b951,0xc083df39bf7acddc,1
-np.float64,0x4d683ac9890f66d8,0x4062ae21d8c2acf0,1
-np.float64,0x5a2825863ec14f4c,0x40722d718d549552,1
-np.float64,0x0398799a88f4db80,0xc084e93dab8e2158,1
-np.float64,0x5ed87a8b77e135a5,0x40756d7051777b33,1
-np.float64,0x5828cd6d79b9bede,0x4070cafb22fc6ca1,1
-np.float64,0x7b18ba2a5ec6f068,0x408481386b3ed6fe,1
-np.float64,0x4938fd60922198fe,0x4059c206b762ea7e,1
-np.float64,0x31b8f44fcdd1a46e,0xc063b2faa8b6434e,1
-np.float64,0x5729341c0d918464,0x407019cac0c4a7d7,1
-np.float64,0x13595e9228ee878e,0xc07ee7235a7d8088,1
-np.float64,0x17698b0dc9dd4135,0xc07c1627e3a5ad5f,1
-np.float64,0x63b977c283abb0cc,0x4078cf1ec6ed65be,1
-np.float64,0x7349cc0d4dc16943,0x4081cc697ce4cb53,1
-np.float64,0x4e49a80b732fb28d,0x4063e67e3c5cbe90,1
-np.float64,0x07ba14b848a8ae02,0xc0837ac032a094e0,1
-np.float64,0x3da9f17b691bfddc,0xc03929c25366acda,1
-np.float64,0x02ea39aa6c3ac007,0xc08525af6f21e1c4,1
-np.float64,0x3a6a42f04ed9563d,0xc04e98e825dca46b,1
-np.float64,0x1afa877cd7900be7,0xc0799d6648cb34a9,1
-np.float64,0x58ea986649e052c6,0x4071512e939ad790,1
-np.float64,0x691abbc04647f536,0x407c89aaae0fcb83,1
-np.float64,0x43aabc5063e6f284,0x4044b45d18106fd2,1
-np.float64,0x488b003c893e0bea,0x4057df012a2dafbe,1
-np.float64,0x77eb076ed67caee5,0x40836720de94769e,1
-np.float64,0x5c1b46974aba46f4,0x40738731ba256007,1
-np.float64,0x1a5b29ecb5d3c261,0xc07a0becc77040d6,1
-np.float64,0x5d8b6ccf868c6032,0x4074865c1865e2db,1
-np.float64,0x4cfb6690b4aaf5af,0x406216cd8c7e8ddb,1
-np.float64,0x76cbd8eb5c5fc39e,0x4083038dc66d682b,1
-np.float64,0x28bbd1fec5012814,0xc07014c2dd1b9711,1
-np.float64,0x33dc1b3a4fd6bf7a,0xc060bd0756e07d8a,1
-np.float64,0x52bbe89b37de99f3,0x406a10041aa7d343,1
-np.float64,0x07bc479d15eb2dd3,0xc0837a1a6e3a3b61,1
-np.float64,0x18fc5275711a901d,0xc07aff3e9d62bc93,1
-np.float64,0x114c9758e247dc71,0xc080299a7cf15b05,1
-np.float64,0x25ac8f6d60755148,0xc07233c4c0c511d4,1
-np.float64,0x260cae2bb9e9fd7e,0xc071f128c7e82eac,1
-np.float64,0x572ccdfe0241de82,0x40701bedc84bb504,1
-np.float64,0x0ddcef6c8d41f5ee,0xc0815a7e16d07084,1
-np.float64,0x6dad1d59c988af68,0x407fb4a0bc0142b1,1
-np.float64,0x025d200580d8b6d1,0xc08556c0bc32b1b2,1
-np.float64,0x7aad344b6aa74c18,0x40845bbc453f22be,1
-np.float64,0x5b5d9d6ad9d14429,0x4073036d2d21f382,1
-np.float64,0x49cd8d8dcdf19954,0x405b5c034f5c7353,1
-np.float64,0x63edb9483335c1e6,0x4078f2dd21378786,1
-np.float64,0x7b1dd64c9d2c26bd,0x408482b922017bc9,1
-np.float64,0x782e13e0b574be5f,0x40837e2a0090a5ad,1
-np.float64,0x592dfe18b9d6db2f,0x40717f777fbcb1ec,1
-np.float64,0x654e3232ac60d72c,0x4079e71a95a70446,1
-np.float64,0x7b8e42ad22091456,0x4084a9a6f1e61722,1
-np.float64,0x570e88dfd5860ae6,0x407006ae6c0d137a,1
-np.float64,0x294e98346cb98ef1,0xc06f5edaac12bd44,1
-np.float64,0x1adeaa4ab792e642,0xc079b1431d5e2633,1
-np.float64,0x7b6ead3377529ac8,0x40849eabc8c7683c,1
-np.float64,0x2b8eedae8a9b2928,0xc06c400054deef11,1
-np.float64,0x65defb45b2dcf660,0x407a4b53f181c05a,1
-np.float64,0x1baf582d475e7701,0xc07920bcad4a502c,1
-np.float64,0x461f39cf05a0f15a,0x405126368f984fa1,1
-np.float64,0x7e5f6f5dcfff005b,0x4085a37d610439b4,1
-np.float64,0x136f66e4d09bd662,0xc07ed8a2719f2511,1
-np.float64,0x65afd8983fb6ca1f,0x407a2a7f48bf7fc1,1
-np.float64,0x572fa7f95ed22319,0x40701d706cf82e6f,1
+np.float64,0x02500186f3d9da56,0xc0855b8abf135773,2
+np.float64,0x09200815a3951173,0xc082ff1ad7131bdc,2
+np.float64,0x0da029623b0243d4,0xc0816fc994695bb5,2
+np.float64,0x48703b8ac483a382,0x40579213a313490b,2
+np.float64,0x09207b74c87c9860,0xc082fee20ff349ef,2
+np.float64,0x62c077698e8df947,0x407821c996d110f0,2
+np.float64,0x2350b45e87c3cfb0,0xc073d6b16b51d072,2
+np.float64,0x3990a23f9ff2b623,0xc051aa60eadd8c61,2
+np.float64,0x0d011386a116c348,0xc081a6cc7ea3b8fb,2
+np.float64,0x1fe0f0303ebe273a,0xc0763870b78a81ca,2
+np.float64,0x0cd1260121d387da,0xc081b7668d61a9d1,2
+np.float64,0x1e6135a8f581d422,0xc077425ac10f08c2,2
+np.float64,0x622168db5fe52d30,0x4077b3c669b9fadb,2
+np.float64,0x69f188e1ec6d1718,0x407d1e2f18c63889,2
+np.float64,0x3aa1bf1d9c4dd1a3,0xc04d682e24bde479,2
+np.float64,0x6c81c4011ce4f683,0x407ee5190e8a8e6a,2
+np.float64,0x2191fa55aa5a5095,0xc0750c0c318b5e2d,2
+np.float64,0x32a1f602a32bf360,0xc06270caa493fc17,2
+np.float64,0x16023c90ba93249b,0xc07d0f88e0801638,2
+np.float64,0x1c525fe6d71fa9ff,0xc078af49c66a5d63,2
+np.float64,0x1a927675815d65b7,0xc079e5bdd7fe376e,2
+np.float64,0x41227b8fe70da028,0x402aa0c9f9a84c71,2
+np.float64,0x4962bb6e853fe87d,0x405a34aa04c83747,2
+np.float64,0x23d2cda00b26b5a4,0xc0737c13a06d00ea,2
+np.float64,0x2d13083fd62987fa,0xc06a25055aeb474e,2
+np.float64,0x10e31e4c9b4579a1,0xc0804e181929418e,2
+np.float64,0x26d3247d556a86a9,0xc0716774171da7e8,2
+np.float64,0x6603379398d0d4ac,0x407a64f51f8a887b,2
+np.float64,0x02d38af17d9442ba,0xc0852d955ac9dd68,2
+np.float64,0x6a2382b4818dd967,0x407d4129d688e5d4,2
+np.float64,0x2ee3c403c79b3934,0xc067a091fefaf8b6,2
+np.float64,0x6493a699acdbf1a4,0x4079663c8602bfc5,2
+np.float64,0x1c8413c4f0de3100,0xc0788c99697059b6,2
+np.float64,0x4573f1ed350d9622,0x404e9bd1e4c08920,2
+np.float64,0x2f34265c9200b69c,0xc067310cfea4e986,2
+np.float64,0x19b43e65fa22029b,0xc07a7f8877de22d6,2
+np.float64,0x0af48ab7925ed6bc,0xc0825c4fbc0e5ade,2
+np.float64,0x4fa49699cad82542,0x4065c76d2a318235,2
+np.float64,0x7204a15e56ade492,0x40815bb87484dffb,2
+np.float64,0x4734aa08a230982d,0x40542a4bf7a361a9,2
+np.float64,0x1ae4ed296c2fd749,0xc079ac4921f20abb,2
+np.float64,0x472514ea4370289c,0x4053ff372bd8f18f,2
+np.float64,0x53a54b3f73820430,0x406b5411fc5f2e33,2
+np.float64,0x64754de5a15684fa,0x407951592e99a5ab,2
+np.float64,0x69358e279868a7c3,0x407c9c671a882c31,2
+np.float64,0x284579ec61215945,0xc0706688e55f0927,2
+np.float64,0x68b5c58806447adc,0x407c43d6f4eff760,2
+np.float64,0x1945a83f98b0e65d,0xc07acc15eeb032cc,2
+np.float64,0x0fc5eb98a16578bf,0xc080b0d02eddca0e,2
+np.float64,0x6a75e208f5784250,0x407d7a7383bf8f05,2
+np.float64,0x0fe63a029c47645d,0xc080a59ca1e98866,2
+np.float64,0x37963ac53f065510,0xc057236281f7bdb6,2
+np.float64,0x135661bb07067ff7,0xc07ee924930c21e4,2
+np.float64,0x4b4699469d458422,0x405f73843756e887,2
+np.float64,0x1a66d73e4bf4881b,0xc07a039ba1c63adf,2
+np.float64,0x12a6b9b119a7da59,0xc07f62e49c6431f3,2
+np.float64,0x24c719aa8fd1bdb5,0xc072d26da4bf84d3,2
+np.float64,0x0fa6ff524ffef314,0xc080bb8514662e77,2
+np.float64,0x1db751d66fdd4a9a,0xc077b77cb50d7c92,2
+np.float64,0x4947374c516da82c,0x4059e9acfc7105bf,2
+np.float64,0x1b1771ab98f3afc8,0xc07989326b8e1f66,2
+np.float64,0x25e78805baac8070,0xc0720a818e6ef080,2
+np.float64,0x4bd7a148225d3687,0x406082d004ea3ee7,2
+np.float64,0x53d7d6b2bbbda00a,0x406b9a398967cbd5,2
+np.float64,0x6997fb9f4e1c685f,0x407ce0a703413eba,2
+np.float64,0x069802c2ff71b951,0xc083df39bf7acddc,2
+np.float64,0x4d683ac9890f66d8,0x4062ae21d8c2acf0,2
+np.float64,0x5a2825863ec14f4c,0x40722d718d549552,2
+np.float64,0x0398799a88f4db80,0xc084e93dab8e2158,2
+np.float64,0x5ed87a8b77e135a5,0x40756d7051777b33,2
+np.float64,0x5828cd6d79b9bede,0x4070cafb22fc6ca1,2
+np.float64,0x7b18ba2a5ec6f068,0x408481386b3ed6fe,2
+np.float64,0x4938fd60922198fe,0x4059c206b762ea7e,2
+np.float64,0x31b8f44fcdd1a46e,0xc063b2faa8b6434e,2
+np.float64,0x5729341c0d918464,0x407019cac0c4a7d7,2
+np.float64,0x13595e9228ee878e,0xc07ee7235a7d8088,2
+np.float64,0x17698b0dc9dd4135,0xc07c1627e3a5ad5f,2
+np.float64,0x63b977c283abb0cc,0x4078cf1ec6ed65be,2
+np.float64,0x7349cc0d4dc16943,0x4081cc697ce4cb53,2
+np.float64,0x4e49a80b732fb28d,0x4063e67e3c5cbe90,2
+np.float64,0x07ba14b848a8ae02,0xc0837ac032a094e0,2
+np.float64,0x3da9f17b691bfddc,0xc03929c25366acda,2
+np.float64,0x02ea39aa6c3ac007,0xc08525af6f21e1c4,2
+np.float64,0x3a6a42f04ed9563d,0xc04e98e825dca46b,2
+np.float64,0x1afa877cd7900be7,0xc0799d6648cb34a9,2
+np.float64,0x58ea986649e052c6,0x4071512e939ad790,2
+np.float64,0x691abbc04647f536,0x407c89aaae0fcb83,2
+np.float64,0x43aabc5063e6f284,0x4044b45d18106fd2,2
+np.float64,0x488b003c893e0bea,0x4057df012a2dafbe,2
+np.float64,0x77eb076ed67caee5,0x40836720de94769e,2
+np.float64,0x5c1b46974aba46f4,0x40738731ba256007,2
+np.float64,0x1a5b29ecb5d3c261,0xc07a0becc77040d6,2
+np.float64,0x5d8b6ccf868c6032,0x4074865c1865e2db,2
+np.float64,0x4cfb6690b4aaf5af,0x406216cd8c7e8ddb,2
+np.float64,0x76cbd8eb5c5fc39e,0x4083038dc66d682b,2
+np.float64,0x28bbd1fec5012814,0xc07014c2dd1b9711,2
+np.float64,0x33dc1b3a4fd6bf7a,0xc060bd0756e07d8a,2
+np.float64,0x52bbe89b37de99f3,0x406a10041aa7d343,2
+np.float64,0x07bc479d15eb2dd3,0xc0837a1a6e3a3b61,2
+np.float64,0x18fc5275711a901d,0xc07aff3e9d62bc93,2
+np.float64,0x114c9758e247dc71,0xc080299a7cf15b05,2
+np.float64,0x25ac8f6d60755148,0xc07233c4c0c511d4,2
+np.float64,0x260cae2bb9e9fd7e,0xc071f128c7e82eac,2
+np.float64,0x572ccdfe0241de82,0x40701bedc84bb504,2
+np.float64,0x0ddcef6c8d41f5ee,0xc0815a7e16d07084,2
+np.float64,0x6dad1d59c988af68,0x407fb4a0bc0142b1,2
+np.float64,0x025d200580d8b6d1,0xc08556c0bc32b1b2,2
+np.float64,0x7aad344b6aa74c18,0x40845bbc453f22be,2
+np.float64,0x5b5d9d6ad9d14429,0x4073036d2d21f382,2
+np.float64,0x49cd8d8dcdf19954,0x405b5c034f5c7353,2
+np.float64,0x63edb9483335c1e6,0x4078f2dd21378786,2
+np.float64,0x7b1dd64c9d2c26bd,0x408482b922017bc9,2
+np.float64,0x782e13e0b574be5f,0x40837e2a0090a5ad,2
+np.float64,0x592dfe18b9d6db2f,0x40717f777fbcb1ec,2
+np.float64,0x654e3232ac60d72c,0x4079e71a95a70446,2
+np.float64,0x7b8e42ad22091456,0x4084a9a6f1e61722,2
+np.float64,0x570e88dfd5860ae6,0x407006ae6c0d137a,2
+np.float64,0x294e98346cb98ef1,0xc06f5edaac12bd44,2
+np.float64,0x1adeaa4ab792e642,0xc079b1431d5e2633,2
+np.float64,0x7b6ead3377529ac8,0x40849eabc8c7683c,2
+np.float64,0x2b8eedae8a9b2928,0xc06c400054deef11,2
+np.float64,0x65defb45b2dcf660,0x407a4b53f181c05a,2
+np.float64,0x1baf582d475e7701,0xc07920bcad4a502c,2
+np.float64,0x461f39cf05a0f15a,0x405126368f984fa1,2
+np.float64,0x7e5f6f5dcfff005b,0x4085a37d610439b4,2
+np.float64,0x136f66e4d09bd662,0xc07ed8a2719f2511,2
+np.float64,0x65afd8983fb6ca1f,0x407a2a7f48bf7fc1,2
+np.float64,0x572fa7f95ed22319,0x40701d706cf82e6f,2
diff --git a/numpy/core/tests/examples/checks.pyx b/numpy/core/tests/examples/cython/checks.pyx
similarity index 95%
rename from numpy/core/tests/examples/checks.pyx
rename to numpy/core/tests/examples/cython/checks.pyx
index 151979db7043..e41c6d657351 100644
--- a/numpy/core/tests/examples/checks.pyx
+++ b/numpy/core/tests/examples/cython/checks.pyx
@@ -1,3 +1,5 @@
+#cython: language_level=3
+
 """
 Functions in this module give python-space wrappers for cython functions
 exposed in numpy/__init__.pxd, so they can be tested in test_cython.py
diff --git a/numpy/core/tests/examples/setup.py b/numpy/core/tests/examples/cython/setup.py
similarity index 100%
rename from numpy/core/tests/examples/setup.py
rename to numpy/core/tests/examples/cython/setup.py
diff --git a/numpy/core/tests/examples/limited_api/limited_api.c b/numpy/core/tests/examples/limited_api/limited_api.c
new file mode 100644
index 000000000000..698c54c57706
--- /dev/null
+++ b/numpy/core/tests/examples/limited_api/limited_api.c
@@ -0,0 +1,17 @@
+#define Py_LIMITED_API 0x03060000
+
+#include 
+#include 
+#include 
+
+static PyModuleDef moduledef = {
+    .m_base = PyModuleDef_HEAD_INIT,
+    .m_name = "limited_api"
+};
+
+PyMODINIT_FUNC PyInit_limited_api(void)
+{
+    import_array();
+    import_umath();
+    return PyModule_Create(&moduledef);
+}
diff --git a/numpy/core/tests/examples/limited_api/setup.py b/numpy/core/tests/examples/limited_api/setup.py
new file mode 100644
index 000000000000..18747dc80896
--- /dev/null
+++ b/numpy/core/tests/examples/limited_api/setup.py
@@ -0,0 +1,22 @@
+"""
+Build an example package using the limited Python C API.
+"""
+
+import numpy as np
+from setuptools import setup, Extension
+import os
+
+macros = [("NPY_NO_DEPRECATED_API", 0), ("Py_LIMITED_API", "0x03060000")]
+
+limited_api = Extension(
+    "limited_api",
+    sources=[os.path.join('.', "limited_api.c")],
+    include_dirs=[np.get_include()],
+    define_macros=macros,
+)
+
+extensions = [limited_api]
+
+setup(
+    ext_modules=extensions
+)
diff --git a/numpy/core/tests/test_abc.py b/numpy/core/tests/test_abc.py
index 30e5748af867..8b12d07ac417 100644
--- a/numpy/core/tests/test_abc.py
+++ b/numpy/core/tests/test_abc.py
@@ -20,35 +20,35 @@ def test_abstract(self):
     def test_floats(self):
         for t in sctypes['float']:
             assert_(isinstance(t(), numbers.Real),
-                    "{0} is not instance of Real".format(t.__name__))
+                    f"{t.__name__} is not instance of Real")
             assert_(issubclass(t, numbers.Real),
-                    "{0} is not subclass of Real".format(t.__name__))
+                    f"{t.__name__} is not subclass of Real")
             assert_(not isinstance(t(), numbers.Rational),
-                    "{0} is instance of Rational".format(t.__name__))
+                    f"{t.__name__} is instance of Rational")
             assert_(not issubclass(t, numbers.Rational),
-                    "{0} is subclass of Rational".format(t.__name__))
+                    f"{t.__name__} is subclass of Rational")
 
     def test_complex(self):
         for t in sctypes['complex']:
             assert_(isinstance(t(), numbers.Complex),
-                    "{0} is not instance of Complex".format(t.__name__))
+                    f"{t.__name__} is not instance of Complex")
             assert_(issubclass(t, numbers.Complex),
-                    "{0} is not subclass of Complex".format(t.__name__))
+                    f"{t.__name__} is not subclass of Complex")
             assert_(not isinstance(t(), numbers.Real),
-                    "{0} is instance of Real".format(t.__name__))
+                    f"{t.__name__} is instance of Real")
             assert_(not issubclass(t, numbers.Real),
-                    "{0} is subclass of Real".format(t.__name__))
+                    f"{t.__name__} is subclass of Real")
 
     def test_int(self):
         for t in sctypes['int']:
             assert_(isinstance(t(), numbers.Integral),
-                    "{0} is not instance of Integral".format(t.__name__))
+                    f"{t.__name__} is not instance of Integral")
             assert_(issubclass(t, numbers.Integral),
-                    "{0} is not subclass of Integral".format(t.__name__))
+                    f"{t.__name__} is not subclass of Integral")
 
     def test_uint(self):
         for t in sctypes['uint']:
             assert_(isinstance(t(), numbers.Integral),
-                    "{0} is not instance of Integral".format(t.__name__))
+                    f"{t.__name__} is not instance of Integral")
             assert_(issubclass(t, numbers.Integral),
-                    "{0} is not subclass of Integral".format(t.__name__))
+                    f"{t.__name__} is not subclass of Integral")
diff --git a/numpy/core/tests/test_api.py b/numpy/core/tests/test_api.py
index d3c7211cd1b9..5006e77f27aa 100644
--- a/numpy/core/tests/test_api.py
+++ b/numpy/core/tests/test_api.py
@@ -8,9 +8,6 @@
      HAS_REFCOUNT
     )
 
-# Switch between new behaviour when NPY_RELAXED_STRIDES_CHECKING is set.
-NPY_RELAXED_STRIDES_CHECKING = np.ones((10, 1), order='C').flags.f_contiguous
-
 
 def test_array_array():
     tobj = type(object)
@@ -144,7 +141,7 @@ def test_array_array():
 
 @pytest.mark.parametrize("array", [True, False])
 def test_array_impossible_casts(array):
-    # All builtin types can forst cast as least theoretically
+    # All builtin types can be forcibly cast, at least theoretically,
     # but user dtypes cannot necessarily.
     rt = rational(1, 2)
     if array:
@@ -153,24 +150,20 @@ def test_array_impossible_casts(array):
         np.array(rt, dtype="M8")
 
 
-def test_fastCopyAndTranspose():
-    # 0D array
-    a = np.array(2)
-    b = np.fastCopyAndTranspose(a)
-    assert_equal(b, a.T)
-    assert_(b.flags.owndata)
-
-    # 1D array
-    a = np.array([3, 2, 7, 0])
-    b = np.fastCopyAndTranspose(a)
-    assert_equal(b, a.T)
-    assert_(b.flags.owndata)
+# TODO: remove when fastCopyAndTranspose deprecation expires
+@pytest.mark.parametrize("a",
+    (
+        np.array(2),  # 0D array
+        np.array([3, 2, 7, 0]),  # 1D array
+        np.arange(6).reshape(2, 3)  # 2D array
+    ),
+)
+def test_fastCopyAndTranspose(a):
+    with pytest.deprecated_call():
+        b = np.fastCopyAndTranspose(a)
+        assert_equal(b, a.T)
+        assert b.flags.owndata
 
-    # 2D array
-    a = np.arange(6).reshape(2, 3)
-    b = np.fastCopyAndTranspose(a)
-    assert_equal(b, a.T)
-    assert_(b.flags.owndata)
 
 def test_array_astype():
     a = np.arange(6, dtype='f4').reshape(2, 3)
@@ -241,7 +234,7 @@ class MyNDArray(np.ndarray):
     b = a.astype('S')
     assert_equal(a, b)
     assert_equal(b.dtype, np.dtype('S100'))
-    a = np.array([u'a'*100], dtype='O')
+    a = np.array(['a'*100], dtype='O')
     b = a.astype('U')
     assert_equal(a, b)
     assert_equal(b.dtype, np.dtype('U100'))
@@ -251,7 +244,7 @@ class MyNDArray(np.ndarray):
     b = a.astype('S')
     assert_equal(a, b)
     assert_equal(b.dtype, np.dtype('S10'))
-    a = np.array([u'a'*10], dtype='O')
+    a = np.array(['a'*10], dtype='O')
     b = a.astype('U')
     assert_equal(a, b)
     assert_equal(b.dtype, np.dtype('U10'))
@@ -259,19 +252,19 @@ class MyNDArray(np.ndarray):
     a = np.array(123456789012345678901234567890, dtype='O').astype('S')
     assert_array_equal(a, np.array(b'1234567890' * 3, dtype='S30'))
     a = np.array(123456789012345678901234567890, dtype='O').astype('U')
-    assert_array_equal(a, np.array(u'1234567890' * 3, dtype='U30'))
+    assert_array_equal(a, np.array('1234567890' * 3, dtype='U30'))
 
     a = np.array([123456789012345678901234567890], dtype='O').astype('S')
     assert_array_equal(a, np.array(b'1234567890' * 3, dtype='S30'))
     a = np.array([123456789012345678901234567890], dtype='O').astype('U')
-    assert_array_equal(a, np.array(u'1234567890' * 3, dtype='U30'))
+    assert_array_equal(a, np.array('1234567890' * 3, dtype='U30'))
 
     a = np.array(123456789012345678901234567890, dtype='S')
     assert_array_equal(a, np.array(b'1234567890' * 3, dtype='S30'))
     a = np.array(123456789012345678901234567890, dtype='U')
-    assert_array_equal(a, np.array(u'1234567890' * 3, dtype='U30'))
+    assert_array_equal(a, np.array('1234567890' * 3, dtype='U30'))
 
-    a = np.array(u'a\u0140', dtype='U')
+    a = np.array('a\u0140', dtype='U')
     b = np.ndarray(buffer=a, dtype='uint32', shape=2)
     assert_(b.size == 2)
 
@@ -482,13 +475,6 @@ def check_copy_result(x, y, ccontig, fcontig, strides=False):
         assert_equal(x, y)
         assert_equal(res.flags.c_contiguous, ccontig)
         assert_equal(res.flags.f_contiguous, fcontig)
-        # This check is impossible only because
-        # NPY_RELAXED_STRIDES_CHECKING changes the strides actively
-        if not NPY_RELAXED_STRIDES_CHECKING:
-            if strides:
-                assert_equal(x.strides, y.strides)
-            else:
-                assert_(x.strides != y.strides)
 
     # Validate the initial state of a, b, and c
     assert_(a.flags.c_contiguous)
@@ -542,8 +528,7 @@ def check_copy_result(x, y, ccontig, fcontig, strides=False):
 
 def test_contiguous_flags():
     a = np.ones((4, 4, 1))[::2,:,:]
-    if NPY_RELAXED_STRIDES_CHECKING:
-        a.strides = a.strides[:2] + (-123,)
+    a.strides = a.strides[:2] + (-123,)
     b = np.ones((2, 2, 1, 2, 2)).swapaxes(3, 4)
 
     def check_contig(a, ccontig, fcontig):
@@ -553,12 +538,8 @@ def check_contig(a, ccontig, fcontig):
     # Check if new arrays are correct:
     check_contig(a, False, False)
     check_contig(b, False, False)
-    if NPY_RELAXED_STRIDES_CHECKING:
-        check_contig(np.empty((2, 2, 0, 2, 2)), True, True)
-        check_contig(np.array([[[1], [2]]], order='F'), True, True)
-    else:
-        check_contig(np.empty((2, 2, 0, 2, 2)), True, False)
-        check_contig(np.array([[[1], [2]]], order='F'), False, True)
+    check_contig(np.empty((2, 2, 0, 2, 2)), True, True)
+    check_contig(np.array([[[1], [2]]], order='F'), True, True)
     check_contig(np.empty((2, 2)), True, False)
     check_contig(np.empty((2, 2), order='F'), False, True)
 
@@ -567,18 +548,11 @@ def check_contig(a, ccontig, fcontig):
     check_contig(np.array(a, copy=False, order='C'), True, False)
     check_contig(np.array(a, ndmin=4, copy=False, order='F'), False, True)
 
-    if NPY_RELAXED_STRIDES_CHECKING:
-        # Check slicing update of flags and :
-        check_contig(a[0], True, True)
-        check_contig(a[None, ::4, ..., None], True, True)
-        check_contig(b[0, 0, ...], False, True)
-        check_contig(b[:,:, 0:0,:,:], True, True)
-    else:
-        # Check slicing update of flags:
-        check_contig(a[0], True, False)
-        # Would be nice if this was C-Contiguous:
-        check_contig(a[None, 0, ..., None], False, False)
-        check_contig(b[0, 0, 0, ...], False, True)
+    # Check slicing update of flags and :
+    check_contig(a[0], True, True)
+    check_contig(a[None, ::4, ..., None], True, True)
+    check_contig(b[0, 0, ...], False, True)
+    check_contig(b[:, :, 0:0, :, :], True, True)
 
     # Test ravel and squeeze.
     check_contig(a.ravel(), True, True)
diff --git a/numpy/core/tests/test_array_coercion.py b/numpy/core/tests/test_array_coercion.py
index 293f5a68f8e6..fade572928c9 100644
--- a/numpy/core/tests/test_array_coercion.py
+++ b/numpy/core/tests/test_array_coercion.py
@@ -4,11 +4,11 @@
 are tested (sometimes indirectly) elsewhere.
 """
 
+from itertools import permutations, product
+
 import pytest
 from pytest import param
 
-from itertools import product
-
 import numpy as np
 from numpy.core._rational_tests import rational
 from numpy.core._multiarray_umath import _discover_array_parameters
@@ -135,7 +135,7 @@ def scalar_instances(times=True, extended_precision=True, user_dtype=True):
 
 
 def is_parametric_dtype(dtype):
-    """Returns True if the the dtype is a parametric legacy dtype (itemsize
+    """Returns True if the dtype is a parametric legacy dtype (itemsize
     is 0, or a datetime without units)
     """
     if dtype.itemsize == 0:
@@ -373,28 +373,29 @@ def test_default_dtype_instance(self, dtype_char):
         assert discovered_dtype.itemsize == dtype.itemsize
 
     @pytest.mark.parametrize("dtype", np.typecodes["Integer"])
-    def test_scalar_to_int_coerce_does_not_cast(self, dtype):
+    @pytest.mark.parametrize(["scalar", "error"],
+            [(np.float64(np.nan), ValueError),
+             (np.array(-1).astype(np.ulonglong)[()], OverflowError)])
+    def test_scalar_to_int_coerce_does_not_cast(self, dtype, scalar, error):
         """
         Signed integers are currently different in that they do not cast other
         NumPy scalar, but instead use scalar.__int__(). The hardcoded
         exception to this rule is `np.array(scalar, dtype=integer)`.
         """
         dtype = np.dtype(dtype)
-        invalid_int = np.ulonglong(-1)
 
-        float_nan = np.float64(np.nan)
-
-        for scalar in [float_nan, invalid_int]:
-            # This is a special case using casting logic and thus not failing:
+        # This is a special case using casting logic.  It warns for the NaN
+        # but allows the cast (giving undefined behaviour).
+        with np.errstate(invalid="ignore"):
             coerced = np.array(scalar, dtype=dtype)
             cast = np.array(scalar).astype(dtype)
-            assert_array_equal(coerced, cast)
+        assert_array_equal(coerced, cast)
 
-            # However these fail:
-            with pytest.raises((ValueError, OverflowError)):
-                np.array([scalar], dtype=dtype)
-            with pytest.raises((ValueError, OverflowError)):
-                cast[()] = scalar
+        # However these fail:
+        with pytest.raises(error):
+            np.array([scalar], dtype=dtype)
+        with pytest.raises(error):
+            cast[()] = scalar
 
 
 class TestTimeScalars:
@@ -489,9 +490,10 @@ def test_nested_simple(self):
         with pytest.raises(ValueError):
             np.array([nested], dtype="float64")
 
-        # We discover object automatically at this time:
-        with assert_warns(np.VisibleDeprecationWarning):
-            arr = np.array([nested])
+        with pytest.raises(ValueError, match=".*would exceed the maximum"):
+            np.array([nested])  # user must ask for `object` explicitly
+
+        arr = np.array([nested], dtype=object)
         assert arr.dtype == np.dtype("O")
         assert arr.shape == (1,) * np.MAXDIMS
         assert arr.item() is initial
@@ -522,7 +524,7 @@ def test_nested_arraylikes(self, arraylike):
         for i in range(np.MAXDIMS - 1):
             nested = [nested]
 
-        with pytest.warns(DeprecationWarning):
+        with pytest.raises(ValueError, match=".*would exceed the maximum"):
             # It will refuse to assign the array into
             np.array(nested, dtype="float64")
 
@@ -614,8 +616,8 @@ def __len__(self):
 
         obj.append([2, 3])
         obj.append(mylist([1, 2]))
-        with pytest.raises(RuntimeError):
-            np.array(obj)
+        # Does not crash:
+        np.array(obj)
 
     def test_replace_0d_array(self):
         # List to coerce, `mylist` will mutate the first element
@@ -746,3 +748,88 @@ def __getitem__(self):
         with pytest.raises(error):
             np.array(BadSequence())
 
+
+class TestAsArray:
+    """Test expected behaviors of ``asarray``."""
+
+    def test_dtype_identity(self):
+        """Confirm the intended behavior for *dtype* kwarg.
+
+        The result of ``asarray()`` should have the dtype provided through the
+        keyword argument, when used. This forces unique array handles to be
+        produced for unique np.dtype objects, but (for equivalent dtypes), the
+        underlying data (the base object) is shared with the original array
+        object.
+
+        Ref https://github.com/numpy/numpy/issues/1468
+        """
+        int_array = np.array([1, 2, 3], dtype='i')
+        assert np.asarray(int_array) is int_array
+
+        # The character code resolves to the singleton dtype object provided
+        # by the numpy package.
+        assert np.asarray(int_array, dtype='i') is int_array
+
+        # Derive a dtype from n.dtype('i'), but add a metadata object to force
+        # the dtype to be distinct.
+        unequal_type = np.dtype('i', metadata={'spam': True})
+        annotated_int_array = np.asarray(int_array, dtype=unequal_type)
+        assert annotated_int_array is not int_array
+        assert annotated_int_array.base is int_array
+        # Create an equivalent descriptor with a new and distinct dtype
+        # instance.
+        equivalent_requirement = np.dtype('i', metadata={'spam': True})
+        annotated_int_array_alt = np.asarray(annotated_int_array,
+                                             dtype=equivalent_requirement)
+        assert unequal_type == equivalent_requirement
+        assert unequal_type is not equivalent_requirement
+        assert annotated_int_array_alt is not annotated_int_array
+        assert annotated_int_array_alt.dtype is equivalent_requirement
+
+        # Check the same logic for a pair of C types whose equivalence may vary
+        # between computing environments.
+        # Find an equivalent pair.
+        integer_type_codes = ('i', 'l', 'q')
+        integer_dtypes = [np.dtype(code) for code in integer_type_codes]
+        typeA = None
+        typeB = None
+        for typeA, typeB in permutations(integer_dtypes, r=2):
+            if typeA == typeB:
+                assert typeA is not typeB
+                break
+        assert isinstance(typeA, np.dtype) and isinstance(typeB, np.dtype)
+
+        # These ``asarray()`` calls may produce a new view or a copy,
+        # but never the same object.
+        long_int_array = np.asarray(int_array, dtype='l')
+        long_long_int_array = np.asarray(int_array, dtype='q')
+        assert long_int_array is not int_array
+        assert long_long_int_array is not int_array
+        assert np.asarray(long_int_array, dtype='q') is not long_int_array
+        array_a = np.asarray(int_array, dtype=typeA)
+        assert typeA == typeB
+        assert typeA is not typeB
+        assert array_a.dtype is typeA
+        assert array_a is not np.asarray(array_a, dtype=typeB)
+        assert np.asarray(array_a, dtype=typeB).dtype is typeB
+        assert array_a is np.asarray(array_a, dtype=typeB).base
+
+
+class TestSpecialAttributeLookupFailure:
+    # An exception was raised while fetching the attribute
+
+    class WeirdArrayLike:
+        @property
+        def __array__(self):
+            raise RuntimeError("oops!")
+
+    class WeirdArrayInterface:
+        @property
+        def __array_interface__(self):
+            raise RuntimeError("oops!")
+
+    def test_deprecated(self):
+        with pytest.raises(RuntimeError):
+            np.array(self.WeirdArrayLike())
+        with pytest.raises(RuntimeError):
+            np.array(self.WeirdArrayInterface())
diff --git a/numpy/core/tests/test_array_interface.py b/numpy/core/tests/test_array_interface.py
new file mode 100644
index 000000000000..8b1ab27c5cd3
--- /dev/null
+++ b/numpy/core/tests/test_array_interface.py
@@ -0,0 +1,216 @@
+import sys
+import pytest
+import numpy as np
+from numpy.testing import extbuild
+
+
+@pytest.fixture
+def get_module(tmp_path):
+    """ Some codes to generate data and manage temporary buffers use when
+    sharing with numpy via the array interface protocol.
+    """
+
+    if not sys.platform.startswith('linux'):
+        pytest.skip('link fails on cygwin')
+
+    prologue = '''
+        #include 
+        #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
+        #include 
+        #include 
+        #include 
+
+        NPY_NO_EXPORT
+        void delete_array_struct(PyObject *cap) {
+
+            /* get the array interface structure */
+            PyArrayInterface *inter = (PyArrayInterface*)
+                PyCapsule_GetPointer(cap, NULL);
+
+            /* get the buffer by which data was shared */
+            double *ptr = (double*)PyCapsule_GetContext(cap);
+
+            /* for the purposes of the regression test set the elements
+               to nan */
+            for (npy_intp i = 0; i < inter->shape[0]; ++i)
+                ptr[i] = nan("");
+
+            /* free the shared buffer */
+            free(ptr);
+
+            /* free the array interface structure */
+            free(inter->shape);
+            free(inter);
+
+            fprintf(stderr, "delete_array_struct\\ncap = %ld inter = %ld"
+                " ptr = %ld\\n", (long)cap, (long)inter, (long)ptr);
+        }
+        '''
+
+    functions = [
+        ("new_array_struct", "METH_VARARGS", """
+
+            long long n_elem = 0;
+            double value = 0.0;
+
+            if (!PyArg_ParseTuple(args, "Ld", &n_elem, &value)) {
+                Py_RETURN_NONE;
+            }
+
+            /* allocate and initialize the data to share with numpy */
+            long long n_bytes = n_elem*sizeof(double);
+            double *data = (double*)malloc(n_bytes);
+
+            if (!data) {
+                PyErr_Format(PyExc_MemoryError,
+                    "Failed to malloc %lld bytes", n_bytes);
+
+                Py_RETURN_NONE;
+            }
+
+            for (long long i = 0; i < n_elem; ++i) {
+                data[i] = value;
+            }
+
+            /* calculate the shape and stride */
+            int nd = 1;
+
+            npy_intp *ss = (npy_intp*)malloc(2*nd*sizeof(npy_intp));
+            npy_intp *shape = ss;
+            npy_intp *stride = ss + nd;
+
+            shape[0] = n_elem;
+            stride[0] = sizeof(double);
+
+            /* construct the array interface */
+            PyArrayInterface *inter = (PyArrayInterface*)
+                malloc(sizeof(PyArrayInterface));
+
+            memset(inter, 0, sizeof(PyArrayInterface));
+
+            inter->two = 2;
+            inter->nd = nd;
+            inter->typekind = 'f';
+            inter->itemsize = sizeof(double);
+            inter->shape = shape;
+            inter->strides = stride;
+            inter->data = data;
+            inter->flags = NPY_ARRAY_WRITEABLE | NPY_ARRAY_NOTSWAPPED |
+                           NPY_ARRAY_ALIGNED | NPY_ARRAY_C_CONTIGUOUS;
+
+            /* package into a capsule */
+            PyObject *cap = PyCapsule_New(inter, NULL, delete_array_struct);
+
+            /* save the pointer to the data */
+            PyCapsule_SetContext(cap, data);
+
+            fprintf(stderr, "new_array_struct\\ncap = %ld inter = %ld"
+                " ptr = %ld\\n", (long)cap, (long)inter, (long)data);
+
+            return cap;
+        """)
+        ]
+
+    more_init = "import_array();"
+
+    try:
+        import array_interface_testing
+        return array_interface_testing
+    except ImportError:
+        pass
+
+    # if it does not exist, build and load it
+    return extbuild.build_and_import_extension('array_interface_testing',
+                                               functions,
+                                               prologue=prologue,
+                                               include_dirs=[np.get_include()],
+                                               build_dir=tmp_path,
+                                               more_init=more_init)
+
+
+@pytest.mark.slow
+def test_cstruct(get_module):
+
+    class data_source:
+        """
+        This class is for testing the timing of the PyCapsule destructor
+        invoked when numpy release its reference to the shared data as part of
+        the numpy array interface protocol. If the PyCapsule destructor is
+        called early the shared data is freed and invalid memory accesses will
+        occur.
+        """
+
+        def __init__(self, size, value):
+            self.size = size
+            self.value = value
+
+        @property
+        def __array_struct__(self):
+            return get_module.new_array_struct(self.size, self.value)
+
+    # write to the same stream as the C code
+    stderr = sys.__stderr__
+
+    # used to validate the shared data.
+    expected_value = -3.1415
+    multiplier = -10000.0
+
+    # create some data to share with numpy via the array interface
+    # assign the data an expected value.
+    stderr.write(' ---- create an object to share data ---- \n')
+    buf = data_source(256, expected_value)
+    stderr.write(' ---- OK!\n\n')
+
+    # share the data
+    stderr.write(' ---- share data via the array interface protocol ---- \n')
+    arr = np.array(buf, copy=False)
+    stderr.write('arr.__array_interface___ = %s\n' % (
+                 str(arr.__array_interface__)))
+    stderr.write('arr.base = %s\n' % (str(arr.base)))
+    stderr.write(' ---- OK!\n\n')
+
+    # release the source of the shared data. this will not release the data
+    # that was shared with numpy, that is done in the PyCapsule destructor.
+    stderr.write(' ---- destroy the object that shared data ---- \n')
+    buf = None
+    stderr.write(' ---- OK!\n\n')
+
+    # check that we got the expected data. If the PyCapsule destructor we
+    # defined was prematurely called then this test will fail because our
+    # destructor sets the elements of the array to NaN before free'ing the
+    # buffer. Reading the values here may also cause a SEGV
+    assert np.allclose(arr, expected_value)
+
+    # read the data. If the PyCapsule destructor we defined was prematurely
+    # called then reading the values here may cause a SEGV and will be reported
+    # as invalid reads by valgrind
+    stderr.write(' ---- read shared data ---- \n')
+    stderr.write('arr = %s\n' % (str(arr)))
+    stderr.write(' ---- OK!\n\n')
+
+    # write to the shared buffer. If the shared data was prematurely deleted
+    # this will may cause a SEGV and valgrind will report invalid writes
+    stderr.write(' ---- modify shared data ---- \n')
+    arr *= multiplier
+    expected_value *= multiplier
+    stderr.write('arr.__array_interface___ = %s\n' % (
+                 str(arr.__array_interface__)))
+    stderr.write('arr.base = %s\n' % (str(arr.base)))
+    stderr.write(' ---- OK!\n\n')
+
+    # read the data. If the shared data was prematurely deleted this
+    # will may cause a SEGV and valgrind will report invalid reads
+    stderr.write(' ---- read modified shared data ---- \n')
+    stderr.write('arr = %s\n' % (str(arr)))
+    stderr.write(' ---- OK!\n\n')
+
+    # check that we got the expected data. If the PyCapsule destructor we
+    # defined was prematurely called then this test will fail because our
+    # destructor sets the elements of the array to NaN before free'ing the
+    # buffer. Reading the values here may also cause a SEGV
+    assert np.allclose(arr, expected_value)
+
+    # free the shared data, the PyCapsule destructor should run here
+    stderr.write(' ---- free shared data ---- \n')
+    arr = None
+    stderr.write(' ---- OK!\n\n')
diff --git a/numpy/core/tests/test_arraymethod.py b/numpy/core/tests/test_arraymethod.py
index 49aa9f6dfcfa..6b75d192121d 100644
--- a/numpy/core/tests/test_arraymethod.py
+++ b/numpy/core/tests/test_arraymethod.py
@@ -3,9 +3,11 @@
 this is private API, but when added, public API may be added here.
 """
 
+from __future__ import annotations
+
 import sys
 import types
-from typing import Any, Type
+from typing import Any
 
 import pytest
 
@@ -63,28 +65,25 @@ def test_invalid_arguments(self, args, error):
 
 
 @pytest.mark.skipif(sys.version_info < (3, 9), reason="Requires python 3.9")
+@pytest.mark.parametrize(
+    "cls", [np.ndarray, np.recarray, np.chararray, np.matrix, np.memmap]
+)
 class TestClassGetItem:
-    @pytest.mark.parametrize(
-        "cls", [np.ndarray, np.recarray, np.chararray, np.matrix, np.memmap]
-    )
-    def test_class_getitem(self, cls: Type[np.ndarray]) -> None:
+    def test_class_getitem(self, cls: type[np.ndarray]) -> None:
         """Test `ndarray.__class_getitem__`."""
         alias = cls[Any, Any]
         assert isinstance(alias, types.GenericAlias)
         assert alias.__origin__ is cls
 
     @pytest.mark.parametrize("arg_len", range(4))
-    def test_subscript_tuple(self, arg_len: int) -> None:
+    def test_subscript_tup(self, cls: type[np.ndarray], arg_len: int) -> None:
         arg_tup = (Any,) * arg_len
-        if arg_len == 2:
-            assert np.ndarray[arg_tup]
+        if arg_len in (1, 2):
+            assert cls[arg_tup]
         else:
-            with pytest.raises(TypeError):
-                np.ndarray[arg_tup]
-
-    def test_subscript_scalar(self) -> None:
-        with pytest.raises(TypeError):
-            np.ndarray[Any]
+            match = f"Too {'few' if arg_len == 0 else 'many'} arguments"
+            with pytest.raises(TypeError, match=match):
+                cls[arg_tup]
 
 
 @pytest.mark.skipif(sys.version_info >= (3, 9), reason="Requires python 3.8")
diff --git a/numpy/core/tests/test_arrayprint.py b/numpy/core/tests/test_arrayprint.py
index 25826d8eda3c..f1883f703d4a 100644
--- a/numpy/core/tests/test_arrayprint.py
+++ b/numpy/core/tests/test_arrayprint.py
@@ -498,10 +498,10 @@ def test_refcount(self):
 class TestPrintOptions:
     """Test getting and setting global print options."""
 
-    def setup(self):
+    def setup_method(self):
         self.oldopts = np.get_printoptions()
 
-    def teardown(self):
+    def teardown_method(self):
         np.set_printoptions(**self.oldopts)
 
     def test_basic(self):
@@ -549,7 +549,7 @@ def test_formatter_reset(self):
         assert_equal(repr(x), "array([0., 1., 2.])")
 
     def test_0d_arrays(self):
-        assert_equal(str(np.array(u'café', ' np.finfo("f8").max:
+        yield param(np.finfo(np.longdouble).max, "float64",
+                    id="longdouble-to-f8")
+
+    # Cast to complex32:
+    yield param(2e300, "complex64", id="float-to-c8")
+    yield param(2e300+0j, "complex64", id="complex-to-c8")
+    yield param(2e300j, "complex64", id="complex-to-c8")
+    yield param(np.longdouble(2e300), "complex64", id="longdouble-to-c8")
+
+    # Invalid float to integer casts:
+    with np.errstate(over="ignore"):
+        for to_dt in np.typecodes["AllInteger"]:
+            for value in [np.inf, np.nan]:
+                for from_dt in np.typecodes["AllFloat"]:
+                    from_dt = np.dtype(from_dt)
+                    from_val = from_dt.type(value)
+
+                    yield param(from_val, to_dt, id=f"{from_val}-to-{to_dt}")
+
+
+def check_operations(dtype, value):
+    """
+    There are many dedicated paths in NumPy which cast and should check for
+    floating point errors which occurred during those casts.
+    """
+    if dtype.kind != 'i':
+        # These assignments use the stricter setitem logic:
+        def assignment():
+            arr = np.empty(3, dtype=dtype)
+            arr[0] = value
+
+        yield assignment
+
+        def fill():
+            arr = np.empty(3, dtype=dtype)
+            arr.fill(value)
+
+        yield fill
+
+    def copyto_scalar():
+        arr = np.empty(3, dtype=dtype)
+        np.copyto(arr, value, casting="unsafe")
+
+    yield copyto_scalar
+
+    def copyto():
+        arr = np.empty(3, dtype=dtype)
+        np.copyto(arr, np.array([value, value, value]), casting="unsafe")
+
+    yield copyto
+
+    def copyto_scalar_masked():
+        arr = np.empty(3, dtype=dtype)
+        np.copyto(arr, value, casting="unsafe",
+                  where=[True, False, True])
+
+    yield copyto_scalar_masked
+
+    def copyto_masked():
+        arr = np.empty(3, dtype=dtype)
+        np.copyto(arr, np.array([value, value, value]), casting="unsafe",
+                  where=[True, False, True])
+
+    yield copyto_masked
+
+    def direct_cast():
+        np.array([value, value, value]).astype(dtype)
+
+    yield direct_cast
+
+    def direct_cast_nd_strided():
+        arr = np.full((5, 5, 5), fill_value=value)[:, ::2, :]
+        arr.astype(dtype)
+
+    yield direct_cast_nd_strided
+
+    def boolean_array_assignment():
+        arr = np.empty(3, dtype=dtype)
+        arr[[True, False, True]] = np.array([value, value])
+
+    yield boolean_array_assignment
+
+    def integer_array_assignment():
+        arr = np.empty(3, dtype=dtype)
+        values = np.array([value, value])
+
+        arr[[0, 1]] = values
+
+    yield integer_array_assignment
+
+    def integer_array_assignment_with_subspace():
+        arr = np.empty((5, 3), dtype=dtype)
+        values = np.array([value, value, value])
+
+        arr[[0, 2]] = values
+
+    yield integer_array_assignment_with_subspace
+
+    def flat_assignment():
+        arr = np.empty((3,), dtype=dtype)
+        values = np.array([value, value, value])
+        arr.flat[:] = values
+
+    yield flat_assignment
+
+@pytest.mark.skipif(IS_WASM, reason="no wasm fp exception support")
+@pytest.mark.parametrize(["value", "dtype"], values_and_dtypes())
+@pytest.mark.filterwarnings("ignore::numpy.ComplexWarning")
+def test_floatingpoint_errors_casting(dtype, value):
+    dtype = np.dtype(dtype)
+    for operation in check_operations(dtype, value):
+        dtype = np.dtype(dtype)
+
+        match = "invalid" if dtype.kind in 'iu' else "overflow"
+        with pytest.warns(RuntimeWarning, match=match):
+            operation()
+
+        with np.errstate(all="raise"):
+            with pytest.raises(FloatingPointError, match=match):
+                operation()
+
diff --git a/numpy/core/tests/test_casting_unittests.py b/numpy/core/tests/test_casting_unittests.py
index cb479209030b..a49d876d410b 100644
--- a/numpy/core/tests/test_casting_unittests.py
+++ b/numpy/core/tests/test_casting_unittests.py
@@ -10,6 +10,7 @@
 import textwrap
 import enum
 import random
+import ctypes
 
 import numpy as np
 from numpy.lib.stride_tricks import as_strided
@@ -76,7 +77,6 @@ class Casting(enum.IntEnum):
     safe = 2
     same_kind = 3
     unsafe = 4
-    cast_is_view = 1 << 16
 
 
 def _get_cancast_table():
@@ -169,6 +169,9 @@ def get_data(self, dtype1, dtype2):
 
         for i, value in enumerate(values):
             # Use item assignment to ensure this is not using casting:
+            if value < 0 and dtype1.kind == "u":
+                # Manually rollover unsigned integers (-1 -> int.max)
+                value = value + np.iinfo(dtype1).max + 1
             arr1[i] = value
 
         if dtype2 is None:
@@ -185,6 +188,9 @@ def get_data(self, dtype1, dtype2):
 
         for i, value in enumerate(values):
             # Use item assignment to ensure this is not using casting:
+            if value < 0 and dtype2.kind == "u":
+                # Manually rollover unsigned integers (-1 -> int.max)
+                value = value + np.iinfo(dtype2).max + 1
             arr2[i] = value
 
         return arr1, arr2, values
@@ -259,14 +265,14 @@ def test_simple_cancast(self, from_Dt):
                 del default
 
                 for to_dt in [to_Dt(), to_Dt().newbyteorder()]:
-                    casting, (from_res, to_res) = cast._resolve_descriptors(
-                        (from_dt, to_dt))
+                    casting, (from_res, to_res), view_off = (
+                            cast._resolve_descriptors((from_dt, to_dt)))
                     assert(type(from_res) == from_Dt)
                     assert(type(to_res) == to_Dt)
-                    if casting & Casting.cast_is_view:
+                    if view_off is not None:
                         # If a view is acceptable, this is "no" casting
                         # and byte order must be matching.
-                        assert casting == Casting.no | Casting.cast_is_view
+                        assert casting == Casting.no
                         # The above table lists this as "equivalent"
                         assert Casting.equiv == CAST_TABLE[from_Dt][to_Dt]
                         # Note that to_res may not be the same as from_dt
@@ -299,7 +305,7 @@ def test_simple_direct_casts(self, from_dt):
             to_dt = to_dt.values[0]
             cast = get_castingimpl(type(from_dt), type(to_dt))
 
-            casting, (from_res, to_res) = cast._resolve_descriptors(
+            casting, (from_res, to_res), view_off = cast._resolve_descriptors(
                 (from_dt, to_dt))
 
             if from_res is not from_dt or to_res is not to_dt:
@@ -307,7 +313,7 @@ def test_simple_direct_casts(self, from_dt):
                 # each of which should is tested individually.
                 return
 
-            safe = (casting & ~Casting.cast_is_view) <= Casting.safe
+            safe = casting <= Casting.safe
             del from_res, to_res, casting
 
             arr1, arr2, values = self.get_data(from_dt, to_dt)
@@ -355,14 +361,15 @@ def test_numeric_to_times(self, from_Dt):
         for time_dt in time_dtypes:
             cast = get_castingimpl(type(from_dt), type(time_dt))
 
-            casting, (from_res, to_res) = cast._resolve_descriptors(
+            casting, (from_res, to_res), view_off = cast._resolve_descriptors(
                 (from_dt, time_dt))
 
             assert from_res is from_dt
             assert to_res is time_dt
             del from_res, to_res
 
-            assert(casting & CAST_TABLE[from_Dt][type(time_dt)])
+            assert casting & CAST_TABLE[from_Dt][type(time_dt)]
+            assert view_off is None
 
             int64_dt = np.dtype(np.int64)
             arr1, arr2, values = self.get_data(from_dt, int64_dt)
@@ -391,31 +398,37 @@ def test_numeric_to_times(self, from_Dt):
             assert arr2_o.tobytes() == arr2.tobytes()
 
     @pytest.mark.parametrize(
-            ["from_dt", "to_dt", "expected_casting", "nom", "denom"],
-            [("M8[ns]", None,
-                  Casting.no | Casting.cast_is_view, 1, 1),
-             (str(np.dtype("M8[ns]").newbyteorder()), None, Casting.equiv, 1, 1),
-             ("M8", "M8[ms]", Casting.safe | Casting.cast_is_view, 1, 1),
-             ("M8[ms]", "M8", Casting.unsafe, 1, 1),  # should be invalid cast
-             ("M8[5ms]", "M8[5ms]", Casting.no | Casting.cast_is_view, 1, 1),
-             ("M8[ns]", "M8[ms]", Casting.same_kind, 1, 10**6),
-             ("M8[ms]", "M8[ns]", Casting.safe, 10**6, 1),
-             ("M8[ms]", "M8[7ms]", Casting.same_kind, 1, 7),
-             ("M8[4D]", "M8[1M]", Casting.same_kind, None,
+            ["from_dt", "to_dt", "expected_casting", "expected_view_off",
+             "nom", "denom"],
+            [("M8[ns]", None, Casting.no, 0, 1, 1),
+             (str(np.dtype("M8[ns]").newbyteorder()), None,
+                  Casting.equiv, None, 1, 1),
+             ("M8", "M8[ms]", Casting.safe, 0, 1, 1),
+             # should be invalid cast:
+             ("M8[ms]", "M8", Casting.unsafe, None, 1, 1),
+             ("M8[5ms]", "M8[5ms]", Casting.no, 0, 1, 1),
+             ("M8[ns]", "M8[ms]", Casting.same_kind, None, 1, 10**6),
+             ("M8[ms]", "M8[ns]", Casting.safe, None, 10**6, 1),
+             ("M8[ms]", "M8[7ms]", Casting.same_kind, None, 1, 7),
+             ("M8[4D]", "M8[1M]", Casting.same_kind, None, None,
                   # give full values based on NumPy 1.19.x
                   [-2**63, 0, -1, 1314, -1315, 564442610]),
-             ("m8[ns]", None, Casting.no | Casting.cast_is_view, 1, 1),
-             (str(np.dtype("m8[ns]").newbyteorder()), None, Casting.equiv, 1, 1),
-             ("m8", "m8[ms]", Casting.safe | Casting.cast_is_view, 1, 1),
-             ("m8[ms]", "m8", Casting.unsafe, 1, 1),  # should be invalid cast
-             ("m8[5ms]", "m8[5ms]", Casting.no | Casting.cast_is_view, 1, 1),
-             ("m8[ns]", "m8[ms]", Casting.same_kind, 1, 10**6),
-             ("m8[ms]", "m8[ns]", Casting.safe, 10**6, 1),
-             ("m8[ms]", "m8[7ms]", Casting.same_kind, 1, 7),
-             ("m8[4D]", "m8[1M]", Casting.unsafe, None,
+             ("m8[ns]", None, Casting.no, 0, 1, 1),
+             (str(np.dtype("m8[ns]").newbyteorder()), None,
+                  Casting.equiv, None, 1, 1),
+             ("m8", "m8[ms]", Casting.safe, 0, 1, 1),
+             # should be invalid cast:
+             ("m8[ms]", "m8", Casting.unsafe, None, 1, 1),
+             ("m8[5ms]", "m8[5ms]", Casting.no, 0, 1, 1),
+             ("m8[ns]", "m8[ms]", Casting.same_kind, None, 1, 10**6),
+             ("m8[ms]", "m8[ns]", Casting.safe, None, 10**6, 1),
+             ("m8[ms]", "m8[7ms]", Casting.same_kind, None, 1, 7),
+             ("m8[4D]", "m8[1M]", Casting.unsafe, None, None,
                   # give full values based on NumPy 1.19.x
                   [-2**63, 0, 0, 1314, -1315, 564442610])])
-    def test_time_to_time(self, from_dt, to_dt, expected_casting, nom, denom):
+    def test_time_to_time(self, from_dt, to_dt,
+                          expected_casting, expected_view_off,
+                          nom, denom):
         from_dt = np.dtype(from_dt)
         if to_dt is not None:
             to_dt = np.dtype(to_dt)
@@ -428,10 +441,12 @@ def test_time_to_time(self, from_dt, to_dt, expected_casting, nom, denom):
 
         DType = type(from_dt)
         cast = get_castingimpl(DType, DType)
-        casting, (from_res, to_res) = cast._resolve_descriptors((from_dt, to_dt))
+        casting, (from_res, to_res), view_off = cast._resolve_descriptors(
+                (from_dt, to_dt))
         assert from_res is from_dt
         assert to_res is to_dt or to_dt is None
         assert casting == expected_casting
+        assert view_off == expected_view_off
 
         if nom is not None:
             expected_out = (values * nom // denom).view(to_res)
@@ -476,9 +491,11 @@ def test_string_cancast(self, other_DT, string_char):
         expected_length = get_expected_stringlength(other_dt)
         string_dt = np.dtype(f"{string_char}{expected_length}")
 
-        safety, (res_other_dt, res_dt) = cast._resolve_descriptors((other_dt, None))
+        safety, (res_other_dt, res_dt), view_off = cast._resolve_descriptors(
+                (other_dt, None))
         assert res_dt.itemsize == expected_length * fact
         assert safety == Casting.safe  # we consider to string casts "safe"
+        assert view_off is None
         assert isinstance(res_dt, string_DT)
 
         # These casts currently implement changing the string length, so
@@ -490,19 +507,24 @@ def test_string_cancast(self, other_DT, string_char):
                 expected_safety = Casting.same_kind
 
             to_dt = self.string_with_modified_length(string_dt, change_length)
-            safety, (_, res_dt) = cast._resolve_descriptors((other_dt, to_dt))
+            safety, (_, res_dt), view_off = cast._resolve_descriptors(
+                    (other_dt, to_dt))
             assert res_dt is to_dt
             assert safety == expected_safety
+            assert view_off is None
 
         # The opposite direction is always considered unsafe:
         cast = get_castingimpl(string_DT, other_DT)
 
-        safety, _ = cast._resolve_descriptors((string_dt, other_dt))
+        safety, _, view_off = cast._resolve_descriptors((string_dt, other_dt))
         assert safety == Casting.unsafe
+        assert view_off is None
 
         cast = get_castingimpl(string_DT, other_DT)
-        safety, (_, res_dt) = cast._resolve_descriptors((string_dt, None))
+        safety, (_, res_dt), view_off = cast._resolve_descriptors(
+            (string_dt, None))
         assert safety == Casting.unsafe
+        assert view_off is None
         assert other_dt is res_dt  # returns the singleton for simple dtypes
 
     @pytest.mark.parametrize("string_char", ["S", "U"])
@@ -521,7 +543,8 @@ def test_simple_string_casts_roundtrip(self, other_dt, string_char):
 
         cast = get_castingimpl(type(other_dt), string_DT)
         cast_back = get_castingimpl(string_DT, type(other_dt))
-        _, (res_other_dt, string_dt) = cast._resolve_descriptors((other_dt, None))
+        _, (res_other_dt, string_dt), _ = cast._resolve_descriptors(
+                (other_dt, None))
 
         if res_other_dt is not other_dt:
             # do not support non-native byteorder, skip test in that case
@@ -580,13 +603,16 @@ def test_string_to_string_cancast(self, other_dt, string_char):
         expected_length = other_dt.itemsize // div
         string_dt = np.dtype(f"{string_char}{expected_length}")
 
-        safety, (res_other_dt, res_dt) = cast._resolve_descriptors((other_dt, None))
+        safety, (res_other_dt, res_dt), view_off = cast._resolve_descriptors(
+                (other_dt, None))
         assert res_dt.itemsize == expected_length * fact
         assert isinstance(res_dt, string_DT)
 
+        expected_view_off = None
         if other_dt.char == string_char:
             if other_dt.isnative:
-                expected_safety = Casting.no | Casting.cast_is_view
+                expected_safety = Casting.no
+                expected_view_off = 0
             else:
                 expected_safety = Casting.equiv
         elif string_char == "U":
@@ -594,13 +620,19 @@ def test_string_to_string_cancast(self, other_dt, string_char):
         else:
             expected_safety = Casting.unsafe
 
+        assert view_off == expected_view_off
         assert expected_safety == safety
 
         for change_length in [-1, 0, 1]:
             to_dt = self.string_with_modified_length(string_dt, change_length)
-            safety, (_, res_dt) = cast._resolve_descriptors((other_dt, to_dt))
+            safety, (_, res_dt), view_off = cast._resolve_descriptors(
+                    (other_dt, to_dt))
 
             assert res_dt is to_dt
+            if change_length <= 0:
+                assert view_off == expected_view_off
+            else:
+                assert view_off is None
             if expected_safety == Casting.unsafe:
                 assert safety == expected_safety
             elif change_length < 0:
@@ -655,12 +687,16 @@ def test_object_and_simple_resolution(self, dtype):
         object_dtype = type(np.dtype(object))
         cast = get_castingimpl(object_dtype, type(dtype))
 
-        safety, (_, res_dt) = cast._resolve_descriptors((np.dtype("O"), dtype))
+        safety, (_, res_dt), view_off = cast._resolve_descriptors(
+                (np.dtype("O"), dtype))
         assert safety == Casting.unsafe
+        assert view_off is None
         assert res_dt is dtype
 
-        safety, (_, res_dt) = cast._resolve_descriptors((np.dtype("O"), None))
+        safety, (_, res_dt), view_off = cast._resolve_descriptors(
+                (np.dtype("O"), None))
         assert safety == Casting.unsafe
+        assert view_off is None
         assert res_dt == dtype.newbyteorder("=")
 
     @pytest.mark.parametrize("dtype", simple_dtype_instances())
@@ -669,8 +705,10 @@ def test_simple_to_object_resolution(self, dtype):
         object_dtype = type(np.dtype(object))
         cast = get_castingimpl(type(dtype), object_dtype)
 
-        safety, (_, res_dt) = cast._resolve_descriptors((dtype, None))
+        safety, (_, res_dt), view_off = cast._resolve_descriptors(
+                (dtype, None))
         assert safety == Casting.safe
+        assert view_off is None
         assert res_dt is np.dtype("O")
 
     @pytest.mark.parametrize("casting", ["no", "unsafe"])
@@ -681,12 +719,82 @@ def test_void_and_structured_with_subarray(self, casting):
         assert np.can_cast("V4", dtype, casting=casting) == expected
         assert np.can_cast(dtype, "V4", casting=casting) == expected
 
+    @pytest.mark.parametrize(["to_dt", "expected_off"],
+            [  # Same as `from_dt` but with both fields shifted:
+             (np.dtype({"names": ["a", "b"], "formats": ["i4", "f4"],
+                        "offsets": [0, 4]}), 2),
+             # Additional change of the names
+             (np.dtype({"names": ["b", "a"], "formats": ["i4", "f4"],
+                        "offsets": [0, 4]}), 2),
+             # Incompatible field offset change
+             (np.dtype({"names": ["b", "a"], "formats": ["i4", "f4"],
+                        "offsets": [0, 6]}), None)])
+    def test_structured_field_offsets(self, to_dt, expected_off):
+        # This checks the cast-safety and view offset for swapped and "shifted"
+        # fields which are viewable
+        from_dt = np.dtype({"names": ["a", "b"],
+                            "formats": ["i4", "f4"],
+                            "offsets": [2, 6]})
+        cast = get_castingimpl(type(from_dt), type(to_dt))
+        safety, _, view_off = cast._resolve_descriptors((from_dt, to_dt))
+        if from_dt.names == to_dt.names:
+            assert safety == Casting.equiv
+        else:
+            assert safety == Casting.safe
+        # Shifting the original data pointer by -2 will align both by
+        # effectively adding 2 bytes of spacing before `from_dt`.
+        assert view_off == expected_off
+
+    @pytest.mark.parametrize(("from_dt", "to_dt", "expected_off"), [
+            # Subarray cases:
+            ("i", "(1,1)i", 0),
+            ("(1,1)i", "i", 0),
+            ("(2,1)i", "(2,1)i", 0),
+            # field cases (field to field is tested explicitly also):
+            # Not considered viewable, because a negative offset would allow
+            # may structured dtype to indirectly access invalid memory.
+            ("i", dict(names=["a"], formats=["i"], offsets=[2]), None),
+            (dict(names=["a"], formats=["i"], offsets=[2]), "i", 2),
+            # Currently considered not viewable, due to multiple fields
+            # even though they overlap (maybe we should not allow that?)
+            ("i", dict(names=["a", "b"], formats=["i", "i"], offsets=[2, 2]),
+             None),
+            # different number of fields can't work, should probably just fail
+            # so it never reports "viewable":
+            ("i,i", "i,i,i", None),
+            # Unstructured void cases:
+            ("i4", "V3", 0),  # void smaller or equal
+            ("i4", "V4", 0),  # void smaller or equal
+            ("i4", "V10", None),  # void is larger (no view)
+            ("O", "V4", None),  # currently reject objects for view here.
+            ("O", "V8", None),  # currently reject objects for view here.
+            ("V4", "V3", 0),
+            ("V4", "V4", 0),
+            ("V3", "V4", None),
+            # Note that currently void-to-other cast goes via byte-strings
+            # and is not a "view" based cast like the opposite direction:
+            ("V4", "i4", None),
+            # completely invalid/impossible cast:
+            ("i,i", "i,i,i", None),
+        ])
+    def test_structured_view_offsets_paramteric(
+            self, from_dt, to_dt, expected_off):
+        # TODO: While this test is fairly thorough, right now, it does not
+        # really test some paths that may have nonzero offsets (they don't
+        # really exists).
+        from_dt = np.dtype(from_dt)
+        to_dt = np.dtype(to_dt)
+        cast = get_castingimpl(type(from_dt), type(to_dt))
+        _, _, view_off = cast._resolve_descriptors((from_dt, to_dt))
+        assert view_off == expected_off
+
     @pytest.mark.parametrize("dtype", np.typecodes["All"])
     def test_object_casts_NULL_None_equivalence(self, dtype):
         # None to  casts may succeed or fail, but a NULL'ed array must
         # behave the same as one filled with None's.
         arr_normal = np.array([None] * 5)
-        arr_NULLs = np.empty_like([None] * 5)
+        arr_NULLs = np.empty_like(arr_normal)
+        ctypes.memset(arr_NULLs.ctypes.data, 0, arr_NULLs.nbytes)
         # If the check fails (maybe it should) the test would lose its purpose:
         assert arr_NULLs.tobytes() == b"\x00" * arr_NULLs.nbytes
 
diff --git a/numpy/core/tests/test_conversion_utils.py b/numpy/core/tests/test_conversion_utils.py
index d8849ee29b0b..c602eba4bb28 100644
--- a/numpy/core/tests/test_conversion_utils.py
+++ b/numpy/core/tests/test_conversion_utils.py
@@ -2,12 +2,13 @@
 Tests for numpy/core/src/multiarray/conversion_utils.c
 """
 import re
+import sys
 
 import pytest
 
 import numpy as np
 import numpy.core._multiarray_tests as mt
-from numpy.testing import assert_warns
+from numpy.testing import assert_warns, IS_PYPY
 
 
 class StringConverterTestCase:
@@ -189,6 +190,8 @@ def test_none(self):
         with pytest.warns(DeprecationWarning):
             assert self.conv(None) == ()
 
+    @pytest.mark.skipif(IS_PYPY and sys.implementation.version <= (7, 3, 8),
+            reason="PyPy bug in error formatting")
     def test_float(self):
         with pytest.raises(TypeError):
             self.conv(1.0)
diff --git a/numpy/core/tests/test_cpu_features.py b/numpy/core/tests/test_cpu_features.py
index 2ccbff41ca63..1a76897e206c 100644
--- a/numpy/core/tests/test_cpu_features.py
+++ b/numpy/core/tests/test_cpu_features.py
@@ -140,12 +140,23 @@ def load_flags(self):
 is_power = re.match("^(powerpc|ppc)64", machine, re.IGNORECASE)
 @pytest.mark.skipif(not is_linux or not is_power, reason="Only for Linux and Power")
 class Test_POWER_Features(AbstractTest):
-    features = ["VSX", "VSX2", "VSX3"]
-    features_map = dict(VSX2="ARCH_2_07", VSX3="ARCH_3_00")
+    features = ["VSX", "VSX2", "VSX3", "VSX4"]
+    features_map = dict(VSX2="ARCH_2_07", VSX3="ARCH_3_00", VSX4="ARCH_3_1")
 
     def load_flags(self):
         self.load_flags_auxv()
 
+
+is_zarch = re.match("^(s390x)", machine, re.IGNORECASE)
+@pytest.mark.skipif(not is_linux or not is_zarch,
+                    reason="Only for Linux and IBM Z")
+class Test_ZARCH_Features(AbstractTest):
+    features = ["VX", "VXE", "VXE2"]
+
+    def load_flags(self):
+        self.load_flags_auxv()
+
+
 is_arm = re.match("^(arm|aarch64)", machine, re.IGNORECASE)
 @pytest.mark.skipif(not is_linux or not is_arm, reason="Only for Linux and ARM")
 class Test_ARM_Features(AbstractTest):
diff --git a/numpy/core/tests/test_cython.py b/numpy/core/tests/test_cython.py
index a1f09d0fef12..f4aac4a36eae 100644
--- a/numpy/core/tests/test_cython.py
+++ b/numpy/core/tests/test_cython.py
@@ -5,6 +5,7 @@
 import pytest
 
 import numpy as np
+from numpy.testing import IS_WASM
 
 # This import is copied from random.tests.test_extending
 try:
@@ -13,14 +14,14 @@
 except ImportError:
     cython = None
 else:
-    from distutils.version import LooseVersion
+    from numpy.compat import _pep440
 
-    # Cython 0.29.21 is required for Python 3.9 and there are
+    # Cython 0.29.30 is required for Python 3.11 and there are
     # other fixes in the 0.29 series that are needed even for earlier
     # Python versions.
     # Note: keep in sync with the one in pyproject.toml
-    required_version = LooseVersion("0.29.21")
-    if LooseVersion(cython_version) < required_version:
+    required_version = "0.29.30"
+    if _pep440.parse(cython_version) < _pep440.Version(required_version):
         # too old or wrong cython, skip the test
         cython = None
 
@@ -30,9 +31,11 @@
 @pytest.fixture
 def install_temp(request, tmp_path):
     # Based in part on test_cython from random.tests.test_extending
+    if IS_WASM:
+        pytest.skip("No subprocess")
 
     here = os.path.dirname(__file__)
-    ext_dir = os.path.join(here, "examples")
+    ext_dir = os.path.join(here, "examples", "cython")
 
     cytest = str(tmp_path / "cytest")
 
@@ -40,7 +43,7 @@ def install_temp(request, tmp_path):
     # build the examples and "install" them into a temporary directory
 
     install_log = str(tmp_path / "tmp_install_log.txt")
-    subprocess.check_call(
+    subprocess.check_output(
         [
             sys.executable,
             "setup.py",
diff --git a/numpy/core/tests/test_datetime.py b/numpy/core/tests/test_datetime.py
index b95d669a855a..da4a9b0fd9d0 100644
--- a/numpy/core/tests/test_datetime.py
+++ b/numpy/core/tests/test_datetime.py
@@ -4,6 +4,7 @@
 import datetime
 import pytest
 from numpy.testing import (
+    IS_WASM,
     assert_, assert_equal, assert_raises, assert_warns, suppress_warnings,
     assert_raises_regex, assert_array_equal,
     )
@@ -1294,6 +1295,7 @@ def check(a, b, res):
     def test_timedelta_floor_divide(self, op1, op2, exp):
         assert_equal(op1 // op2, exp)
 
+    @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm")
     @pytest.mark.parametrize("op1, op2", [
         # div by 0
         (np.timedelta64(10, 'us'),
@@ -1368,6 +1370,7 @@ def test_timedelta_divmod(self, op1, op2):
         expected = (op1 // op2, op1 % op2)
         assert_equal(divmod(op1, op2), expected)
 
+    @pytest.mark.skipif(IS_WASM, reason="does not work in wasm")
     @pytest.mark.parametrize("op1, op2", [
         # reuse cases from floordiv
         # div by 0
@@ -1437,7 +1440,7 @@ def test_datetime_divide(self):
 
         # NaTs
         with suppress_warnings() as sup:
-            sup.filter(RuntimeWarning,  r".*encountered in true\_divide")
+            sup.filter(RuntimeWarning,  r".*encountered in divide")
             nat = np.timedelta64('NaT')
             for tp in (int, float):
                 assert_equal(np.timedelta64(1) / tp(0), nat)
@@ -1993,6 +1996,7 @@ def test_timedelta_modulus_error(self, val1, val2):
         with assert_raises_regex(TypeError, "common metadata divisor"):
             val1 % val2
 
+    @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm")
     def test_timedelta_modulus_div_by_zero(self):
         with assert_warns(RuntimeWarning):
             actual = np.timedelta64(10, 's') % np.timedelta64(0, 's')
@@ -2029,19 +2033,25 @@ def test_datetime_maximum_reduce(self):
         assert_equal(np.maximum.reduce(a),
                      np.timedelta64(7, 's'))
 
+    def test_timedelta_correct_mean(self):
+        # test mainly because it worked only via a bug in that allowed:
+        # `timedelta.sum(dtype="f8")` to ignore the dtype request.
+        a = np.arange(1000, dtype="m8[s]")
+        assert_array_equal(a.mean(), a.sum() / len(a))
+
     def test_datetime_no_subtract_reducelike(self):
         # subtracting two datetime64 works, but we cannot reduce it, since
         # the result of that subtraction will have a different dtype.
         arr = np.array(["2021-12-02", "2019-05-12"], dtype="M8[ms]")
-        msg = r"the resolved dtypes are not compatible with subtract\."
+        msg = r"the resolved dtypes are not compatible"
 
-        with pytest.raises(TypeError, match=msg + "reduce"):
+        with pytest.raises(TypeError, match=msg):
             np.subtract.reduce(arr)
 
-        with pytest.raises(TypeError, match=msg + "accumulate"):
+        with pytest.raises(TypeError, match=msg):
             np.subtract.accumulate(arr)
 
-        with pytest.raises(TypeError, match=msg + "reduceat"):
+        with pytest.raises(TypeError, match=msg):
             np.subtract.reduceat(arr, [0])
 
     def test_datetime_busday_offset(self):
@@ -2520,3 +2530,23 @@ def test_non_ascii(self):
 
         dt = np.datetime64('2000', '5μs')
         assert np.datetime_data(dt.dtype) == ('us', 5)
+
+
+def test_comparisons_return_not_implemented():
+    # GH#17017
+
+    class custom:
+        __array_priority__ = 10000
+
+    obj = custom()
+
+    dt = np.datetime64('2000', 'ns')
+    td = dt - dt
+
+    for item in [dt, td]:
+        assert item.__eq__(obj) is NotImplemented
+        assert item.__ne__(obj) is NotImplemented
+        assert item.__le__(obj) is NotImplemented
+        assert item.__lt__(obj) is NotImplemented
+        assert item.__ge__(obj) is NotImplemented
+        assert item.__gt__(obj) is NotImplemented
diff --git a/numpy/core/tests/test_defchararray.py b/numpy/core/tests/test_defchararray.py
index 59fc54722397..22296604ee5c 100644
--- a/numpy/core/tests/test_defchararray.py
+++ b/numpy/core/tests/test_defchararray.py
@@ -1,4 +1,3 @@
-
 import numpy as np
 from numpy.core.multiarray import _vec_string
 from numpy.testing import (
@@ -19,12 +18,12 @@ def test_from_object_array(self):
                                [b'long', b'0123456789']])
 
     def test_from_object_array_unicode(self):
-        A = np.array([['abc', u'Sigma \u03a3'],
+        A = np.array([['abc', 'Sigma \u03a3'],
                       ['long   ', '0123456789']], dtype='O')
         assert_raises(ValueError, np.char.array, (A,))
         B = np.char.array(A, **kw_unicode_true)
         assert_equal(B.dtype.itemsize, 10 * np.array('a', 'U').dtype.itemsize)
-        assert_array_equal(B, [['abc', u'Sigma \u03a3'],
+        assert_array_equal(B, [['abc', 'Sigma \u03a3'],
                                ['long', '0123456789']])
 
     def test_from_string_array(self):
@@ -45,7 +44,7 @@ def test_from_string_array(self):
         assert_(C[0, 0] == A[0, 0])
 
     def test_from_unicode_array(self):
-        A = np.array([['abc', u'Sigma \u03a3'],
+        A = np.array([['abc', 'Sigma \u03a3'],
                       ['long   ', '0123456789']])
         assert_equal(A.dtype.type, np.unicode_)
         B = np.char.array(A)
@@ -64,7 +63,7 @@ def fail():
 
     def test_unicode_upconvert(self):
         A = np.char.array(['abc'])
-        B = np.char.array([u'\u03a3'])
+        B = np.char.array(['\u03a3'])
         assert_(issubclass((A + B).dtype.type, np.unicode_))
 
     def test_from_string(self):
@@ -74,7 +73,7 @@ def test_from_string(self):
         assert_(issubclass(A.dtype.type, np.string_))
 
     def test_from_unicode(self):
-        A = np.char.array(u'\u03a3')
+        A = np.char.array('\u03a3')
         assert_equal(len(A), 1)
         assert_equal(len(A[0]), 1)
         assert_equal(A.itemsize, 4)
@@ -132,7 +131,7 @@ def fail():
 
 
 class TestWhitespace:
-    def setup(self):
+    def setup_method(self):
         self.A = np.array([['abc ', '123  '],
                            ['789 ', 'xyz ']]).view(np.chararray)
         self.B = np.array([['abc', '123'],
@@ -147,7 +146,7 @@ def test1(self):
         assert_(not np.any(self.A != self.B))
 
 class TestChar:
-    def setup(self):
+    def setup_method(self):
         self.A = np.array('abc1', dtype='c').view(np.chararray)
 
     def test_it(self):
@@ -155,7 +154,7 @@ def test_it(self):
         assert_equal(self.A.upper()[:2].tobytes(), b'AB')
 
 class TestComparisons:
-    def setup(self):
+    def setup_method(self):
         self.A = np.array([['abc', '123'],
                            ['789', 'xyz']]).view(np.chararray)
         self.B = np.array([['efg', '123  '],
@@ -188,27 +187,27 @@ def test_type(self):
 class TestComparisonsMixed1(TestComparisons):
     """Ticket #1276"""
 
-    def setup(self):
-        TestComparisons.setup(self)
+    def setup_method(self):
+        TestComparisons.setup_method(self)
         self.B = np.array([['efg', '123  '],
                            ['051', 'tuv']], np.unicode_).view(np.chararray)
 
 class TestComparisonsMixed2(TestComparisons):
     """Ticket #1276"""
 
-    def setup(self):
-        TestComparisons.setup(self)
+    def setup_method(self):
+        TestComparisons.setup_method(self)
         self.A = np.array([['abc', '123'],
                            ['789', 'xyz']], np.unicode_).view(np.chararray)
 
 class TestInformation:
-    def setup(self):
+    def setup_method(self):
         self.A = np.array([[' abc ', ''],
                            ['12345', 'MixedCase'],
                            ['123 \t 345 \0 ', 'UPPER']]).view(np.chararray)
-        self.B = np.array([[u' \u03a3 ', u''],
-                           [u'12345', u'MixedCase'],
-                           [u'123 \t 345 \0 ', u'UPPER']]).view(np.chararray)
+        self.B = np.array([[' \u03a3 ', ''],
+                           ['12345', 'MixedCase'],
+                           ['123 \t 345 \0 ', 'UPPER']]).view(np.chararray)
 
     def test_len(self):
         assert_(issubclass(np.char.str_len(self.A).dtype.type, np.integer))
@@ -308,14 +307,14 @@ def fail():
 
 
 class TestMethods:
-    def setup(self):
+    def setup_method(self):
         self.A = np.array([[' abc ', ''],
                            ['12345', 'MixedCase'],
                            ['123 \t 345 \0 ', 'UPPER']],
                           dtype='S').view(np.chararray)
-        self.B = np.array([[u' \u03a3 ', u''],
-                           [u'12345', u'MixedCase'],
-                           [u'123 \t 345 \0 ', u'UPPER']]).view(np.chararray)
+        self.B = np.array([[' \u03a3 ', ''],
+                           ['12345', 'MixedCase'],
+                           ['123 \t 345 \0 ', 'UPPER']]).view(np.chararray)
 
     def test_capitalize(self):
         tgt = [[b' abc ', b''],
@@ -324,7 +323,7 @@ def test_capitalize(self):
         assert_(issubclass(self.A.capitalize().dtype.type, np.string_))
         assert_array_equal(self.A.capitalize(), tgt)
 
-        tgt = [[u' \u03c3 ', ''],
+        tgt = [[' \u03c3 ', ''],
                ['12345', 'Mixedcase'],
                ['123 \t 345 \0 ', 'Upper']]
         assert_(issubclass(self.B.capitalize().dtype.type, np.unicode_))
@@ -393,9 +392,9 @@ def test_lower(self):
         assert_(issubclass(self.A.lower().dtype.type, np.string_))
         assert_array_equal(self.A.lower(), tgt)
 
-        tgt = [[u' \u03c3 ', u''],
-               [u'12345', u'mixedcase'],
-               [u'123 \t 345 \0 ', u'upper']]
+        tgt = [[' \u03c3 ', ''],
+               ['12345', 'mixedcase'],
+               ['123 \t 345 \0 ', 'upper']]
         assert_(issubclass(self.B.lower().dtype.type, np.unicode_))
         assert_array_equal(self.B.lower(), tgt)
 
@@ -411,7 +410,7 @@ def test_lstrip(self):
                [b'23 \t 345 \x00', b'UPPER']]
         assert_array_equal(self.A.lstrip([b'1', b'M']), tgt)
 
-        tgt = [[u'\u03a3 ', ''],
+        tgt = [['\u03a3 ', ''],
                ['12345', 'MixedCase'],
                ['123 \t 345 \0 ', 'UPPER']]
         assert_(issubclass(self.B.lstrip().dtype.type, np.unicode_))
@@ -481,7 +480,7 @@ def test_rstrip(self):
                ]
         assert_array_equal(self.A.rstrip([b'5', b'ER']), tgt)
 
-        tgt = [[u' \u03a3', ''],
+        tgt = [[' \u03a3', ''],
                ['12345', 'MixedCase'],
                ['123 \t 345', 'UPPER']]
         assert_(issubclass(self.B.rstrip().dtype.type, np.unicode_))
@@ -499,7 +498,7 @@ def test_strip(self):
                [b'23 \t 345 \x00', b'UPP']]
         assert_array_equal(self.A.strip([b'15', b'EReM']), tgt)
 
-        tgt = [[u'\u03a3', ''],
+        tgt = [['\u03a3', ''],
                ['12345', 'MixedCase'],
                ['123 \t 345', 'UPPER']]
         assert_(issubclass(self.B.strip().dtype.type, np.unicode_))
@@ -527,9 +526,9 @@ def test_swapcase(self):
         assert_(issubclass(self.A.swapcase().dtype.type, np.string_))
         assert_array_equal(self.A.swapcase(), tgt)
 
-        tgt = [[u' \u03c3 ', u''],
-               [u'12345', u'mIXEDcASE'],
-               [u'123 \t 345 \0 ', u'upper']]
+        tgt = [[' \u03c3 ', ''],
+               ['12345', 'mIXEDcASE'],
+               ['123 \t 345 \0 ', 'upper']]
         assert_(issubclass(self.B.swapcase().dtype.type, np.unicode_))
         assert_array_equal(self.B.swapcase(), tgt)
 
@@ -540,9 +539,9 @@ def test_title(self):
         assert_(issubclass(self.A.title().dtype.type, np.string_))
         assert_array_equal(self.A.title(), tgt)
 
-        tgt = [[u' \u03a3 ', u''],
-               [u'12345', u'Mixedcase'],
-               [u'123 \t 345 \0 ', u'Upper']]
+        tgt = [[' \u03a3 ', ''],
+               ['12345', 'Mixedcase'],
+               ['123 \t 345 \0 ', 'Upper']]
         assert_(issubclass(self.B.title().dtype.type, np.unicode_))
         assert_array_equal(self.B.title(), tgt)
 
@@ -553,9 +552,9 @@ def test_upper(self):
         assert_(issubclass(self.A.upper().dtype.type, np.string_))
         assert_array_equal(self.A.upper(), tgt)
 
-        tgt = [[u' \u03a3 ', u''],
-               [u'12345', u'MIXEDCASE'],
-               [u'123 \t 345 \0 ', u'UPPER']]
+        tgt = [[' \u03a3 ', ''],
+               ['12345', 'MIXEDCASE'],
+               ['123 \t 345 \0 ', 'UPPER']]
         assert_(issubclass(self.B.upper().dtype.type, np.unicode_))
         assert_array_equal(self.B.upper(), tgt)
 
@@ -581,7 +580,7 @@ def fail():
 
 
 class TestOperations:
-    def setup(self):
+    def setup_method(self):
         self.A = np.array([['abc', '123'],
                            ['789', 'xyz']]).view(np.chararray)
         self.B = np.array([['efg', '456'],
diff --git a/numpy/core/tests/test_deprecations.py b/numpy/core/tests/test_deprecations.py
index 94583a5ee04f..033815150b0e 100644
--- a/numpy/core/tests/test_deprecations.py
+++ b/numpy/core/tests/test_deprecations.py
@@ -13,7 +13,8 @@
 
 import numpy as np
 from numpy.testing import (
-    assert_raises, assert_warns, assert_, assert_array_equal, SkipTest, KnownFailureException
+    assert_raises, assert_warns, assert_, assert_array_equal, SkipTest,
+    KnownFailureException, break_cycles,
     )
 
 from numpy.core._multiarray_tests import fromstring_null_term_c_api
@@ -31,7 +32,7 @@ class _DeprecationTestCase:
     message = ''
     warning_cls = DeprecationWarning
 
-    def setup(self):
+    def setup_method(self):
         self.warn_ctx = warnings.catch_warnings(record=True)
         self.log = self.warn_ctx.__enter__()
 
@@ -45,7 +46,7 @@ def setup(self):
         warnings.filterwarnings("always", message=self.message,
                                 category=self.warning_cls)
 
-    def teardown(self):
+    def teardown_method(self):
         self.warn_ctx.__exit__()
 
     def assert_deprecated(self, function, num=1, ignore_others=False,
@@ -137,22 +138,6 @@ class _VisibleDeprecationTestCase(_DeprecationTestCase):
     warning_cls = np.VisibleDeprecationWarning
 
 
-class TestNonTupleNDIndexDeprecation:
-    def test_basic(self):
-        a = np.zeros((5, 5))
-        with warnings.catch_warnings():
-            warnings.filterwarnings('always')
-            assert_warns(FutureWarning, a.__getitem__, [[0, 1], [0, 1]])
-            assert_warns(FutureWarning, a.__getitem__, [slice(None)])
-
-            warnings.filterwarnings('error')
-            assert_raises(FutureWarning, a.__getitem__, [[0, 1], [0, 1]])
-            assert_raises(FutureWarning, a.__getitem__, [slice(None)])
-
-            # a a[[0, 1]] always was advanced indexing, so no error/warning
-            a[[0, 1]]
-
-
 class TestComparisonDeprecations(_DeprecationTestCase):
     """This tests the deprecation, for non-element-wise comparison logic.
     This used to mean that when an error occurred during element-wise comparison
@@ -181,7 +166,7 @@ def test_string(self):
         # For two string arrays, strings always raised the broadcasting error:
         a = np.array(['a', 'b'])
         b = np.array(['a', 'b', 'c'])
-        assert_raises(ValueError, lambda x, y: x == y, a, b)
+        assert_warns(FutureWarning, lambda x, y: x == y, a, b)
 
         # The empty list is not cast to string, and this used to pass due
         # to dtype mismatch; now (2018-06-21) it correctly leads to a
@@ -200,14 +185,6 @@ def __ne__(self, other):
         self.assert_deprecated(lambda: np.arange(2) == NotArray())
         self.assert_deprecated(lambda: np.arange(2) != NotArray())
 
-        struct1 = np.zeros(2, dtype="i4,i4")
-        struct2 = np.zeros(2, dtype="i4,i4,i4")
-
-        assert_warns(FutureWarning, lambda: struct1 == 1)
-        assert_warns(FutureWarning, lambda: struct1 == struct2)
-        assert_warns(FutureWarning, lambda: struct1 != 1)
-        assert_warns(FutureWarning, lambda: struct1 != struct2)
-
     def test_array_richcompare_legacy_weirdness(self):
         # It doesn't really work to use assert_deprecated here, b/c part of
         # the point of assert_deprecated is to check that when warnings are
@@ -256,20 +233,6 @@ def test_datetime(self):
         self.assert_deprecated(np.datetime64, args=(dt,))
 
 
-class TestNonCContiguousViewDeprecation(_DeprecationTestCase):
-    """View of non-C-contiguous arrays deprecated in 1.11.0.
-
-    The deprecation will not be raised for arrays that are both C and F
-    contiguous, as C contiguous is dominant. There are more such arrays
-    with relaxed stride checking than without so the deprecation is not
-    as visible with relaxed stride checking in force.
-    """
-
-    def test_fortran_contiguous(self):
-        self.assert_deprecated(np.ones((2,2)).T.view, args=(complex,))
-        self.assert_deprecated(np.ones((2,2)).T.view, args=(np.int8,))
-
-
 class TestArrayDataAttributeAssignmentDeprecation(_DeprecationTestCase):
     """Assigning the 'data' attribute of an ndarray is unsafe as pointed
      out in gh-7093. Eventually, such assignment should NOT be allowed, but
@@ -334,7 +297,7 @@ class vdt(np.void):
 class TestTestDeprecated:
     def test_assert_deprecated(self):
         test_case_instance = _DeprecationTestCase()
-        test_case_instance.setup()
+        test_case_instance.setup_method()
         assert_raises(AssertionError,
                       test_case_instance.assert_deprecated,
                       lambda: None)
@@ -343,7 +306,7 @@ def foo():
             warnings.warn("foo", category=DeprecationWarning, stacklevel=2)
 
         test_case_instance.assert_deprecated(foo)
-        test_case_instance.teardown()
+        test_case_instance.teardown_method()
 
 
 class TestNonNumericConjugate(_DeprecationTestCase):
@@ -379,18 +342,6 @@ def test_npy_pyarrayas2d_deprecation(self):
         assert_raises(NotImplementedError, npy_pyarrayas2d_deprecation)
 
 
-class Test_UPDATEIFCOPY(_DeprecationTestCase):
-    """
-    v1.14 deprecates creating an array with the UPDATEIFCOPY flag, use
-    WRITEBACKIFCOPY instead
-    """
-    def test_npy_updateifcopy_deprecation(self):
-        from numpy.core._multiarray_tests import npy_updateifcopy_deprecation
-        arr = np.arange(9).reshape(3, 3)
-        v = arr.T
-        self.assert_deprecated(npy_updateifcopy_deprecation, args=(v,))
-
-
 class TestDatetimeEvent(_DeprecationTestCase):
     # 2017-08-11, 1.14.0
     def test_3_tuple(self):
@@ -426,11 +377,6 @@ def test_bincount_minlength(self):
         self.assert_deprecated(lambda: np.bincount([1, 2, 3], minlength=None))
 
 
-class TestAlen(_DeprecationTestCase):
-    # 2019-08-02, 1.18.0
-    def test_alen(self):
-        self.assert_deprecated(lambda: np.alen(np.array([1, 2, 3])))
-
 
 class TestGeneratorSum(_DeprecationTestCase):
     # 2018-02-25, 1.15.0
@@ -529,34 +475,6 @@ def test_zerod(self):
         self.assert_deprecated(lambda: np.nonzero(np.array(1)))
 
 
-def test_deprecate_ragged_arrays():
-    # 2019-11-29 1.19.0
-    #
-    # NEP 34 deprecated automatic object dtype when creating ragged
-    # arrays. Also see the "ragged" tests in `test_multiarray`
-    #
-    # emits a VisibleDeprecationWarning
-    arg = [1, [2, 3]]
-    with assert_warns(np.VisibleDeprecationWarning):
-        np.array(arg)
-
-
-class TestTooDeepDeprecation(_VisibleDeprecationTestCase):
-    # NumPy 1.20, 2020-05-08
-    # This is a bit similar to the above ragged array deprecation case.
-    message = re.escape("Creating an ndarray from nested sequences exceeding")
-
-    def test_deprecation(self):
-        nested = [1]
-        for i in range(np.MAXDIMS - 1):
-            nested = [nested]
-        self.assert_not_deprecated(np.array, args=(nested,))
-        self.assert_not_deprecated(np.array,
-                args=(nested,), kwargs=dict(dtype=object))
-
-        self.assert_deprecated(np.array, args=([nested],))
-
-
 class TestToString(_DeprecationTestCase):
     # 2020-03-06 1.19.0
     message = re.escape("tostring() is deprecated. Use tobytes() instead.")
@@ -665,28 +583,6 @@ def test_non_exact_match(self):
         self.assert_deprecated(lambda: np.searchsorted(arr[0], 4, side='Random'))
 
 
-class TestDeprecatedGlobals(_DeprecationTestCase):
-    # 2020-06-06
-    @pytest.mark.skipif(
-        sys.version_info < (3, 7),
-        reason='module-level __getattr__ not supported')
-    def test_type_aliases(self):
-        # from builtins
-        self.assert_deprecated(lambda: np.bool(True))
-        self.assert_deprecated(lambda: np.int(1))
-        self.assert_deprecated(lambda: np.float(1))
-        self.assert_deprecated(lambda: np.complex(1))
-        self.assert_deprecated(lambda: np.object())
-        self.assert_deprecated(lambda: np.str('abc'))
-
-        # from np.compat
-        self.assert_deprecated(lambda: np.long(1))
-        self.assert_deprecated(lambda: np.unicode('abc'))
-
-        # from np.core.numerictypes
-        self.assert_deprecated(lambda: np.typeDict)
-
-
 class TestMatrixInOuter(_DeprecationTestCase):
     # 2020-05-13 NumPy 1.20.0
     message = (r"add.outer\(\) was passed a numpy matrix as "
@@ -701,20 +597,6 @@ def test_deprecated(self):
         self.assert_not_deprecated(np.add.outer, args=(arr, arr))
 
 
-class TestRaggedArray(_DeprecationTestCase):
-    # 2020-07-24, NumPy 1.20.0
-    message = "setting an array element with a sequence"
-
-    def test_deprecated(self):
-        arr = np.ones((1, 1))
-        # Deprecated if the array is a leave node:
-        self.assert_deprecated(lambda: np.array([arr, 0], dtype=np.float64))
-        self.assert_deprecated(lambda: np.array([0, arr], dtype=np.float64))
-        # And when it is an assignment into a lower dimensional subarray:
-        self.assert_deprecated(lambda: np.array([arr, [0]], dtype=np.float64))
-        self.assert_deprecated(lambda: np.array([[0], arr], dtype=np.float64))
-
-
 class FlatteningConcatenateUnsafeCast(_DeprecationTestCase):
     # NumPy 1.20, 2020-09-03
     message = "concatenate with `axis=None` will use same-kind casting"
@@ -1099,49 +981,6 @@ def test_deprecated(self):
         self.assert_deprecated(lambda: np.add(1, 2, sig=(np.dtype("l"),)))
 
 
-class TestComparisonBadDType(_DeprecationTestCase):
-    # Deprecated 2021-04-01, NumPy 1.21
-    message = r"using `dtype=` in comparisons is only useful for"
-
-    def test_deprecated(self):
-        self.assert_deprecated(lambda: np.equal(1, 1, dtype=np.int64))
-        # Not an error only for the transition
-        self.assert_deprecated(lambda: np.equal(1, 1, sig=(None, None, "l")))
-
-    def test_not_deprecated(self):
-        np.equal(True, False, dtype=bool)
-        np.equal(3, 5, dtype=bool, casting="unsafe")
-        np.equal([None], [4], dtype=object)
-
-class TestComparisonBadObjectDType(_DeprecationTestCase):
-    # Deprecated 2021-04-01, NumPy 1.21  (different branch of the above one)
-    message = r"using `dtype=object` \(or equivalent signature\) will"
-    warning_cls = FutureWarning
-
-    def test_deprecated(self):
-        self.assert_deprecated(lambda: np.equal(1, 1, dtype=object))
-        self.assert_deprecated(
-                lambda: np.equal(1, 1, sig=(None, None, object)))
-
-
-class TestSpecialAttributeLookupFailure(_DeprecationTestCase):
-    message = r"An exception was ignored while fetching the attribute"
-
-    class WeirdArrayLike:
-        @property
-        def __array__(self):
-            raise RuntimeError("oops!")
-
-    class WeirdArrayInterface:
-        @property
-        def __array_interface__(self):
-            raise RuntimeError("oops!")
-
-    def test_deprecated(self):
-        self.assert_deprecated(lambda: np.array(self.WeirdArrayLike()))
-        self.assert_deprecated(lambda: np.array(self.WeirdArrayInterface()))
-
-
 class TestCtypesGetter(_DeprecationTestCase):
     # Deprecated 2021-05-18, Numpy 1.21.0
     warning_cls = DeprecationWarning
@@ -1161,39 +1000,6 @@ def test_not_deprecated(self, name: str) -> None:
         self.assert_not_deprecated(lambda: getattr(self.ctypes, name))
 
 
-class TestUFuncForcedDTypeWarning(_DeprecationTestCase):
-    message = "The `dtype` and `signature` arguments to ufuncs only select the"
-
-    def test_not_deprecated(self):
-        import pickle
-        # does not warn (test relies on bad pickling behaviour, simply remove
-        # it if the `assert int64 is not int64_2` should start failing.
-        int64 = np.dtype("int64")
-        int64_2 = pickle.loads(pickle.dumps(int64))
-        assert int64 is not int64_2
-        self.assert_not_deprecated(lambda: np.add(3, 4, dtype=int64_2))
-
-    def test_deprecation(self):
-        int64 = np.dtype("int64")
-        self.assert_deprecated(lambda: np.add(3, 5, dtype=int64.newbyteorder()))
-        self.assert_deprecated(lambda: np.add(3, 5, dtype="m8[ns]"))
-
-    def test_behaviour(self):
-        int64 = np.dtype("int64")
-        arr = np.arange(10, dtype="m8[s]")
-
-        with pytest.warns(DeprecationWarning, match=self.message):
-            np.add(3, 5, dtype=int64.newbyteorder())
-        with pytest.warns(DeprecationWarning, match=self.message):
-            np.add(3, 5, dtype="m8[ns]")  # previously used the "ns"
-        with pytest.warns(DeprecationWarning, match=self.message):
-            np.add(arr, arr, dtype="m8[ns]")  # never preserved the "ns"
-        with pytest.warns(DeprecationWarning, match=self.message):
-            np.maximum(arr, arr, dtype="m8[ns]")  # previously used the "ns"
-        with pytest.warns(DeprecationWarning, match=self.message):
-            np.maximum.reduce(arr, dtype="m8[ns]")  # never preserved the "ns"
-
-
 PARTITION_DICT = {
     "partition method": np.arange(10).partition,
     "argpartition method": np.arange(10).argpartition,
@@ -1221,9 +1027,6 @@ class TestMachAr(_DeprecationTestCase):
     # Deprecated 2021-10-19, NumPy 1.22
     warning_cls = DeprecationWarning
 
-    def test_deprecated(self):
-        self.assert_deprecated(lambda: np.MachAr)
-
     def test_deprecated_module(self):
         self.assert_deprecated(lambda: getattr(np.core, "machar"))
 
@@ -1250,3 +1053,141 @@ def test_both_passed(self, func):
             warnings.simplefilter("always", DeprecationWarning)
             with pytest.raises(TypeError):
                 func([0., 1.], 0., interpolation="nearest", method="nearest")
+
+
+class TestMemEventHook(_DeprecationTestCase):
+    # Deprecated 2021-11-18, NumPy 1.23
+    def test_mem_seteventhook(self):
+        # The actual tests are within the C code in
+        # multiarray/_multiarray_tests.c.src
+        import numpy.core._multiarray_tests as ma_tests
+        with pytest.warns(DeprecationWarning,
+                          match='PyDataMem_SetEventHook is deprecated'):
+            ma_tests.test_pydatamem_seteventhook_start()
+        # force an allocation and free of a numpy array
+        # needs to be larger then limit of small memory cacher in ctors.c
+        a = np.zeros(1000)
+        del a
+        break_cycles()
+        with pytest.warns(DeprecationWarning,
+                          match='PyDataMem_SetEventHook is deprecated'):
+            ma_tests.test_pydatamem_seteventhook_end()
+
+
+class TestArrayFinalizeNone(_DeprecationTestCase):
+    message = "Setting __array_finalize__ = None"
+
+    def test_use_none_is_deprecated(self):
+        # Deprecated way that ndarray itself showed nothing needs finalizing.
+        class NoFinalize(np.ndarray):
+            __array_finalize__ = None
+
+        self.assert_deprecated(lambda: np.array(1).view(NoFinalize))
+
+class TestAxisNotMAXDIMS(_DeprecationTestCase):
+    # Deprecated 2022-01-08, NumPy 1.23
+    message = r"Using `axis=32` \(MAXDIMS\) is deprecated"
+
+    def test_deprecated(self):
+        a = np.zeros((1,)*32)
+        self.assert_deprecated(lambda: np.repeat(a, 1, axis=np.MAXDIMS))
+
+
+class TestLoadtxtParseIntsViaFloat(_DeprecationTestCase):
+    # Deprecated 2022-07-03, NumPy 1.23
+    # This test can be removed without replacement after the deprecation.
+    # The tests:
+    #   * numpy/lib/tests/test_loadtxt.py::test_integer_signs
+    #   * lib/tests/test_loadtxt.py::test_implicit_cast_float_to_int_fails
+    # Have a warning filter that needs to be removed.
+    message = r"loadtxt\(\): Parsing an integer via a float is deprecated.*"
+
+    @pytest.mark.parametrize("dtype", np.typecodes["AllInteger"])
+    def test_deprecated_warning(self, dtype):
+        with pytest.warns(DeprecationWarning, match=self.message):
+            np.loadtxt(["10.5"], dtype=dtype)
+
+    @pytest.mark.parametrize("dtype", np.typecodes["AllInteger"])
+    def test_deprecated_raised(self, dtype):
+        # The DeprecationWarning is chained when raised, so test manually:
+        with warnings.catch_warnings():
+            warnings.simplefilter("error", DeprecationWarning)
+            try:
+                np.loadtxt(["10.5"], dtype=dtype)
+            except ValueError as e:
+                assert isinstance(e.__cause__, DeprecationWarning)
+
+
+class TestPyIntConversion(_DeprecationTestCase):
+    message = r".*stop allowing conversion of out-of-bound.*"
+
+    @pytest.mark.parametrize("dtype", np.typecodes["AllInteger"])
+    def test_deprecated_scalar(self, dtype):
+        dtype = np.dtype(dtype)
+        info = np.iinfo(dtype)
+
+        # Cover the most common creation paths (all end up in the
+        # same place):
+        def scalar(value, dtype):
+            dtype.type(value)
+
+        def assign(value, dtype):
+            arr = np.array([0, 0, 0], dtype=dtype)
+            arr[2] = value
+
+        def create(value, dtype):
+            np.array([value], dtype=dtype)
+
+        for creation_func in [scalar, assign, create]:
+            try:
+                self.assert_deprecated(
+                        lambda: creation_func(info.min - 1, dtype))
+            except OverflowError:
+                pass  # OverflowErrors always happened also before and are OK.
+
+            try:
+                self.assert_deprecated(
+                        lambda: creation_func(info.max + 1, dtype))
+            except OverflowError:
+                pass  # OverflowErrors always happened also before and are OK.
+
+
+class TestDeprecatedGlobals(_DeprecationTestCase):
+    # Deprecated 2022-11-17, NumPy 1.24
+    def test_type_aliases(self):
+        # from builtins
+        self.assert_deprecated(lambda: np.bool8)
+        self.assert_deprecated(lambda: np.int0)
+        self.assert_deprecated(lambda: np.uint0)
+        self.assert_deprecated(lambda: np.bytes0)
+        self.assert_deprecated(lambda: np.str0)
+        self.assert_deprecated(lambda: np.object0)
+
+
+@pytest.mark.parametrize("name",
+        ["bool", "long", "ulong", "str", "bytes", "object"])
+def test_future_scalar_attributes(name):
+    # FutureWarning added 2022-11-17, NumPy 1.24,
+    assert name not in dir(np)  # we may want to not add them
+    with pytest.warns(FutureWarning,
+            match=f"In the future .*{name}"):
+        assert not hasattr(np, name)
+
+    # Unfortunately, they are currently still valid via `np.dtype()`
+    np.dtype(name)
+    name in np.sctypeDict
+
+
+# Ignore the above future attribute warning for this test.
+@pytest.mark.filterwarnings("ignore:In the future:FutureWarning")
+class TestRemovedGlobals:
+    # Removed 2023-01-12, NumPy 1.24.0
+    # Not a deprecation, but the large error was added to aid those who missed
+    # the previous deprecation, and should be removed similarly to one
+    # (or faster).
+    @pytest.mark.parametrize("name",
+            ["object", "bool", "float", "complex", "str", "int"])
+    def test_attributeerror_includes_info(self, name):
+        msg = f".*\n`np.{name}` was a deprecated alias for the builtin"
+        with pytest.raises(AttributeError, match=msg):
+            getattr(np, name)
diff --git a/numpy/core/tests/test_dlpack.py b/numpy/core/tests/test_dlpack.py
index f848b2008cf9..278bdd12de53 100644
--- a/numpy/core/tests/test_dlpack.py
+++ b/numpy/core/tests/test_dlpack.py
@@ -26,13 +26,13 @@ def test_strides_not_multiple_of_itemsize(self):
         y = np.zeros((5,), dtype=dt)
         z = y['int']
 
-        with pytest.raises(RuntimeError):
-            np._from_dlpack(z)
+        with pytest.raises(BufferError):
+            np.from_dlpack(z)
 
     @pytest.mark.skipif(IS_PYPY, reason="PyPy can't get refcounts.")
     def test_from_dlpack_refcount(self):
         x = np.arange(5)
-        y = np._from_dlpack(x)
+        y = np.from_dlpack(x)
         assert sys.getrefcount(x) == 3
         del y
         assert sys.getrefcount(x) == 2
@@ -45,7 +45,7 @@ def test_from_dlpack_refcount(self):
     ])
     def test_dtype_passthrough(self, dtype):
         x = np.arange(5, dtype=dtype)
-        y = np._from_dlpack(x)
+        y = np.from_dlpack(x)
 
         assert y.dtype == x.dtype
         assert_array_equal(x, y)
@@ -53,51 +53,54 @@ def test_dtype_passthrough(self, dtype):
     def test_invalid_dtype(self):
         x = np.asarray(np.datetime64('2021-05-27'))
 
-        with pytest.raises(TypeError):
-            np._from_dlpack(x)
+        with pytest.raises(BufferError):
+            np.from_dlpack(x)
 
     def test_invalid_byte_swapping(self):
         dt = np.dtype('=i8').newbyteorder()
         x = np.arange(5, dtype=dt)
 
-        with pytest.raises(TypeError):
-            np._from_dlpack(x)
+        with pytest.raises(BufferError):
+            np.from_dlpack(x)
 
     def test_non_contiguous(self):
         x = np.arange(25).reshape((5, 5))
 
         y1 = x[0]
-        assert_array_equal(y1, np._from_dlpack(y1))
+        assert_array_equal(y1, np.from_dlpack(y1))
 
         y2 = x[:, 0]
-        assert_array_equal(y2, np._from_dlpack(y2))
+        assert_array_equal(y2, np.from_dlpack(y2))
 
         y3 = x[1, :]
-        assert_array_equal(y3, np._from_dlpack(y3))
+        assert_array_equal(y3, np.from_dlpack(y3))
 
         y4 = x[1]
-        assert_array_equal(y4, np._from_dlpack(y4))
+        assert_array_equal(y4, np.from_dlpack(y4))
 
         y5 = np.diagonal(x).copy()
-        assert_array_equal(y5, np._from_dlpack(y5))
+        assert_array_equal(y5, np.from_dlpack(y5))
 
     @pytest.mark.parametrize("ndim", range(33))
     def test_higher_dims(self, ndim):
         shape = (1,) * ndim
         x = np.zeros(shape, dtype=np.float64)
 
-        assert shape == np._from_dlpack(x).shape
+        assert shape == np.from_dlpack(x).shape
 
     def test_dlpack_device(self):
         x = np.arange(5)
         assert x.__dlpack_device__() == (1, 0)
-        assert np._from_dlpack(x).__dlpack_device__() == (1, 0)
+        y = np.from_dlpack(x)
+        assert y.__dlpack_device__() == (1, 0)
+        z = y[::2]
+        assert z.__dlpack_device__() == (1, 0)
 
     def dlpack_deleter_exception(self):
         x = np.arange(5)
         _ = x.__dlpack__()
         raise RuntimeError
-    
+
     def test_dlpack_destructor_exception(self):
         with pytest.raises(RuntimeError):
             self.dlpack_deleter_exception()
@@ -105,5 +108,16 @@ def test_dlpack_destructor_exception(self):
     def test_readonly(self):
         x = np.arange(5)
         x.flags.writeable = False
-        with pytest.raises(TypeError):
+        with pytest.raises(BufferError):
             x.__dlpack__()
+
+    def test_ndim0(self):
+        x = np.array(1.0)
+        y = np.from_dlpack(x)
+        assert_array_equal(x, y)
+
+    def test_size1dims_arrays(self):
+        x = np.ndarray(dtype='f8', shape=(10, 5, 1), strides=(8, 80, 4),
+                       buffer=np.ones(1000, dtype=np.uint8), order='F')
+        y = np.from_dlpack(x)
+        assert_array_equal(x, y)
diff --git a/numpy/core/tests/test_dtype.py b/numpy/core/tests/test_dtype.py
index e49604e4db7a..0a56483d64e8 100644
--- a/numpy/core/tests/test_dtype.py
+++ b/numpy/core/tests/test_dtype.py
@@ -11,9 +11,14 @@
 from numpy.core._multiarray_tests import create_custom_field_dtype
 from numpy.testing import (
     assert_, assert_equal, assert_array_equal, assert_raises, HAS_REFCOUNT,
-    IS_PYSTON)
+    IS_PYSTON, _OLD_PROMOTION)
 from numpy.compat import pickle
 from itertools import permutations
+import random
+
+import hypothesis
+from hypothesis.extra import numpy as hynp
+
 
 
 def assert_dtype_equal(a, b):
@@ -121,6 +126,15 @@ def test_numeric_style_types_are_invalid(self, dtype):
         with assert_raises(TypeError):
             np.dtype(dtype)
 
+    def test_remaining_dtypes_with_bad_bytesize(self):
+        # The np. aliases were deprecated, these probably should be too 
+        assert np.dtype("int0") is np.dtype("intp")
+        assert np.dtype("uint0") is np.dtype("uintp")
+        assert np.dtype("bool8") is np.dtype("bool")
+        assert np.dtype("bytes0") is np.dtype("bytes")
+        assert np.dtype("str0") is np.dtype("str")
+        assert np.dtype("object0") is np.dtype("object")
+
     @pytest.mark.parametrize(
         'value',
         ['m8', 'M8', 'datetime64', 'timedelta64',
@@ -175,11 +189,11 @@ def test_field_order_equality(self):
                       'formats': ['i4', 'f4'],
                       'offsets': [0, 4]})
         y = np.dtype({'names': ['B', 'A'],
-                      'formats': ['f4', 'i4'],
+                      'formats': ['i4', 'f4'],
                       'offsets': [4, 0]})
         assert_equal(x == y, False)
-        # But it is currently an equivalent cast:
-        assert np.can_cast(x, y, casting="equiv")
+        # This is an safe cast (not equiv) due to the different names:
+        assert np.can_cast(x, y, casting="safe")
 
 
 class TestRecord:
@@ -218,7 +232,8 @@ def test_refcount_dictionary_setting(self):
         assert refcounts == refcounts_new
 
     def test_mutate(self):
-        # Mutating a dtype should reset the cached hash value
+        # Mutating a dtype should reset the cached hash value.
+        # NOTE: Mutating should be deprecated, but new API added to replace it.
         a = np.dtype([('yo', int)])
         b = np.dtype([('yo', int)])
         c = np.dtype([('ye', int)])
@@ -232,6 +247,16 @@ def test_mutate(self):
         assert_dtype_equal(a, b)
         assert_dtype_not_equal(a, c)
 
+    def test_mutate_error(self):
+        # NOTE: Mutating should be deprecated, but new API added to replace it.
+        a = np.dtype("i,i")
+
+        with pytest.raises(ValueError, match="must replace all names at once"):
+            a.names = ["f0"]
+
+        with pytest.raises(ValueError, match=".*and not string"):
+            a.names = ["f0", b"not a unicode name"]
+
     def test_not_lists(self):
         """Test if an appropriate exception is raised when passing bad values to
         the dtype constructor.
@@ -312,8 +337,8 @@ def test_union_struct(self):
         dt2 = np.dtype({'names':['f2', 'f0', 'f1'],
                         'formats':['i4")
+        assert np.result_type(dt).isnative
+        assert np.result_type(dt).num == dt.num
+
+        # dtype with empty space:
+        struct_dt = np.dtype(">i4,i1,i", a, b, c,
                      dtype='?', casting='unsafe', optimize=do_opt),
                      np.logical_and(np.logical_and(a != 0, b != 0), c != 0))
@@ -592,11 +596,10 @@ def test_einsum_misc(self):
         assert_equal(np.einsum('ij...,j...->i...', a, b, optimize=True), [[[2], [2]]])
 
         # Regression test for issue #10369 (test unicode inputs with Python 2)
-        assert_equal(np.einsum(u'ij...,j...->i...', a, b), [[[2], [2]]])
+        assert_equal(np.einsum('ij...,j...->i...', a, b), [[[2], [2]]])
         assert_equal(np.einsum('...i,...i', [1, 2, 3], [2, 3, 4]), 20)
-        assert_equal(np.einsum(u'...i,...i', [1, 2, 3], [2, 3, 4]), 20)
         assert_equal(np.einsum('...i,...i', [1, 2, 3], [2, 3, 4],
-                               optimize=u'greedy'), 20)
+                               optimize='greedy'), 20)
 
         # The iterator had an issue with buffering this reduction
         a = np.ones((5, 12, 4, 2, 3), np.int64)
@@ -1019,12 +1022,10 @@ def test_long_paths(self):
         # Long test 2
         long_test2 = self.build_operands('chd,bde,agbc,hiad,bdi,cgh,agdb')
         path, path_str = np.einsum_path(*long_test2, optimize='greedy')
-        print(path)
         self.assert_path_equal(path, ['einsum_path',
                                       (3, 4), (0, 3), (3, 4), (1, 3), (1, 2), (0, 1)])
 
         path, path_str = np.einsum_path(*long_test2, optimize='optimal')
-        print(path)
         self.assert_path_equal(path, ['einsum_path',
                                       (0, 5), (1, 4), (3, 4), (1, 3), (1, 2), (0, 1)])
 
@@ -1091,6 +1092,32 @@ def test_path_type_input(self):
         opt = np.einsum(*path_test, optimize=exp_path)
         assert_almost_equal(noopt, opt)
 
+    def test_path_type_input_internal_trace(self):
+        #gh-20962
+        path_test = self.build_operands('cab,cdd->ab')
+        exp_path = ['einsum_path', (1,), (0, 1)]
+
+        path, path_str = np.einsum_path(*path_test, optimize=exp_path)
+        self.assert_path_equal(path, exp_path)
+
+        # Double check einsum works on the input path
+        noopt = np.einsum(*path_test, optimize=False)
+        opt = np.einsum(*path_test, optimize=exp_path)
+        assert_almost_equal(noopt, opt)
+
+    def test_path_type_input_invalid(self):
+        path_test = self.build_operands('ab,bc,cd,de->ae')
+        exp_path = ['einsum_path', (2, 3), (0, 1)]
+        assert_raises(RuntimeError, np.einsum, *path_test, optimize=exp_path)
+        assert_raises(
+            RuntimeError, np.einsum_path, *path_test, optimize=exp_path)
+
+        path_test = self.build_operands('a,a,a->a')
+        exp_path = ['einsum_path', (1,), (0, 1)]
+        assert_raises(RuntimeError, np.einsum, *path_test, optimize=exp_path)
+        assert_raises(
+            RuntimeError, np.einsum_path, *path_test, optimize=exp_path)
+
     def test_spaces(self):
         #gh-10794
         arr = np.array([[1]])
diff --git a/numpy/core/tests/test_errstate.py b/numpy/core/tests/test_errstate.py
index 184a373002fa..3a5647f6f340 100644
--- a/numpy/core/tests/test_errstate.py
+++ b/numpy/core/tests/test_errstate.py
@@ -2,7 +2,7 @@
 import sysconfig
 
 import numpy as np
-from numpy.testing import assert_, assert_raises
+from numpy.testing import assert_, assert_raises, IS_WASM
 
 # The floating point emulation on ARM EABI systems lacking a hardware FPU is
 # known to be buggy. This is an attempt to identify these hosts. It may not
@@ -12,6 +12,7 @@
 arm_softfloat = False if hosttype is None else hosttype.endswith('gnueabi')
 
 class TestErrstate:
+    @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm")
     @pytest.mark.skipif(arm_softfloat,
                         reason='platform/cpu issue with FPU (gh-413,-15562)')
     def test_invalid(self):
@@ -24,6 +25,7 @@ def test_invalid(self):
             with assert_raises(FloatingPointError):
                 np.sqrt(a)
 
+    @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm")
     @pytest.mark.skipif(arm_softfloat,
                         reason='platform/cpu issue with FPU (gh-15562)')
     def test_divide(self):
diff --git a/numpy/core/tests/test_getlimits.py b/numpy/core/tests/test_getlimits.py
index c5148db2c715..b8aaba386e98 100644
--- a/numpy/core/tests/test_getlimits.py
+++ b/numpy/core/tests/test_getlimits.py
@@ -69,7 +69,9 @@ def test_basic(self):
     def test_unsigned_max(self):
         types = np.sctypes['uint']
         for T in types:
-            assert_equal(iinfo(T).max, T(-1))
+            with np.errstate(over="ignore"):
+                max_calculated = T(0) - T(1)
+            assert_equal(iinfo(T).max, max_calculated)
 
 class TestRepr:
     def test_iinfo_repr(self):
diff --git a/numpy/core/tests/test_half.py b/numpy/core/tests/test_half.py
index 1b6fd21e14bb..ca849ad52ead 100644
--- a/numpy/core/tests/test_half.py
+++ b/numpy/core/tests/test_half.py
@@ -3,7 +3,7 @@
 
 import numpy as np
 from numpy import uint16, float16, float32, float64
-from numpy.testing import assert_, assert_equal
+from numpy.testing import assert_, assert_equal, _OLD_PROMOTION, IS_WASM
 
 
 def assert_raises_fpe(strmatch, callable, *args, **kwargs):
@@ -17,7 +17,7 @@ def assert_raises_fpe(strmatch, callable, *args, **kwargs):
                 "Did not raise floating point %s error" % strmatch)
 
 class TestHalf:
-    def setup(self):
+    def setup_method(self):
         # An array of all possible float16 values
         self.all_f16 = np.arange(0x10000, dtype=uint16)
         self.all_f16.dtype = float16
@@ -85,6 +85,7 @@ def test_half_conversion_from_string(self, string_dt):
     @pytest.mark.parametrize("offset", [None, "up", "down"])
     @pytest.mark.parametrize("shift", [None, "up", "down"])
     @pytest.mark.parametrize("float_t", [np.float32, np.float64])
+    @np._no_nep50_warning()
     def test_half_conversion_rounding(self, float_t, shift, offset):
         # Assumes that round to even is used during casting.
         max_pattern = np.float16(np.finfo(np.float16).max).view(np.uint16)
@@ -104,9 +105,9 @@ def test_half_conversion_rounding(self, float_t, shift, offset):
 
         # Increase the float by a minimal value:
         if offset == "up":
-            f16s_float = np.nextafter(f16s_float, float_t(1e50))
+            f16s_float = np.nextafter(f16s_float, float_t(np.inf))
         elif offset == "down":
-            f16s_float = np.nextafter(f16s_float, float_t(-1e50))
+            f16s_float = np.nextafter(f16s_float, float_t(-np.inf))
 
         # Convert back to float16 and its bit pattern:
         res_patterns = f16s_float.astype(np.float16).view(np.uint16)
@@ -233,12 +234,14 @@ def test_half_rounding(self):
                    np.inf]
 
         # Check float64->float16 rounding
-        b = np.array(a, dtype=float16)
+        with np.errstate(over="ignore"):
+            b = np.array(a, dtype=float16)
         assert_equal(b, rounded)
 
         # Check float32->float16 rounding
         a = np.array(a, dtype=float32)
-        b = np.array(a, dtype=float16)
+        with np.errstate(over="ignore"):
+            b = np.array(a, dtype=float16)
         assert_equal(b, rounded)
 
     def test_half_correctness(self):
@@ -448,34 +451,40 @@ def test_half_ufuncs(self):
         assert_equal(np.frexp(b), ([-0.5, 0.625, 0.5, 0.5, 0.75], [2, 3, 1, 3, 2]))
         assert_equal(np.ldexp(b, [0, 1, 2, 4, 2]), [-2, 10, 4, 64, 12])
 
-    def test_half_coercion(self):
+    @np._no_nep50_warning()
+    def test_half_coercion(self, weak_promotion):
         """Test that half gets coerced properly with the other types"""
         a16 = np.array((1,), dtype=float16)
         a32 = np.array((1,), dtype=float32)
         b16 = float16(1)
         b32 = float32(1)
 
-        assert_equal(np.power(a16, 2).dtype, float16)
-        assert_equal(np.power(a16, 2.0).dtype, float16)
-        assert_equal(np.power(a16, b16).dtype, float16)
-        assert_equal(np.power(a16, b32).dtype, float16)
-        assert_equal(np.power(a16, a16).dtype, float16)
-        assert_equal(np.power(a16, a32).dtype, float32)
-
-        assert_equal(np.power(b16, 2).dtype, float64)
-        assert_equal(np.power(b16, 2.0).dtype, float64)
-        assert_equal(np.power(b16, b16).dtype, float16)
-        assert_equal(np.power(b16, b32).dtype, float32)
-        assert_equal(np.power(b16, a16).dtype, float16)
-        assert_equal(np.power(b16, a32).dtype, float32)
-
-        assert_equal(np.power(a32, a16).dtype, float32)
-        assert_equal(np.power(a32, b16).dtype, float32)
-        assert_equal(np.power(b32, a16).dtype, float16)
-        assert_equal(np.power(b32, b16).dtype, float32)
+        assert np.power(a16, 2).dtype == float16
+        assert np.power(a16, 2.0).dtype == float16
+        assert np.power(a16, b16).dtype == float16
+        expected_dt = float32 if weak_promotion else float16
+        assert np.power(a16, b32).dtype == expected_dt
+        assert np.power(a16, a16).dtype == float16
+        assert np.power(a16, a32).dtype == float32
+
+        expected_dt = float16 if weak_promotion else float64
+        assert np.power(b16, 2).dtype == expected_dt
+        assert np.power(b16, 2.0).dtype == expected_dt
+        assert np.power(b16, b16).dtype, float16
+        assert np.power(b16, b32).dtype, float32
+        assert np.power(b16, a16).dtype, float16
+        assert np.power(b16, a32).dtype, float32
+
+        assert np.power(a32, a16).dtype == float32
+        assert np.power(a32, b16).dtype == float32
+        expected_dt = float32 if weak_promotion else float16
+        assert np.power(b32, a16).dtype == expected_dt
+        assert np.power(b32, b16).dtype == float32
 
     @pytest.mark.skipif(platform.machine() == "armv5tel",
                         reason="See gh-413.")
+    @pytest.mark.skipif(IS_WASM,
+                        reason="fp exceptions don't work in wasm.")
     def test_half_fpe(self):
         with np.errstate(all='raise'):
             sx16 = np.array((1e-4,), dtype=float16)
diff --git a/numpy/core/tests/test_indexing.py b/numpy/core/tests/test_indexing.py
index 1c22538567d3..74075639cf82 100644
--- a/numpy/core/tests/test_indexing.py
+++ b/numpy/core/tests/test_indexing.py
@@ -10,7 +10,7 @@
 from itertools import product
 from numpy.testing import (
     assert_, assert_equal, assert_raises, assert_raises_regex,
-    assert_array_equal, assert_warns, HAS_REFCOUNT,
+    assert_array_equal, assert_warns, HAS_REFCOUNT, IS_WASM
     )
 
 
@@ -563,6 +563,7 @@ def test_too_many_advanced_indices(self, index, num, original_ndim):
         with pytest.raises(IndexError):
             arr[(index,) * num] = 1.
 
+    @pytest.mark.skipif(IS_WASM, reason="no threading")
     def test_structured_advanced_indexing(self):
         # Test that copyswap(n) used by integer array indexing is threadsafe
         # for structured datatypes, see gh-15387. This test can behave randomly.
@@ -587,6 +588,12 @@ def func(arr):
 
         assert arr.dtype is dt
 
+    def test_nontuple_ndindex(self):
+        a = np.arange(25).reshape((5, 5))
+        assert_equal(a[[0, 1]], np.array([a[0], a[1]]))
+        assert_equal(a[[0, 1], [0, 1]], np.array([0, 6]))
+        assert_raises(IndexError, a.__getitem__, [slice(None)])
+
 
 class TestFieldIndexing:
     def test_scalar_return_type(self):
@@ -820,7 +827,7 @@ class TestMultiIndexingAutomated:
 
     """
 
-    def setup(self):
+    def setup_method(self):
         self.a = np.arange(np.prod([3, 1, 5, 6])).reshape(3, 1, 5, 6)
         self.b = np.empty((3, 0, 5, 6))
         self.complex_indices = ['skip', Ellipsis,
@@ -1291,11 +1298,10 @@ def test_bool_as_int_argument_errors(self):
     def test_boolean_indexing_weirdness(self):
         # Weird boolean indexing things
         a = np.ones((2, 3, 4))
-        a[False, True, ...].shape == (0, 2, 3, 4)
-        a[True, [0, 1], True, True, [1], [[2]]] == (1, 2)
+        assert a[False, True, ...].shape == (0, 2, 3, 4)
+        assert a[True, [0, 1], True, True, [1], [[2]]].shape == (1, 2)
         assert_raises(IndexError, lambda: a[False, [0, 1], ...])
 
-
     def test_boolean_indexing_fast_path(self):
         # These used to either give the wrong error, or incorrectly give no
         # error.
@@ -1332,7 +1338,7 @@ def test_boolean_indexing_fast_path(self):
 
 
 class TestArrayToIndexDeprecation:
-    """Creating an an index from array not 0-D is an error.
+    """Creating an index from array not 0-D is an error.
 
     """
     def test_array_to_index_error(self):
diff --git a/numpy/core/tests/test_limited_api.py b/numpy/core/tests/test_limited_api.py
new file mode 100644
index 000000000000..725de19bdaed
--- /dev/null
+++ b/numpy/core/tests/test_limited_api.py
@@ -0,0 +1,44 @@
+import os
+import shutil
+import subprocess
+import sys
+import sysconfig
+import pytest
+
+from numpy.testing import IS_WASM
+
+
+@pytest.mark.skipif(IS_WASM, reason="Can't start subprocess")
+@pytest.mark.xfail(
+    sysconfig.get_config_var("Py_DEBUG"),
+    reason=(
+        "Py_LIMITED_API is incompatible with Py_DEBUG, Py_TRACE_REFS, "
+        "and Py_REF_DEBUG"
+    ),
+)
+def test_limited_api(tmp_path):
+    """Test building a third-party C extension with the limited API."""
+    # Based in part on test_cython from random.tests.test_extending
+
+    here = os.path.dirname(__file__)
+    ext_dir = os.path.join(here, "examples", "limited_api")
+
+    cytest = str(tmp_path / "limited_api")
+
+    shutil.copytree(ext_dir, cytest)
+    # build the examples and "install" them into a temporary directory
+
+    install_log = str(tmp_path / "tmp_install_log.txt")
+    subprocess.check_output(
+        [
+            sys.executable,
+            "setup.py",
+            "build",
+            "install",
+            "--prefix", str(tmp_path / "installdir"),
+            "--single-version-externally-managed",
+            "--record",
+            install_log,
+        ],
+        cwd=cytest,
+    )
diff --git a/numpy/core/tests/test_mem_overlap.py b/numpy/core/tests/test_mem_overlap.py
index 24bdf477f7c7..d66decfda072 100644
--- a/numpy/core/tests/test_mem_overlap.py
+++ b/numpy/core/tests/test_mem_overlap.py
@@ -105,7 +105,7 @@ def test_diophantine_fuzz():
                       for j in range(ndim))
 
             b_ub = min(max_int-2, sum(a*ub for a, ub in zip(A, U)))
-            b = rng.randint(-1, b_ub+2, dtype=np.intp)
+            b = int(rng.randint(-1, b_ub+2, dtype=np.intp))
 
             if ndim == 0 and feasible_count < min_count:
                 b = 0
diff --git a/numpy/core/tests/test_mem_policy.py b/numpy/core/tests/test_mem_policy.py
index 3dae36d5a56c..d5dfbc38b3db 100644
--- a/numpy/core/tests/test_mem_policy.py
+++ b/numpy/core/tests/test_mem_policy.py
@@ -5,7 +5,7 @@
 import numpy as np
 import threading
 import warnings
-from numpy.testing import extbuild, assert_warns
+from numpy.testing import extbuild, assert_warns, IS_WASM
 import sys
 
 
@@ -18,6 +18,8 @@ def get_module(tmp_path):
     """
     if sys.platform.startswith('cygwin'):
         pytest.skip('link fails on cygwin')
+    if IS_WASM:
+        pytest.skip("Can't build module inside Wasm")
     functions = [
         ("get_default_policy", "METH_NOARGS", """
              Py_INCREF(PyDataMem_DefaultHandler);
diff --git a/numpy/core/tests/test_memmap.py b/numpy/core/tests/test_memmap.py
index e4f0a6b3f665..914f86f1480e 100644
--- a/numpy/core/tests/test_memmap.py
+++ b/numpy/core/tests/test_memmap.py
@@ -15,14 +15,14 @@
     )
 
 class TestMemmap:
-    def setup(self):
+    def setup_method(self):
         self.tmpfp = NamedTemporaryFile(prefix='mmap')
         self.shape = (3, 4)
         self.dtype = 'float32'
         self.data = arange(12, dtype=self.dtype)
         self.data.resize(self.shape)
 
-    def teardown(self):
+    def teardown_method(self):
         self.tmpfp.close()
         self.data = None
         if IS_PYPY:
diff --git a/numpy/core/tests/test_multiarray.py b/numpy/core/tests/test_multiarray.py
index 4413cd0d0e69..9f113cb20fd5 100644
--- a/numpy/core/tests/test_multiarray.py
+++ b/numpy/core/tests/test_multiarray.py
@@ -9,6 +9,7 @@
 import ctypes
 import os
 import gc
+import re
 import weakref
 import pytest
 from contextlib import contextmanager
@@ -18,6 +19,7 @@
 import pathlib
 import builtins
 from decimal import Decimal
+import mmap
 
 import numpy as np
 import numpy.core._multiarray_tests as _multiarray_tests
@@ -28,8 +30,9 @@
     assert_allclose, IS_PYPY, IS_PYSTON, HAS_REFCOUNT, assert_array_less,
     runstring, temppath, suppress_warnings, break_cycles,
     )
-from numpy.testing._private.utils import _no_tracing
+from numpy.testing._private.utils import requires_memory, _no_tracing
 from numpy.core.tests._locales import CommaDecimalPointLocale
+from numpy.lib.recfunctions import repack_fields
 
 # Need to test an object that does not fully implement math interface
 from datetime import timedelta, datetime
@@ -66,13 +69,13 @@ def _aligned_zeros(shape, dtype=float, order="C", align=None):
     # Note: slices producing 0-size arrays do not necessarily change
     # data pointer --- so we use and allocate size+1
     buf = buf[offset:offset+size+1][:-1]
+    buf.fill(0)
     data = np.ndarray(shape, dtype, buf, order=order)
-    data.fill(0)
     return data
 
 
 class TestFlags:
-    def setup(self):
+    def setup_method(self):
         self.a = np.arange(10)
 
     def test_writeable(self):
@@ -234,11 +237,6 @@ def test_otherflags(self):
         assert_equal(self.a.flags.owndata, True)
         assert_equal(self.a.flags.writeable, True)
         assert_equal(self.a.flags.aligned, True)
-        with assert_warns(DeprecationWarning):
-            assert_equal(self.a.flags.updateifcopy, False)
-        with assert_warns(DeprecationWarning):
-            assert_equal(self.a.flags['U'], False)
-            assert_equal(self.a.flags['UPDATEIFCOPY'], False)
         assert_equal(self.a.flags.writebackifcopy, False)
         assert_equal(self.a.flags['X'], False)
         assert_equal(self.a.flags['WRITEBACKIFCOPY'], False)
@@ -278,7 +276,7 @@ def test_int(self):
 
 
 class TestAttributes:
-    def setup(self):
+    def setup_method(self):
         self.one = np.arange(10)
         self.two = np.arange(20).reshape(4, 5)
         self.three = np.arange(60, dtype=np.float64).reshape(2, 5, 6)
@@ -405,6 +403,13 @@ def test_fill_struct_array(self):
         assert_array_equal(x['a'], [3.5, 3.5])
         assert_array_equal(x['b'], [-2, -2])
 
+    def test_fill_readonly(self):
+        # gh-22922
+        a = np.zeros(11)
+        a.setflags(write=False)
+        with pytest.raises(ValueError, match=".*read-only"):
+            a.fill(0)
+
 
 class TestArrayConstruction:
     def test_array(self):
@@ -449,6 +454,9 @@ def test_array(self):
     def test_array_empty(self):
         assert_raises(TypeError, np.array)
 
+    def test_0d_array_shape(self):
+        assert np.ones(np.array(3)).shape == (3,)
+
     def test_array_copy_false(self):
         d = np.array([1, 2, 3])
         e = np.array(d, copy=False)
@@ -511,6 +519,7 @@ def test_array_as_keyword(self, func):
         else:
             func(a=3)
 
+
 class TestAssignment:
     def test_assignment_broadcasting(self):
         a = np.arange(6).reshape(2, 3)
@@ -563,18 +572,18 @@ def inject_str(s):
             finally:
                 set_string_function(None, repr=False)
 
-        a1d = np.array([u'test'])
-        a0d = np.array(u'done')
-        with inject_str(u'bad'):
+        a1d = np.array(['test'])
+        a0d = np.array('done')
+        with inject_str('bad'):
             a1d[0] = a0d  # previously this would invoke __str__
-        assert_equal(a1d[0], u'done')
+        assert_equal(a1d[0], 'done')
 
         # this would crash for the same reason
-        np.array([np.array(u'\xe5\xe4\xf6')])
+        np.array([np.array('\xe5\xe4\xf6')])
 
     def test_stringlike_empty_list(self):
         # gh-8902
-        u = np.array([u'done'])
+        u = np.array(['done'])
         b = np.array([b'done'])
 
         class bad_sequence:
@@ -651,7 +660,7 @@ def test_structured_non_void(self):
 
 
 class TestZeroRank:
-    def setup(self):
+    def setup_method(self):
         self.d = np.array(0), np.array('x', object)
 
     def test_ellipsis_subscript(self):
@@ -755,7 +764,7 @@ def test_real_imag(self):
 
 
 class TestScalarIndexing:
-    def setup(self):
+    def setup_method(self):
         self.d = np.array([0, 1])[0]
 
     def test_ellipsis_subscript(self):
@@ -1117,12 +1126,11 @@ def test_array_too_big(self):
                           shape=(max_bytes//itemsize + 1,), dtype=dtype)
 
     def _ragged_creation(self, seq):
-        # without dtype=object, the ragged object should raise
-        with assert_warns(np.VisibleDeprecationWarning):
+        # without dtype=object, the ragged object raises
+        with pytest.raises(ValueError, match=".*detected shape was"):
             a = np.array(seq)
-        b = np.array(seq, dtype=object)
-        assert_equal(a, b)
-        return b
+
+        return np.array(seq, dtype=object)
 
     def test_ragged_ndim_object(self):
         # Lists of mismatching depths are treated as object arrays
@@ -1171,6 +1179,20 @@ def test_deep_nonragged_object(self):
         a = np.array([1, Decimal(1)])
         a = np.array([[1], [Decimal(1)]])
 
+    @pytest.mark.parametrize("dtype", [object, "O,O", "O,(3)O", "(2,3)O"])
+    @pytest.mark.parametrize("function", [
+            np.ndarray, np.empty,
+            lambda shape, dtype: np.empty_like(np.empty(shape, dtype=dtype))])
+    def test_object_initialized_to_None(self, function, dtype):
+        # NumPy has support for object fields to be NULL (meaning None)
+        # but generally, we should always fill with the proper None, and
+        # downstream may rely on that.  (For fully initialized arrays!)
+        arr = function(3, dtype=dtype)
+        # We expect a fill value of None, which is not NULL:
+        expected = np.array(None).tobytes()
+        expected = expected * (arr.nbytes // len(expected))
+        assert arr.tobytes() == expected
+
 class TestStructured:
     def test_subarray_field_access(self):
         a = np.zeros((3, 5), dtype=[('a', ('i4', (2, 2)))])
@@ -1210,7 +1232,8 @@ def test_subarray_comparison(self):
                 assert_equal(a == b, [False, True])
                 assert_equal(a != b, [True, False])
 
-        # Check that broadcasting with a subarray works
+        # Check that broadcasting with a subarray works, including cases that
+        # require promotion to work:
         a = np.array([[(0,)], [(1,)]], dtype=[('a', 'f8')])
         b = np.array([(0,), (0,), (1,)], dtype=[('a', 'f8')])
         assert_equal(a == b, [[True, True, False], [False, False, True]])
@@ -1233,27 +1256,68 @@ def test_subarray_comparison(self):
         # Check that incompatible sub-array shapes don't result to broadcasting
         x = np.zeros((1,), dtype=[('a', ('f4', (1, 2))), ('b', 'i1')])
         y = np.zeros((1,), dtype=[('a', ('f4', (2,))), ('b', 'i1')])
-        # This comparison invokes deprecated behaviour, and will probably
-        # start raising an error eventually. What we really care about in this
-        # test is just that it doesn't return True.
-        with suppress_warnings() as sup:
-            sup.filter(FutureWarning, "elementwise == comparison failed")
-            assert_equal(x == y, False)
+        # The main importance is that it does not return True:
+        with pytest.raises(TypeError):
+            x == y
 
         x = np.zeros((1,), dtype=[('a', ('f4', (2, 1))), ('b', 'i1')])
         y = np.zeros((1,), dtype=[('a', ('f4', (2,))), ('b', 'i1')])
-        # This comparison invokes deprecated behaviour, and will probably
-        # start raising an error eventually. What we really care about in this
-        # test is just that it doesn't return True.
-        with suppress_warnings() as sup:
-            sup.filter(FutureWarning, "elementwise == comparison failed")
-            assert_equal(x == y, False)
-
-        # Check that structured arrays that are different only in
-        # byte-order work
+        # The main importance is that it does not return True:
+        with pytest.raises(TypeError):
+            x == y
+
+    def test_empty_structured_array_comparison(self):
+        # Check that comparison works on empty arrays with nontrivially
+        # shaped fields
+        a = np.zeros(0, [('a', 'i8'), ('b', 'f8')])
         assert_equal(a == b, [False, True])
+        assert_equal(a != b, [True, False])
+
+        a = np.array([(5, 42), (10, 1)], dtype=[('a', '>f8'), ('b', 'i8')])
+        assert_equal(a == b, [False, True])
+        assert_equal(a != b, [True, False])
+
+        # Including with embedded subarray dtype (although subarray comparison
+        # itself may still be a bit weird and compare the raw data)
+        a = np.array([(5, 42), (10, 1)], dtype=[('a', '10>f8'), ('b', '5i8')])
+        assert_equal(a == b, [False, True])
+        assert_equal(a != b, [True, False])
+
+    def test_void_comparison_failures(self):
+        # In principle, one could decide to return an array of False for some
+        # if comparisons are impossible.  But right now we return TypeError
+        # when "void" dtype are involved.
+        x = np.zeros(3, dtype=[('a', 'i1')])
+        y = np.zeros(3)
+        # Cannot compare non-structured to structured:
+        with pytest.raises(TypeError):
+            x == y
+
+        # Added title prevents promotion, but casts are OK:
+        y = np.zeros(3, dtype=[(('title', 'a'), 'i1')])
+        assert np.can_cast(y.dtype, x.dtype)
+        with pytest.raises(TypeError):
+            x == y
+
+        x = np.zeros(3, dtype="V7")
+        y = np.zeros(3, dtype="V8")
+        with pytest.raises(TypeError):
+            x == y
 
     def test_casting(self):
         # Check that casting a structured array to change its byte order
@@ -1428,7 +1492,7 @@ def testassign(arr, v):
         assert_equal(testassign(arr, v1), ans)
         assert_equal(testassign(arr, v2), ans)
         assert_equal(testassign(arr, v3), ans)
-        assert_raises(ValueError, lambda: testassign(arr, v4))
+        assert_raises(TypeError, lambda: testassign(arr, v4))
         assert_equal(testassign(arr, v5), ans)
         w[:] = 4
         assert_equal(arr, np.array([(1,4),(1,4)], dtype=dt))
@@ -1463,6 +1527,75 @@ def test_multiindex_titles(self):
         assert_raises(ValueError, lambda : a[['b','b']])  # field exists, but repeated
         a[['b','c']]  # no exception
 
+    def test_structured_cast_promotion_fieldorder(self):
+        # gh-15494
+        # dtypes with different field names are not promotable
+        A = ("a", "i8")
+        ab = np.array([(1, 2)], dtype=[A, B])
+        ba = np.array([(1, 2)], dtype=[B, A])
+        assert_raises(TypeError, np.concatenate, ab, ba)
+        assert_raises(TypeError, np.result_type, ab.dtype, ba.dtype)
+        assert_raises(TypeError, np.promote_types, ab.dtype, ba.dtype)
+
+        # dtypes with same field names/order but different memory offsets
+        # and byte-order are promotable to packed nbo.
+        assert_equal(np.promote_types(ab.dtype, ba[['a', 'b']].dtype),
+                     repack_fields(ab.dtype.newbyteorder('N')))
+
+        # gh-13667
+        # dtypes with different fieldnames but castable field types are castable
+        assert_equal(np.can_cast(ab.dtype, ba.dtype), True)
+        assert_equal(ab.astype(ba.dtype).dtype, ba.dtype)
+        assert_equal(np.can_cast('f8,i8', [('f0', 'f8'), ('f1', 'i8')]), True)
+        assert_equal(np.can_cast('f8,i8', [('f1', 'f8'), ('f0', 'i8')]), True)
+        assert_equal(np.can_cast('f8,i8', [('f1', 'i8'), ('f0', 'f8')]), False)
+        assert_equal(np.can_cast('f8,i8', [('f1', 'i8'), ('f0', 'f8')],
+                                 casting='unsafe'), True)
+
+        ab[:] = ba  # make sure assignment still works
+
+        # tests of type-promotion of corresponding fields
+        dt1 = np.dtype([("", "i4")])
+        dt2 = np.dtype([("", "i8")])
+        assert_equal(np.promote_types(dt1, dt2), np.dtype([('f0', 'i8')]))
+        assert_equal(np.promote_types(dt2, dt1), np.dtype([('f0', 'i8')]))
+        assert_raises(TypeError, np.promote_types, dt1, np.dtype([("", "V3")]))
+        assert_equal(np.promote_types('i4,f8', 'i8,f4'),
+                     np.dtype([('f0', 'i8'), ('f1', 'f8')]))
+        # test nested case
+        dt1nest = np.dtype([("", dt1)])
+        dt2nest = np.dtype([("", dt2)])
+        assert_equal(np.promote_types(dt1nest, dt2nest),
+                     np.dtype([('f0', np.dtype([('f0', 'i8')]))]))
+
+        # note that offsets are lost when promoting:
+        dt = np.dtype({'names': ['x'], 'formats': ['i4'], 'offsets': [8]})
+        a = np.ones(3, dtype=dt)
+        assert_equal(np.concatenate([a, a]).dtype, np.dtype([('x', 'i4')]))
+
+    @pytest.mark.parametrize("dtype_dict", [
+            dict(names=["a", "b"], formats=["i4", "f"], itemsize=100),
+            dict(names=["a", "b"], formats=["i4", "f"],
+                 offsets=[0, 12])])
+    @pytest.mark.parametrize("align", [True, False])
+    def test_structured_promotion_packs(self, dtype_dict, align):
+        # Structured dtypes are packed when promoted (we consider the packed
+        # form to be "canonical"), so tere is no extra padding.
+        dtype = np.dtype(dtype_dict, align=align)
+        # Remove non "canonical" dtype options:
+        dtype_dict.pop("itemsize", None)
+        dtype_dict.pop("offsets", None)
+        expected = np.dtype(dtype_dict, align=align)
+
+        res = np.promote_types(dtype, dtype)
+        assert res.itemsize == expected.itemsize
+        assert res.fields == expected.fields
+
+        # But the "expected" one, should just be returned unchanged:
+        res = np.promote_types(expected, expected)
+        assert res is expected
+
     def test_structured_asarray_is_view(self):
         # A scalar viewing an array preserves its view even when creating a
         # new array. This test documents behaviour, it may not be the best
@@ -1640,6 +1773,15 @@ def test_pickle(self):
 
                 assert_equal(zs.dtype, zs2.dtype)
 
+    def test_pickle_empty(self):
+        """Checking if an empty array pickled and un-pickled will not cause a
+        segmentation fault"""
+        arr = np.array([]).reshape(999999, 0)
+        pk_dmp = pickle.dumps(arr)
+        pk_load = pickle.loads(pk_dmp)
+
+        assert pk_load.size == 0
+
     @pytest.mark.skipif(pickle.HIGHEST_PROTOCOL < 5,
                         reason="requires pickle protocol 5")
     def test_pickle_with_buffercallback(self):
@@ -2099,6 +2241,28 @@ def assert_c(arr):
         assert_fortran(a.copy('F'))
         assert_c(a.copy('A'))
 
+    @pytest.mark.parametrize("dtype", ['O', np.int32, 'i,O'])
+    def test__deepcopy__(self, dtype):
+        # Force the entry of NULLs into array
+        a = np.empty(4, dtype=dtype)
+        ctypes.memset(a.ctypes.data, 0, a.nbytes)
+
+        # Ensure no error is raised, see gh-21833
+        b = a.__deepcopy__({})
+
+        a[0] = 42
+        with pytest.raises(AssertionError):
+            assert_array_equal(a, b)
+
+    def test__deepcopy__catches_failure(self):
+        class MyObj:
+            def __deepcopy__(self, *args, **kwargs):
+                raise RuntimeError
+
+        arr = np.array([1, MyObj(), 3], dtype='O')
+        with pytest.raises(RuntimeError):
+            arr.__deepcopy__({})
+
     def test_sort_order(self):
         # Test sorting an array with fields
         x1 = np.array([21, 32, 14])
@@ -2279,23 +2443,32 @@ def test_sort_unicode_kind(self):
         assert_raises(ValueError, d.sort, kind=k)
         assert_raises(ValueError, d.argsort, kind=k)
 
-    def test_searchsorted(self):
-        # test for floats and complex containing nans. The logic is the
-        # same for all float types so only test double types for now.
-        # The search sorted routines use the compare functions for the
-        # array type, so this checks if that is consistent with the sort
-        # order.
-
-        # check double
-        a = np.array([0, 1, np.nan])
-        msg = "Test real searchsorted with nans, side='l'"
+    @pytest.mark.parametrize('a', [
+        np.array([0, 1, np.nan], dtype=np.float16),
+        np.array([0, 1, np.nan], dtype=np.float32),
+        np.array([0, 1, np.nan]),
+    ])
+    def test_searchsorted_floats(self, a):
+        # test for floats arrays containing nans. Explicitly test
+        # half, single, and double precision floats to verify that
+        # the NaN-handling is correct.
+        msg = "Test real (%s) searchsorted with nans, side='l'" % a.dtype
         b = a.searchsorted(a, side='left')
         assert_equal(b, np.arange(3), msg)
-        msg = "Test real searchsorted with nans, side='r'"
+        msg = "Test real (%s) searchsorted with nans, side='r'" % a.dtype
         b = a.searchsorted(a, side='right')
         assert_equal(b, np.arange(1, 4), msg)
         # check keyword arguments
         a.searchsorted(v=1)
+        x = np.array([0, 1, np.nan], dtype='float32')
+        y = np.searchsorted(x, x[-1])
+        assert_equal(y, 2)
+
+    def test_searchsorted_complex(self):
+        # test for complex arrays containing nans.
+        # The search sorted routines use the compare functions for the
+        # array type, so this checks if that is consistent with the sort
+        # order.
         # check double complex
         a = np.zeros(9, dtype=np.complex128)
         a.real += [0, 0, 1, 1, 0, 1, np.nan, np.nan, np.nan]
@@ -2315,6 +2488,7 @@ def test_searchsorted(self):
         b = a.searchsorted(np.array(128, dtype='>i4'))
         assert_equal(b, 1, msg)
 
+    def test_searchsorted_n_elements(self):
         # Check 0 elements
         a = np.ones(0)
         b = a.searchsorted([0, 1, 2], 'left')
@@ -2334,6 +2508,7 @@ def test_searchsorted(self):
         b = a.searchsorted([0, 1, 2], 'right')
         assert_equal(b, [0, 2, 2])
 
+    def test_searchsorted_unaligned_array(self):
         # Test searching unaligned array
         a = np.arange(10)
         aligned = np.empty(a.itemsize * a.size + 1, 'uint8')
@@ -2350,6 +2525,7 @@ def test_searchsorted(self):
         b = a.searchsorted(unaligned, 'right')
         assert_equal(b, a + 1)
 
+    def test_searchsorted_resetting(self):
         # Test smart resetting of binsearch indices
         a = np.arange(5)
         b = a.searchsorted([6, 5, 4], 'left')
@@ -2357,6 +2533,7 @@ def test_searchsorted(self):
         b = a.searchsorted([6, 5, 4], 'right')
         assert_equal(b, [5, 5, 5])
 
+    def test_searchsorted_type_specific(self):
         # Test all type specific binary search functions
         types = ''.join((np.typecodes['AllInteger'], np.typecodes['AllFloat'],
                          np.typecodes['Datetime'], '?O'))
@@ -3300,11 +3477,11 @@ def test_ravel(self):
         assert_equal(a.ravel('C'), [3, 2, 1, 0])
         assert_equal(a.ravel('K'), [3, 2, 1, 0])
 
-        # 1-element tidy strides test (NPY_RELAXED_STRIDES_CHECKING):
+        # 1-element tidy strides test:
         a = np.array([[1]])
         a.strides = (123, 432)
-        # If the stride is not 8, NPY_RELAXED_STRIDES_CHECKING is messing
-        # them up on purpose:
+        # If the following stride is not 8, NPY_RELAXED_STRIDES_DEBUG is
+        # messing them up on purpose:
         if np.ones(1).strides == (8,):
             assert_(np.may_share_memory(a.ravel('K'), a))
             assert_equal(a.ravel('K').strides, (a.dtype.itemsize,))
@@ -3690,6 +3867,32 @@ def first_out_arg(result):
         check(make_obj(np.ndarray, array_ufunc=None), True, False, False,
               check_scalar=False)
 
+    @pytest.mark.parametrize("priority", [None, "runtime error"])
+    def test_ufunc_binop_bad_array_priority(self, priority):
+        # Mainly checks that this does not crash.  The second array has a lower
+        # priority than -1 ("error value").  If the __radd__ actually exists,
+        # bad things can happen (I think via the scalar paths).
+        # In principle both of these can probably just be errors in the future.
+        class BadPriority:
+            @property
+            def __array_priority__(self):
+                if priority == "runtime error":
+                    raise RuntimeError("RuntimeError in __array_priority__!")
+                return priority
+
+            def __radd__(self, other):
+                return "result"
+
+        class LowPriority(np.ndarray):
+            __array_priority__ = -1000
+
+        # Priority failure uses the same as scalars (smaller -1000).  So the
+        # LowPriority wins with 'result' for each element (inner operation).
+        res = np.arange(3).view(LowPriority) + BadPriority()
+        assert res.shape == (3,)
+        assert res[0] == 'result'
+
+
     def test_ufunc_override_normalize_signature(self):
         # gh-5674
         class SomeClass:
@@ -3950,6 +4153,41 @@ def test_IsPythonScalar(self):
         assert_(IsPythonScalar(2.))
         assert_(IsPythonScalar("a"))
 
+    @pytest.mark.parametrize("converter",
+             [_multiarray_tests.run_scalar_intp_converter,
+              _multiarray_tests.run_scalar_intp_from_sequence])
+    def test_intp_sequence_converters(self, converter):
+        # Test simple values (-1 is special for error return paths)
+        assert converter(10) == (10,)
+        assert converter(-1) == (-1,)
+        # A 0-D array looks a bit like a sequence but must take the integer
+        # path:
+        assert converter(np.array(123)) == (123,)
+        # Test simple sequences (intp_from_sequence only supports length 1):
+        assert converter((10,)) == (10,)
+        assert converter(np.array([11])) == (11,)
+
+    @pytest.mark.parametrize("converter",
+             [_multiarray_tests.run_scalar_intp_converter,
+              _multiarray_tests.run_scalar_intp_from_sequence])
+    @pytest.mark.skipif(IS_PYPY and sys.implementation.version <= (7, 3, 8),
+            reason="PyPy bug in error formatting")
+    def test_intp_sequence_converters_errors(self, converter):
+        with pytest.raises(TypeError,
+                match="expected a sequence of integers or a single integer, "):
+            converter(object())
+        with pytest.raises(TypeError,
+                match="expected a sequence of integers or a single integer, "
+                      "got '32.0'"):
+            converter(32.)
+        with pytest.raises(TypeError,
+                match="'float' object cannot be interpreted as an integer"):
+            converter([32.])
+        with pytest.raises(ValueError,
+                match="Maximum allowed dimension"):
+            # These converters currently convert overflows to a ValueError
+            converter(2**64)
+
 
 class TestSubscripting:
     def test_test_zero_rank(self):
@@ -3965,13 +4203,6 @@ class TestPickling:
     def test_correct_protocol5_error_message(self):
         array = np.arange(10)
 
-        if sys.version_info[:2] in ((3, 6), (3, 7)):
-            # For the specific case of python3.6 and 3.7, raise a clear import
-            # error about the pickle5 backport when trying to use protocol=5
-            # without the pickle5 package
-            with pytest.raises(ImportError):
-                array.__reduce_ex__(5)
-
     def test_record_array_with_object_dtype(self):
         my_object = object()
 
@@ -4181,8 +4412,8 @@ def test_mixed(self):
         assert_array_equal(g1 >= g2, [x >= g2 for x in g1])
 
     def test_unicode(self):
-        g1 = np.array([u"This", u"is", u"example"])
-        g2 = np.array([u"This", u"was", u"example"])
+        g1 = np.array(["This", "is", "example"])
+        g2 = np.array(["This", "was", "example"])
         assert_array_equal(g1 == g2, [g1[i] == g2[i] for i in [0, 1, 2]])
         assert_array_equal(g1 != g2, [g1[i] != g2[i] for i in [0, 1, 2]])
         assert_array_equal(g1 <= g2, [g1[i] <= g2[i] for i in [0, 1, 2]])
@@ -4195,7 +4426,8 @@ class TestArgmaxArgminCommon:
     sizes = [(), (3,), (3, 2), (2, 3),
              (3, 3), (2, 3, 4), (4, 3, 2),
              (1, 2, 3, 4), (2, 3, 4, 1),
-             (3, 4, 1, 2), (4, 1, 2, 3)]
+             (3, 4, 1, 2), (4, 1, 2, 3),
+             (64,), (128,), (256,)]
 
     @pytest.mark.parametrize("size, axis", itertools.chain(*[[(size, axis)
         for axis in list(range(-len(size), len(size))) + [None]]
@@ -4309,9 +4541,9 @@ def test_output_shape(self, method):
     @pytest.mark.parametrize('ndim', [0, 1])
     @pytest.mark.parametrize('method', ['argmax', 'argmin'])
     def test_ret_is_out(self, ndim, method):
-        a = np.ones((4,) + (3,)*ndim)
+        a = np.ones((4,) + (256,)*ndim)
         arg_method = getattr(a, method)
-        out = np.empty((3,)*ndim, dtype=np.intp)
+        out = np.empty((256,)*ndim, dtype=np.intp)
         ret = arg_method(axis=0, out=out)
         assert ret is out
 
@@ -4362,12 +4594,44 @@ def test_object_with_NULLs(self, method, vals):
         assert_equal(arg_method(), 1)
 
 class TestArgmax:
-
-    nan_arr = [
-        ([0, 1, 2, 3, np.nan], 4),
-        ([0, 1, 2, np.nan, 3], 3),
-        ([np.nan, 0, 1, 2, 3], 0),
-        ([np.nan, 0, np.nan, 2, 3], 0),
+    usg_data = [
+        ([1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], 0),
+        ([3, 3, 3, 3,  2,  2,  2,  2], 0),
+        ([0, 1, 2, 3,  4,  5,  6,  7], 7),
+        ([7, 6, 5, 4,  3,  2,  1,  0], 0)
+    ]
+    sg_data = usg_data + [
+        ([1, 2, 3, 4, -4, -3, -2, -1], 3),
+        ([1, 2, 3, 4, -1, -2, -3, -4], 3)
+    ]
+    darr = [(np.array(d[0], dtype=t), d[1]) for d, t in (
+        itertools.product(usg_data, (
+            np.uint8, np.uint16, np.uint32, np.uint64
+        ))
+    )]
+    darr = darr + [(np.array(d[0], dtype=t), d[1]) for d, t in (
+        itertools.product(sg_data, (
+            np.int8, np.int16, np.int32, np.int64, np.float32, np.float64
+        ))
+    )]
+    darr = darr + [(np.array(d[0], dtype=t), d[1]) for d, t in (
+        itertools.product((
+            ([0, 1, 2, 3, np.nan], 4),
+            ([0, 1, 2, np.nan, 3], 3),
+            ([np.nan, 0, 1, 2, 3], 0),
+            ([np.nan, 0, np.nan, 2, 3], 0),
+            # To hit the tail of SIMD multi-level(x4, x1) inner loops
+            # on variant SIMD widthes
+            ([1] * (2*5-1) + [np.nan], 2*5-1),
+            ([1] * (4*5-1) + [np.nan], 4*5-1),
+            ([1] * (8*5-1) + [np.nan], 8*5-1),
+            ([1] * (16*5-1) + [np.nan], 16*5-1),
+            ([1] * (32*5-1) + [np.nan], 32*5-1)
+        ), (
+            np.float32, np.float64
+        ))
+    )]
+    nan_arr = darr + [
         ([0, 1, 2, 3, complex(0, np.nan)], 4),
         ([0, 1, 2, 3, complex(np.nan, 0)], 4),
         ([0, 1, 2, complex(np.nan, 0), 3], 3),
@@ -4437,28 +4701,80 @@ def test_combinations(self, data):
         assert_equal(np.argmax(arr), pos, err_msg="%r" % arr)
         assert_equal(arr[np.argmax(arr)], val, err_msg="%r" % arr)
 
+        # add padding to test SIMD loops
+        rarr = np.repeat(arr, 129)
+        rpos = pos * 129
+        assert_equal(np.argmax(rarr), rpos, err_msg="%r" % rarr)
+        assert_equal(rarr[np.argmax(rarr)], val, err_msg="%r" % rarr)
+
+        padd = np.repeat(np.min(arr), 513)
+        rarr = np.concatenate((arr, padd))
+        rpos = pos
+        assert_equal(np.argmax(rarr), rpos, err_msg="%r" % rarr)
+        assert_equal(rarr[np.argmax(rarr)], val, err_msg="%r" % rarr)
+
+
     def test_maximum_signed_integers(self):
 
         a = np.array([1, 2**7 - 1, -2**7], dtype=np.int8)
         assert_equal(np.argmax(a), 1)
+        a.repeat(129)
+        assert_equal(np.argmax(a), 1)
 
         a = np.array([1, 2**15 - 1, -2**15], dtype=np.int16)
         assert_equal(np.argmax(a), 1)
+        a.repeat(129)
+        assert_equal(np.argmax(a), 1)
 
         a = np.array([1, 2**31 - 1, -2**31], dtype=np.int32)
         assert_equal(np.argmax(a), 1)
+        a.repeat(129)
+        assert_equal(np.argmax(a), 1)
 
         a = np.array([1, 2**63 - 1, -2**63], dtype=np.int64)
         assert_equal(np.argmax(a), 1)
-
+        a.repeat(129)
+        assert_equal(np.argmax(a), 1)
 
 class TestArgmin:
-
-    nan_arr = [
-        ([0, 1, 2, 3, np.nan], 4),
-        ([0, 1, 2, np.nan, 3], 3),
-        ([np.nan, 0, 1, 2, 3], 0),
-        ([np.nan, 0, np.nan, 2, 3], 0),
+    usg_data = [
+        ([1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], 8),
+        ([3, 3, 3, 3,  2,  2,  2,  2], 4),
+        ([0, 1, 2, 3,  4,  5,  6,  7], 0),
+        ([7, 6, 5, 4,  3,  2,  1,  0], 7)
+    ]
+    sg_data = usg_data + [
+        ([1, 2, 3, 4, -4, -3, -2, -1], 4),
+        ([1, 2, 3, 4, -1, -2, -3, -4], 7)
+    ]
+    darr = [(np.array(d[0], dtype=t), d[1]) for d, t in (
+        itertools.product(usg_data, (
+            np.uint8, np.uint16, np.uint32, np.uint64
+        ))
+    )]
+    darr = darr + [(np.array(d[0], dtype=t), d[1]) for d, t in (
+        itertools.product(sg_data, (
+            np.int8, np.int16, np.int32, np.int64, np.float32, np.float64
+        ))
+    )]
+    darr = darr + [(np.array(d[0], dtype=t), d[1]) for d, t in (
+        itertools.product((
+            ([0, 1, 2, 3, np.nan], 4),
+            ([0, 1, 2, np.nan, 3], 3),
+            ([np.nan, 0, 1, 2, 3], 0),
+            ([np.nan, 0, np.nan, 2, 3], 0),
+            # To hit the tail of SIMD multi-level(x4, x1) inner loops
+            # on variant SIMD widthes
+            ([1] * (2*5-1) + [np.nan], 2*5-1),
+            ([1] * (4*5-1) + [np.nan], 4*5-1),
+            ([1] * (8*5-1) + [np.nan], 8*5-1),
+            ([1] * (16*5-1) + [np.nan], 16*5-1),
+            ([1] * (32*5-1) + [np.nan], 32*5-1)
+        ), (
+            np.float32, np.float64
+        ))
+    )]
+    nan_arr = darr + [
         ([0, 1, 2, 3, complex(0, np.nan)], 4),
         ([0, 1, 2, 3, complex(np.nan, 0)], 4),
         ([0, 1, 2, complex(np.nan, 0), 3], 3),
@@ -4517,30 +4833,50 @@ class TestArgmin:
         ([False, True, False, True, True], 0),
     ]
 
-    def test_combinations(self):
-        for arr, pos in self.nan_arr:
-            with suppress_warnings() as sup:
-                sup.filter(RuntimeWarning,
-                           "invalid value encountered in reduce")
-                min_val = np.min(arr)
+    @pytest.mark.parametrize('data', nan_arr)
+    def test_combinations(self, data):
+        arr, pos = data
+        with suppress_warnings() as sup:
+            sup.filter(RuntimeWarning,
+                       "invalid value encountered in reduce")
+            min_val = np.min(arr)
+
+        assert_equal(np.argmin(arr), pos, err_msg="%r" % arr)
+        assert_equal(arr[np.argmin(arr)], min_val, err_msg="%r" % arr)
 
-            assert_equal(np.argmin(arr), pos, err_msg="%r" % arr)
-            assert_equal(arr[np.argmin(arr)], min_val, err_msg="%r" % arr)
+        # add padding to test SIMD loops
+        rarr = np.repeat(arr, 129)
+        rpos = pos * 129
+        assert_equal(np.argmin(rarr), rpos, err_msg="%r" % rarr)
+        assert_equal(rarr[np.argmin(rarr)], min_val, err_msg="%r" % rarr)
+
+        padd = np.repeat(np.max(arr), 513)
+        rarr = np.concatenate((arr, padd))
+        rpos = pos
+        assert_equal(np.argmin(rarr), rpos, err_msg="%r" % rarr)
+        assert_equal(rarr[np.argmin(rarr)], min_val, err_msg="%r" % rarr)
 
     def test_minimum_signed_integers(self):
 
         a = np.array([1, -2**7, -2**7 + 1, 2**7 - 1], dtype=np.int8)
         assert_equal(np.argmin(a), 1)
+        a.repeat(129)
+        assert_equal(np.argmin(a), 1)
 
         a = np.array([1, -2**15, -2**15 + 1, 2**15 - 1], dtype=np.int16)
         assert_equal(np.argmin(a), 1)
+        a.repeat(129)
+        assert_equal(np.argmin(a), 1)
 
         a = np.array([1, -2**31, -2**31 + 1, 2**31 - 1], dtype=np.int32)
         assert_equal(np.argmin(a), 1)
+        a.repeat(129)
+        assert_equal(np.argmin(a), 1)
 
         a = np.array([1, -2**63, -2**63 + 1, 2**63 - 1], dtype=np.int64)
         assert_equal(np.argmin(a), 1)
-
+        a.repeat(129)
+        assert_equal(np.argmin(a), 1)
 
 class TestMinMax:
 
@@ -4691,6 +5027,8 @@ def test_ip_types(self):
             for types in np.sctypes.values():
                 for T in types:
                     if T not in unchecked_types:
+                        if val < 0 and np.dtype(T).kind == "u":
+                            val = np.iinfo(T).max - 99
                         self.tst_basic(x.copy().astype(T), T, mask, val)
 
             # Also test string of a length which uses an untypical length
@@ -5189,10 +5527,12 @@ def test_binary(self, tmp_filename):
 
     @pytest.mark.slow  # takes > 1 minute on mechanical hard drive
     def test_big_binary(self):
-        """Test workarounds for 32-bit limited fwrite, fseek, and ftell
-        calls in windows. These normally would hang doing something like this.
-        See http://projects.scipy.org/numpy/ticket/1660"""
-        if sys.platform != 'win32':
+        """Test workarounds for 32-bit limit for MSVC fwrite, fseek, and ftell
+
+        These normally would hang doing something like this.
+        See : https://github.com/numpy/numpy/issues/2256
+        """
+        if sys.platform != 'win32' or '[GCC ' in sys.version:
             return
         try:
             # before workarounds, only up to 2**32-1 worked
@@ -5340,12 +5680,36 @@ def test_basic(self, byteorder, dtype):
         buf = x.tobytes()
         assert_array_equal(np.frombuffer(buf, dtype=dt), x.flat)
 
+    @pytest.mark.parametrize("obj", [np.arange(10), b"12345678"])
+    def test_array_base(self, obj):
+        # Objects (including NumPy arrays), which do not use the
+        # `release_buffer` slot should be directly used as a base object.
+        # See also gh-21612
+        new = np.frombuffer(obj)
+        assert new.base is obj
+
     def test_empty(self):
         assert_array_equal(np.frombuffer(b''), np.array([]))
 
+    @pytest.mark.skipif(IS_PYPY,
+            reason="PyPy's memoryview currently does not track exports. See: "
+                   "https://foss.heptapod.net/pypy/pypy/-/issues/3724")
+    def test_mmap_close(self):
+        # The old buffer protocol was not safe for some things that the new
+        # one is.  But `frombuffer` always used the old one for a long time.
+        # Checks that it is safe with the new one (using memoryviews)
+        with tempfile.TemporaryFile(mode='wb') as tmp:
+            tmp.write(b"asdf")
+            tmp.flush()
+            mm = mmap.mmap(tmp.fileno(), 0)
+            arr = np.frombuffer(mm, dtype=np.uint8)
+            with pytest.raises(BufferError):
+                mm.close()  # cannot close while array uses the buffer
+            del arr
+            mm.close()
 
 class TestFlat:
-    def setup(self):
+    def setup_method(self):
         a0 = np.arange(20.0)
         a = a0.reshape(4, 5)
         a0.shape = (4, 5)
@@ -5381,19 +5745,8 @@ def test___array__(self):
 
         assert_(c.flags.writeable is False)
         assert_(d.flags.writeable is False)
-        # for 1.14 all are set to non-writeable on the way to replacing the
-        # UPDATEIFCOPY array returned for non-contiguous arrays.
         assert_(e.flags.writeable is True)
         assert_(f.flags.writeable is False)
-        with assert_warns(DeprecationWarning):
-            assert_(c.flags.updateifcopy is False)
-        with assert_warns(DeprecationWarning):
-            assert_(d.flags.updateifcopy is False)
-        with assert_warns(DeprecationWarning):
-            assert_(e.flags.updateifcopy is False)
-        with assert_warns(DeprecationWarning):
-            # UPDATEIFCOPY is removed.
-            assert_(f.flags.updateifcopy is False)
         assert_(c.flags.writebackifcopy is False)
         assert_(d.flags.writebackifcopy is False)
         assert_(e.flags.writebackifcopy is False)
@@ -5564,17 +5917,18 @@ def test_dtype_unicode():
     def test_fromarrays_unicode(self):
         # A single name string provided to fromarrays() is allowed to be unicode
         # on both Python 2 and 3:
-        x = np.core.records.fromarrays([[0], [1]], names=u'a,b', formats=u'i4,i4')
+        x = np.core.records.fromarrays(
+            [[0], [1]], names='a,b', formats='i4,i4')
         assert_equal(x['a'][0], 0)
         assert_equal(x['b'][0], 1)
 
     def test_unicode_order(self):
         # Test that we can sort with order as a unicode field name in both Python 2 and
         # 3:
-        name = u'b'
+        name = 'b'
         x = np.array([1, 3, 2], dtype=[(name, int)])
         x.sort(order=name)
-        assert_equal(x[u'b'], np.array([1, 2, 3]))
+        assert_equal(x['b'], np.array([1, 2, 3]))
 
     def test_field_names(self):
         # Test unicode and 8-bit / byte strings can be used
@@ -5614,8 +5968,8 @@ def test_field_names(self):
         assert_equal(b[['f1', 'f3']][0].tolist(), (2, (1,)))
 
         # non-ascii unicode field indexing is well behaved
-        assert_raises(ValueError, a.__setitem__, u'\u03e0', 1)
-        assert_raises(ValueError, a.__getitem__, u'\u03e0')
+        assert_raises(ValueError, a.__setitem__, '\u03e0', 1)
+        assert_raises(ValueError, a.__getitem__, '\u03e0')
 
     def test_record_hash(self):
         a = np.array([(1, 2), (1, 2)], dtype='i1,i2')
@@ -5679,7 +6033,7 @@ class TestStats:
 
     funcs = [_mean, _var, _std]
 
-    def setup(self):
+    def setup_method(self):
         np.random.seed(range(3))
         self.rmat = np.random.random((4, 5))
         self.cmat = self.rmat + 1j * self.rmat
@@ -6106,7 +6460,7 @@ def test_vdot_uncontiguous(self):
 
 
 class TestDot:
-    def setup(self):
+    def setup_method(self):
         np.random.seed(128)
         self.A = np.random.rand(4, 2)
         self.b1 = np.random.rand(2, 1)
@@ -6375,6 +6729,27 @@ def assert_dot_close(A, X, desired):
             # Strides in A cols and X
             assert_dot_close(A_f_12, X_f_2, desired)
 
+    @pytest.mark.slow
+    @pytest.mark.parametrize("dtype", [np.float64, np.complex128])
+    @requires_memory(free_bytes=18e9)  # complex case needs 18GiB+
+    def test_huge_vectordot(self, dtype):
+        # Large vector multiplications are chunked with 32bit BLAS
+        # Test that the chunking does the right thing, see also gh-22262
+        data = np.ones(2**30+100, dtype=dtype)
+        res = np.dot(data, data)
+        assert res == 2**30+100
+
+    def test_dtype_discovery_fails(self):
+        # See gh-14247, error checking was missing for failed dtype discovery
+        class BadObject(object):
+            def __array__(self):
+                raise TypeError("just this tiny mint leaf")
+
+        with pytest.raises(TypeError):
+            np.dot(BadObject(), BadObject())
+
+        with pytest.raises(TypeError):
+            np.dot(3.0, BadObject())
 
 
 class MatmulCommon:
@@ -6881,35 +7256,14 @@ def test_3d_tensor(self):
                    [2630, 2910, 3190]],
 
                   [[2198, 2542, 2886],
-                   [3230, 3574, 3918]]]],
-                dtype=dt
-            )
+                   [3230, 3574, 3918]]]]
+            ).astype(dt)
             assert_equal(np.inner(a, b), desired)
             assert_equal(np.inner(b, a).transpose(2,3,0,1), desired)
 
 
-class TestAlen:
-    def test_basic(self):
-        with pytest.warns(DeprecationWarning):
-            m = np.array([1, 2, 3])
-            assert_equal(np.alen(m), 3)
-
-            m = np.array([[1, 2, 3], [4, 5, 7]])
-            assert_equal(np.alen(m), 2)
-
-            m = [1, 2, 3]
-            assert_equal(np.alen(m), 3)
-
-            m = [[1, 2, 3], [4, 5, 7]]
-            assert_equal(np.alen(m), 2)
-
-    def test_singleton(self):
-        with pytest.warns(DeprecationWarning):
-            assert_equal(np.alen(5), 1)
-
-
 class TestChoose:
-    def setup(self):
+    def setup_method(self):
         self.x = 2*np.ones((3,), dtype=int)
         self.y = 3*np.ones((3,), dtype=int)
         self.x2 = 2*np.ones((2, 3), dtype=int)
@@ -6939,7 +7293,7 @@ def test_output_dtype(self, ops):
 
 
 class TestRepeat:
-    def setup(self):
+    def setup_method(self):
         self.m = np.array([1, 2, 3, 4, 5, 6])
         self.m_rect = self.m.reshape((2, 3))
 
@@ -7576,7 +7930,7 @@ def test_export_record(self):
             assert_equal(y.format, 'T{b:a:=h:b:i:c:l:d:q:dx:B:e:@H:f:=I:g:L:h:Q:hx:f:i:d:j:^g:k:=Zf:ix:Zd:jx:^Zg:kx:4s:l:=4w:m:3x:n:?:o:@e:p:}')
         else:
             assert_equal(y.format, 'T{b:a:=h:b:i:c:q:d:q:dx:B:e:@H:f:=I:g:Q:h:Q:hx:f:i:d:j:^g:k:=Zf:ix:Zd:jx:^Zg:kx:4s:l:=4w:m:3x:n:?:o:@e:p:}')
-        # Cannot test if NPY_RELAXED_STRIDES_CHECKING changes the strides
+        # Cannot test if NPY_RELAXED_STRIDES_DEBUG changes the strides
         if not (np.ones(1).strides[0] == np.iinfo(np.intp).max):
             assert_equal(y.strides, (sz,))
         assert_equal(y.itemsize, sz)
@@ -7666,10 +8020,7 @@ def test_padded_struct_array(self):
     def test_relaxed_strides(self, c=np.ones((1, 10, 10), dtype='i8')):
         # Note: c defined as parameter so that it is persistent and leak
         # checks will notice gh-16934 (buffer info cache leak).
-
-        # Check for NPY_RELAXED_STRIDES_CHECKING:
-        if np.ones((10, 1), order="C").flags.f_contiguous:
-            c.strides = (-1, 80, 8)
+        c.strides = (-1, 80, 8)  # strides need to be fixed at export
 
         assert_(memoryview(c).strides == (800, 80, 8))
 
@@ -7813,6 +8164,26 @@ def test_error_if_stored_buffer_info_is_corrupted(self, obj):
         # Fix buffer info again before we delete (or we lose the memory)
         _multiarray_tests.corrupt_or_fix_bufferinfo(obj)
 
+    def test_no_suboffsets(self):
+        try:
+            import _testbuffer
+        except ImportError:
+            raise pytest.skip("_testbuffer is not available")
+
+        for shape in [(2, 3), (2, 3, 4)]:
+            data = list(range(np.prod(shape)))
+            buffer = _testbuffer.ndarray(data, shape, format='i',
+                                         flags=_testbuffer.ND_PIL)
+            msg = "NumPy currently does not support.*suboffsets"
+            with pytest.raises(BufferError, match=msg):
+                np.asarray(buffer)
+            with pytest.raises(BufferError, match=msg):
+                np.asarray([buffer])
+
+            # Also check (unrelated and more limited but similar) frombuffer:
+            with pytest.raises(BufferError):
+                np.frombuffer(buffer)
+
 
 class TestArrayCreationCopyArgument(object):
 
@@ -7832,9 +8203,9 @@ def test_scalars(self):
             pyscalar = arr.item(0)
 
             # Test never-copy raises error:
-            assert_raises(ValueError, np.array, scalar, 
+            assert_raises(ValueError, np.array, scalar,
                             copy=np._CopyMode.NEVER)
-            assert_raises(ValueError, np.array, pyscalar, 
+            assert_raises(ValueError, np.array, pyscalar,
                             copy=np._CopyMode.NEVER)
             assert_raises(ValueError, np.array, pyscalar,
                             copy=self.RaiseOnBool())
@@ -8187,18 +8558,6 @@ def test_scalar_element_deletion():
     assert_raises(ValueError, a[0].__delitem__, 'x')
 
 
-class TestMemEventHook:
-    def test_mem_seteventhook(self):
-        # The actual tests are within the C code in
-        # multiarray/_multiarray_tests.c.src
-        _multiarray_tests.test_pydatamem_seteventhook_start()
-        # force an allocation and free of a numpy array
-        # needs to be larger then limit of small memory cacher in ctors.c
-        a = np.zeros(1000)
-        del a
-        break_cycles()
-        _multiarray_tests.test_pydatamem_seteventhook_end()
-
 class TestMapIter:
     def test_mapiter(self):
         # The actual tests are within the C code in
@@ -8297,10 +8656,9 @@ def __bool__(self):
 
         self_containing = np.array([None])
         self_containing[0] = self_containing
-        try:
-            Error = RecursionError
-        except NameError:
-            Error = RuntimeError  # python < 3.5
+
+        Error = RecursionError
+
         assert_raises(Error, bool, self_containing)  # previously stack overflow
         self_containing[0] = None  # resolve circular reference
 
@@ -8316,13 +8674,18 @@ def test_to_int_scalar(self):
             # gh-9972
             assert_equal(4, int_func(np.array('4')))
             assert_equal(5, int_func(np.bytes_(b'5')))
-            assert_equal(6, int_func(np.unicode_(u'6')))
-
-            class HasTrunc:
-                def __trunc__(self):
-                    return 3
-            assert_equal(3, int_func(np.array(HasTrunc())))
-            assert_equal(3, int_func(np.array([HasTrunc()])))
+            assert_equal(6, int_func(np.unicode_('6')))
+
+            # The delegation of int() to __trunc__ was deprecated in
+            # Python 3.11.
+            if sys.version_info < (3, 11):
+                class HasTrunc:
+                    def __trunc__(self):
+                        return 3
+                assert_equal(3, int_func(np.array(HasTrunc())))
+                assert_equal(3, int_func(np.array([HasTrunc()])))
+            else:
+                pass
 
             class NotConvertible:
                 def __int__(self):
@@ -8969,6 +9332,61 @@ def test_start_stop_kwarg(self):
         assert len(keyword_start_stop) == 6
         assert_array_equal(keyword_stop, keyword_zerotostop)
 
+    def test_arange_booleans(self):
+        # Arange makes some sense for booleans and works up to length 2.
+        # But it is weird since `arange(2, 4, dtype=bool)` works.
+        # Arguably, much or all of this could be deprecated/removed.
+        res = np.arange(False, dtype=bool)
+        assert_array_equal(res, np.array([], dtype="bool"))
+
+        res = np.arange(True, dtype="bool")
+        assert_array_equal(res, [False])
+
+        res = np.arange(2, dtype="bool")
+        assert_array_equal(res, [False, True])
+
+        # This case is especially weird, but drops out without special case:
+        res = np.arange(6, 8, dtype="bool")
+        assert_array_equal(res, [True, True])
+
+        with pytest.raises(TypeError):
+            np.arange(3, dtype="bool")
+
+    @pytest.mark.parametrize("dtype", ["S3", "U", "5i"])
+    def test_rejects_bad_dtypes(self, dtype):
+        dtype = np.dtype(dtype)
+        DType_name = re.escape(str(type(dtype)))
+        with pytest.raises(TypeError,
+                match=rf"arange\(\) not supported for inputs .* {DType_name}"):
+            np.arange(2, dtype=dtype)
+
+    def test_rejects_strings(self):
+        # Explicitly test error for strings which may call "b" - "a":
+        DType_name = re.escape(str(type(np.array("a").dtype)))
+        with pytest.raises(TypeError,
+                match=rf"arange\(\) not supported for inputs .* {DType_name}"):
+            np.arange("a", "b")
+
+    def test_byteswapped(self):
+        res_be = np.arange(1, 1000, dtype=">i4")
+        res_le = np.arange(1, 1000, dtype="i4"
+        assert res_le.dtype == "i,O")
@@ -3130,7 +3170,6 @@ def test_warn_noclose():
 
 @pytest.mark.skipif(sys.version_info[:2] == (3, 9) and sys.platform == "win32",
                     reason="Errors with Python 3.9 on Windows")
-@pytest.mark.skipif(not HAS_REFCOUNT, reason="Python lacks refcounts")
 @pytest.mark.parametrize(["in_dtype", "buf_dtype"],
         [("i", "O"), ("O", "i"),  # most simple cases
          ("i,O", "O,O"),  # structured partially only copying O
@@ -3138,9 +3177,14 @@ def test_warn_noclose():
          ])
 @pytest.mark.parametrize("steps", [1, 2, 3])
 def test_partial_iteration_cleanup(in_dtype, buf_dtype, steps):
-    value = 123  # relies on python cache (leak-check will still find it)
+    """
+    Checks for reference counting leaks during cleanup.  Using explicit
+    reference counts lead to occasional false positives (at least in parallel
+    test setups).  This test now should still test leaks correctly when
+    run e.g. with pytest-valgrind or pytest-leaks
+    """
+    value = 2**30 + 1  # just a random value that Python won't intern
     arr = np.full(int(np.BUFSIZE * 2.5), value).astype(in_dtype)
-    count = sys.getrefcount(value)
 
     it = np.nditer(arr, op_dtypes=[np.dtype(buf_dtype)],
             flags=["buffered", "external_loop", "refs_ok"], casting="unsafe")
@@ -3148,11 +3192,7 @@ def test_partial_iteration_cleanup(in_dtype, buf_dtype, steps):
         # The iteration finishes in 3 steps, the first two are partial
         next(it)
 
-    # Note that resetting does not free references
-    del it
-    break_cycles()
-    break_cycles()
-    assert count == sys.getrefcount(value)
+    del it  # not necessary, but we test the cleanup
 
     # Repeat the test with `iternext`
     it = np.nditer(arr, op_dtypes=[np.dtype(buf_dtype)],
@@ -3160,11 +3200,7 @@ def test_partial_iteration_cleanup(in_dtype, buf_dtype, steps):
     for step in range(steps):
         it.iternext()
 
-    del it  # should ensure cleanup
-    break_cycles()
-    break_cycles()
-    assert count == sys.getrefcount(value)
-
+    del it  # not necessary, but we test the cleanup
 
 @pytest.mark.skipif(not HAS_REFCOUNT, reason="Python lacks refcounts")
 @pytest.mark.parametrize(["in_dtype", "buf_dtype"],
diff --git a/numpy/core/tests/test_nep50_promotions.py b/numpy/core/tests/test_nep50_promotions.py
new file mode 100644
index 000000000000..3c0316960203
--- /dev/null
+++ b/numpy/core/tests/test_nep50_promotions.py
@@ -0,0 +1,182 @@
+"""
+This file adds basic tests to test the NEP 50 style promotion compatibility
+mode.  Most of these test are likely to be simply deleted again once NEP 50
+is adopted in the main test suite.  A few may be moved elsewhere.
+"""
+
+import operator
+
+import numpy as np
+
+import pytest
+from numpy.testing import IS_WASM
+
+
+@pytest.fixture(scope="module", autouse=True)
+def _weak_promotion_enabled():
+    state = np._get_promotion_state()
+    np._set_promotion_state("weak_and_warn")
+    yield
+    np._set_promotion_state(state)
+
+
+@pytest.mark.skipif(IS_WASM, reason="wasm doesn't have support for fp errors")
+def test_nep50_examples():
+    with pytest.warns(UserWarning, match="result dtype changed"):
+        res = np.uint8(1) + 2
+    assert res.dtype == np.uint8
+
+    with pytest.warns(UserWarning, match="result dtype changed"):
+        res = np.array([1], np.uint8) + np.int64(1)
+    assert res.dtype == np.int64
+
+    with pytest.warns(UserWarning, match="result dtype changed"):
+        res = np.array([1], np.uint8) + np.array(1, dtype=np.int64)
+    assert res.dtype == np.int64
+
+    with pytest.warns(UserWarning, match="result dtype changed"):
+        # Note: For "weak_and_warn" promotion state the overflow warning is
+        #       unfortunately not given (because we use the full array path).
+        with np.errstate(over="raise"):
+            res = np.uint8(100) + 200
+    assert res.dtype == np.uint8
+
+    with pytest.warns(Warning) as recwarn:
+        res = np.float32(1) + 3e100
+
+    # Check that both warnings were given in the one call:
+    warning = str(recwarn.pop(UserWarning).message)
+    assert warning.startswith("result dtype changed")
+    warning = str(recwarn.pop(RuntimeWarning).message)
+    assert warning.startswith("overflow")
+    assert len(recwarn) == 0  # no further warnings
+    assert np.isinf(res)
+    assert res.dtype == np.float32
+
+    # Changes, but we don't warn for it (too noisy)
+    res = np.array([0.1], np.float32) == np.float64(0.1)
+    assert res[0] == False
+
+    # Additional test, since the above silences the warning:
+    with pytest.warns(UserWarning, match="result dtype changed"):
+        res = np.array([0.1], np.float32) + np.float64(0.1)
+    assert res.dtype == np.float64
+
+    with pytest.warns(UserWarning, match="result dtype changed"):
+        res = np.array([1.], np.float32) + np.int64(3)
+    assert res.dtype == np.float64
+
+
+@pytest.mark.parametrize("dtype", np.typecodes["AllInteger"])
+def test_nep50_weak_integers(dtype):
+    # Avoids warning (different code path for scalars)
+    np._set_promotion_state("weak")
+    scalar_type = np.dtype(dtype).type
+
+    maxint = int(np.iinfo(dtype).max)
+
+    with np.errstate(over="warn"):
+        with pytest.warns(RuntimeWarning):
+            res = scalar_type(100) + maxint
+    assert res.dtype == dtype
+
+    # Array operations are not expected to warn, but should give the same
+    # result dtype.
+    res = np.array(100, dtype=dtype) + maxint
+    assert res.dtype == dtype
+
+
+@pytest.mark.parametrize("dtype", np.typecodes["AllFloat"])
+def test_nep50_weak_integers_with_inexact(dtype):
+    # Avoids warning (different code path for scalars)
+    np._set_promotion_state("weak")
+    scalar_type = np.dtype(dtype).type
+
+    too_big_int = int(np.finfo(dtype).max) * 2
+
+    if dtype in "dDG":
+        # These dtypes currently convert to Python float internally, which
+        # raises an OverflowError, while the other dtypes overflow to inf.
+        # NOTE: It may make sense to normalize the behavior!
+        with pytest.raises(OverflowError):
+            scalar_type(1) + too_big_int
+
+        with pytest.raises(OverflowError):
+            np.array(1, dtype=dtype) + too_big_int
+    else:
+        # NumPy uses (or used) `int -> string -> longdouble` for the
+        # conversion.  But Python may refuse `str(int)` for huge ints.
+        # In that case, RuntimeWarning would be correct, but conversion
+        # fails earlier (seems to happen on 32bit linux, possibly only debug).
+        if dtype in "gG":
+            try:
+                str(too_big_int)
+            except ValueError:
+                pytest.skip("`huge_int -> string -> longdouble` failed")
+
+        # Otherwise, we overflow to infinity:
+        with pytest.warns(RuntimeWarning):
+            res = scalar_type(1) + too_big_int
+        assert res.dtype == dtype
+        assert res == np.inf
+
+        with pytest.warns(RuntimeWarning):
+            # We force the dtype here, since windows may otherwise pick the
+            # double instead of the longdouble loop.  That leads to slightly
+            # different results (conversion of the int fails as above).
+            res = np.add(np.array(1, dtype=dtype), too_big_int, dtype=dtype)
+        assert res.dtype == dtype
+        assert res == np.inf
+
+
+@pytest.mark.parametrize("op", [operator.add, operator.pow, operator.eq])
+def test_weak_promotion_scalar_path(op):
+    # Some additional paths excercising the weak scalars.
+    np._set_promotion_state("weak")
+
+    # Integer path:
+    res = op(np.uint8(3), 5)
+    assert res == op(3, 5)
+    assert res.dtype == np.uint8 or res.dtype == bool
+
+    with pytest.raises(OverflowError):
+        op(np.uint8(3), 1000)
+
+    # Float path:
+    res = op(np.float32(3), 5.)
+    assert res == op(3., 5.)
+    assert res.dtype == np.float32 or res.dtype == bool
+
+
+def test_nep50_complex_promotion():
+    np._set_promotion_state("weak")
+
+    with pytest.warns(RuntimeWarning, match=".*overflow"):
+        res = np.complex64(3) + complex(2**300)
+
+    assert type(res) == np.complex64
+
+
+def test_nep50_integer_conversion_errors():
+    # Do not worry about warnings here (auto-fixture will reset).
+    np._set_promotion_state("weak")
+    # Implementation for error paths is mostly missing (as of writing)
+    with pytest.raises(OverflowError, match=".*uint8"):
+        np.array([1], np.uint8) + 300
+
+    with pytest.raises(OverflowError, match=".*uint8"):
+        np.uint8(1) + 300
+
+    # Error message depends on platform (maybe unsigned int or unsigned long)
+    with pytest.raises(OverflowError,
+            match="Python integer -1 out of bounds for uint8"):
+        np.uint8(1) + -1
+
+
+def test_nep50_integer_regression():
+    # Test the old integer promotion rules.  When the integer is too large,
+    # we need to keep using the old-style promotion.
+    np._set_promotion_state("legacy")
+    arr = np.array(1)
+    assert (arr + 2**63).dtype == np.float64
+    assert (arr[()] + 2**63).dtype == np.float64
diff --git a/numpy/core/tests/test_numeric.py b/numpy/core/tests/test_numeric.py
index ad94379115a8..3cc168b3429c 100644
--- a/numpy/core/tests/test_numeric.py
+++ b/numpy/core/tests/test_numeric.py
@@ -12,7 +12,7 @@
 from numpy.testing import (
     assert_, assert_equal, assert_raises, assert_raises_regex,
     assert_array_equal, assert_almost_equal, assert_array_almost_equal,
-    assert_warns, assert_array_max_ulp, HAS_REFCOUNT
+    assert_warns, assert_array_max_ulp, HAS_REFCOUNT, IS_WASM
     )
 from numpy.core._rational_tests import rational
 
@@ -347,7 +347,7 @@ def test_bitwise_xor(self):
 
 
 class TestBoolArray:
-    def setup(self):
+    def setup_method(self):
         # offset for simd tests
         self.t = np.array([True] * 41, dtype=bool)[1::]
         self.f = np.array([False] * 41, dtype=bool)[1::]
@@ -434,7 +434,7 @@ def test_logical_and_or_xor(self):
 
 
 class TestBoolCmp:
-    def setup(self):
+    def setup_method(self):
         self.f = np.ones(256, dtype=np.float32)
         self.ef = np.ones(self.f.size, dtype=bool)
         self.d = np.ones(128, dtype=np.float64)
@@ -556,6 +556,7 @@ def test_set(self):
             np.seterr(**old)
             assert_(np.geterr() == old)
 
+    @pytest.mark.skipif(IS_WASM, reason="no wasm fp exception support")
     @pytest.mark.skipif(platform.machine() == "armv5tel", reason="See gh-413.")
     def test_divide_err(self):
         with np.errstate(divide='raise'):
@@ -565,6 +566,7 @@ def test_divide_err(self):
             np.seterr(divide='ignore')
             np.array([1.]) / np.array([0.])
 
+    @pytest.mark.skipif(IS_WASM, reason="no wasm fp exception support")
     def test_errobj(self):
         olderrobj = np.geterrobj()
         self.called = 0
@@ -638,6 +640,7 @@ def assert_op_raises_fpe(self, fpeerr, flop, sc1, sc2):
         self.assert_raises_fpe(fpeerr, flop, sc1[()], sc2[()])
 
     # Test for all real and complex float types
+    @pytest.mark.skipif(IS_WASM, reason="no wasm fp exception support")
     @pytest.mark.parametrize("typecode", np.typecodes["AllFloat"])
     def test_floating_exceptions(self, typecode):
         # Test basic arithmetic function errors
@@ -697,6 +700,7 @@ def test_floating_exceptions(self, typecode):
             self.assert_raises_fpe(invalid,
                                    lambda a, b: a*b, ftype(0), ftype(np.inf))
 
+    @pytest.mark.skipif(IS_WASM, reason="no wasm fp exception support")
     def test_warnings(self):
         # test warning code path
         with warnings.catch_warnings(record=True) as w:
@@ -932,9 +936,28 @@ def test_promote_types_strings(self, swap, string_dtype):
         # Promote with object:
         assert_equal(promote_types('O', S+'30'), np.dtype('O'))
 
+    @pytest.mark.parametrize(["dtype1", "dtype2"],
+            [[np.dtype("V6"), np.dtype("V10")],  # mismatch shape
+             # Mismatching names:
+             [np.dtype([("name1", "i8")]), np.dtype([("name2", "i8")])],
+            ])
+    def test_invalid_void_promotion(self, dtype1, dtype2):
+        with pytest.raises(TypeError):
+            np.promote_types(dtype1, dtype2)
+
+    @pytest.mark.parametrize(["dtype1", "dtype2"],
+            [[np.dtype("V10"), np.dtype("V10")],
+             [np.dtype([("name1", "i8")]),
+              np.dtype([("name1", np.dtype("i8").newbyteorder())])],
+             [np.dtype("i8,i8"), np.dtype("i8,>i8")],
+             [np.dtype("i8,i8"), np.dtype("i4,i4")],
+            ])
+    def test_valid_void_promotion(self, dtype1, dtype2):
+        assert np.promote_types(dtype1, dtype2) == dtype1
+
     @pytest.mark.parametrize("dtype",
-           list(np.typecodes["All"]) +
-           ["i,i", "S3", "S100", "U3", "U100", rational])
+            list(np.typecodes["All"]) +
+            ["i,i", "10i", "S3", "S100", "U3", "U100", rational])
     def test_promote_identical_types_metadata(self, dtype):
         # The same type passed in twice to promote types always
         # preserves metadata
@@ -951,14 +974,14 @@ def test_promote_identical_types_metadata(self, dtype):
             return
 
         res = np.promote_types(dtype, dtype)
-        if res.char in "?bhilqpBHILQPefdgFDGOmM" or dtype.type is rational:
-            # Metadata is lost for simple promotions (they create a new dtype)
+
+        # Metadata is (currently) generally lost on byte-swapping (except for
+        # unicode.
+        if dtype.char != "U":
             assert res.metadata is None
         else:
             assert res.metadata == metadata
-        if dtype.kind != "V":
-            # the result is native (except for structured void)
-            assert res.isnative
+        assert res.isnative
 
     @pytest.mark.slow
     @pytest.mark.filterwarnings('ignore:Promotion of numbers:FutureWarning')
@@ -987,8 +1010,10 @@ def test_promote_types_metadata(self, dtype1, dtype2):
             # Promotion failed, this test only checks metadata
             return
 
-        if res.char in "?bhilqpBHILQPefdgFDGOmM" or res.type is rational:
-            # All simple types lose metadata (due to using promotion table):
+        if res.char not in "USV" or res.names is not None or res.shape != ():
+            # All except string dtypes (and unstructured void) lose metadata
+            # on promotion (unless both dtypes are identical).
+            # At some point structured ones did not, but were restrictive.
             assert res.metadata is None
         elif res == dtype1:
             # If one result is the result, it is usually returned unchanged:
@@ -1008,32 +1033,9 @@ def test_promote_types_metadata(self, dtype1, dtype2):
         dtype1 = dtype1.newbyteorder()
         assert dtype1.metadata == metadata1
         res_bs = np.promote_types(dtype1, dtype2)
-        if res_bs.names is not None:
-            # Structured promotion doesn't remove byteswap:
-            assert res_bs.newbyteorder() == res
-        else:
-            assert res_bs == res
+        assert res_bs == res
         assert res_bs.metadata == res.metadata
 
-    @pytest.mark.parametrize(["dtype1", "dtype2"],
-            [[np.dtype("V6"), np.dtype("V10")],
-             [np.dtype([("name1", "i8")]), np.dtype([("name2", "i8")])],
-             [np.dtype("i8,i8"), np.dtype("i4,i4")],
-            ])
-    def test_invalid_void_promotion(self, dtype1, dtype2):
-        # Mainly test structured void promotion, which currently allows
-        # byte-swapping, but nothing else:
-        with pytest.raises(TypeError):
-            np.promote_types(dtype1, dtype2)
-
-    @pytest.mark.parametrize(["dtype1", "dtype2"],
-            [[np.dtype("V10"), np.dtype("V10")],
-             [np.dtype([("name1", "i8")])],
-             [np.dtype("i8,i8"), np.dtype("i8,>i8")],
-            ])
-    def test_valid_void_promotion(self, dtype1, dtype2):
-        assert np.promote_types(dtype1, dtype2) is dtype1
-
     def test_can_cast(self):
         assert_(np.can_cast(np.int32, np.int64))
         assert_(np.can_cast(np.float64, complex))
@@ -1202,19 +1204,76 @@ def load_data(self, n, eindex):
                 raise NIterError('error at index %s' % eindex)
             yield e
 
-    def test_2592(self):
-        # Test iteration exceptions are correctly raised.
-        count, eindex = 10, 5
-        assert_raises(NIterError, np.fromiter,
-                          self.load_data(count, eindex), dtype=int, count=count)
-
-    def test_2592_edge(self):
-        # Test iter. exceptions, edge case (exception at end of iterator).
-        count = 10
-        eindex = count-1
-        assert_raises(NIterError, np.fromiter,
-                          self.load_data(count, eindex), dtype=int, count=count)
+    @pytest.mark.parametrize("dtype", [int, object])
+    @pytest.mark.parametrize(["count", "error_index"], [(10, 5), (10, 9)])
+    def test_2592(self, count, error_index, dtype):
+        # Test iteration exceptions are correctly raised. The data/generator
+        # has `count` elements but errors at `error_index`
+        iterable = self.load_data(count, error_index)
+        with pytest.raises(NIterError):
+            np.fromiter(iterable, dtype=dtype, count=count)
+
+    @pytest.mark.parametrize("dtype", ["S", "S0", "V0", "U0"])
+    def test_empty_not_structured(self, dtype):
+        # Note, "S0" could be allowed at some point, so long "S" (without
+        # any length) is rejected.
+        with pytest.raises(ValueError, match="Must specify length"):
+            np.fromiter([], dtype=dtype)
+
+    @pytest.mark.parametrize(["dtype", "data"],
+            [("d", [1, 2, 3, 4, 5, 6, 7, 8, 9]),
+             ("O", [1, 2, 3, 4, 5, 6, 7, 8, 9]),
+             ("i,O", [(1, 2), (5, 4), (2, 3), (9, 8), (6, 7)]),
+             # subarray dtypes (important because their dimensions end up
+             # in the result arrays dimension:
+             ("2i", [(1, 2), (5, 4), (2, 3), (9, 8), (6, 7)]),
+             (np.dtype(("O", (2, 3))),
+              [((1, 2, 3), (3, 4, 5)), ((3, 2, 1), (5, 4, 3))])])
+    @pytest.mark.parametrize("length_hint", [0, 1])
+    def test_growth_and_complicated_dtypes(self, dtype, data, length_hint):
+        dtype = np.dtype(dtype)
+
+        data = data * 100  # make sure we realloc a bit
+
+        class MyIter:
+            # Class/example from gh-15789
+            def __length_hint__(self):
+                # only required to be an estimate, this is legal
+                return length_hint  # 0 or 1
+
+            def __iter__(self):
+                return iter(data)
+
+        res = np.fromiter(MyIter(), dtype=dtype)
+        expected = np.array(data, dtype=dtype)
+
+        assert_array_equal(res, expected)
+
+    def test_empty_result(self):
+        class MyIter:
+            def __length_hint__(self):
+                return 10
+
+            def __iter__(self):
+                return iter([])  # actual iterator is empty.
+
+        res = np.fromiter(MyIter(), dtype="d")
+        assert res.shape == (0,)
+        assert res.dtype == "d"
+
+    def test_too_few_items(self):
+        msg = "iterator too short: Expected 10 but iterator had only 3 items."
+        with pytest.raises(ValueError, match=msg):
+            np.fromiter([1, 2, 3], count=10, dtype=int)
+
+    def test_failed_itemsetting(self):
+        with pytest.raises(TypeError):
+            np.fromiter([1, None, 3], dtype=int)
 
+        # The following manages to hit somewhat trickier code paths:
+        iterable = ((2, 3, 4) for i in range(5))
+        with pytest.raises(ValueError):
+            np.fromiter(iterable, dtype=np.dtype((int, 2)))
 
 class TestNonzero:
     def test_nonzero_trivial(self):
@@ -1529,6 +1588,7 @@ def __bool__(self):
         a = np.array([[ThrowsAfter(15)]]*10)
         assert_raises(ValueError, np.nonzero, a)
 
+    @pytest.mark.skipif(IS_WASM, reason="wasm doesn't have threads")
     def test_structured_threadsafety(self):
         # Nonzero (and some other functions) should be threadsafe for
         # structured datatypes, see gh-15387. This test can behave randomly.
@@ -1758,7 +1818,7 @@ def assert_array_strict_equal(x, y):
 
 
 class TestClip:
-    def setup(self):
+    def setup_method(self):
         self.nr = 5
         self.nc = 3
 
@@ -2387,10 +2447,10 @@ class TestAllclose:
     rtol = 1e-5
     atol = 1e-8
 
-    def setup(self):
+    def setup_method(self):
         self.olderr = np.seterr(invalid='ignore')
 
-    def teardown(self):
+    def teardown_method(self):
         np.seterr(**self.olderr)
 
     def tst_allclose(self, x, y):
@@ -2472,7 +2532,7 @@ class TestIsclose:
     rtol = 1e-5
     atol = 1e-8
 
-    def setup(self):
+    def _setup(self):
         atol = self.atol
         rtol = self.rtol
         arr = np.array([100, 1000])
@@ -2518,7 +2578,7 @@ def setup(self):
                 ]
 
     def test_ip_isclose(self):
-        self.setup()
+        self._setup()
         tests = self.some_close_tests
         results = self.some_close_results
         for (x, y), result in zip(tests, results):
@@ -2540,17 +2600,17 @@ def tst_isclose_allclose(self, x, y):
             assert_array_equal(np.isclose(x, y).all(), np.allclose(x, y), msg % (x, y))
 
     def test_ip_all_isclose(self):
-        self.setup()
+        self._setup()
         for (x, y) in self.all_close_tests:
             self.tst_all_isclose(x, y)
 
     def test_ip_none_isclose(self):
-        self.setup()
+        self._setup()
         for (x, y) in self.none_close_tests:
             self.tst_none_isclose(x, y)
 
     def test_ip_isclose_allclose(self):
-        self.setup()
+        self._setup()
         tests = (self.all_close_tests + self.none_close_tests +
                  self.some_close_tests)
         for (x, y) in tests:
@@ -2616,7 +2676,7 @@ def test_timedelta(self):
 
 
 class TestStdVar:
-    def setup(self):
+    def setup_method(self):
         self.A = np.array([1, -1, 1, -1])
         self.real_var = 1
 
@@ -2669,7 +2729,7 @@ def test_scalars(self):
 class TestCreationFuncs:
     # Test ones, zeros, empty and full.
 
-    def setup(self):
+    def setup_method(self):
         dtypes = {np.dtype(tp) for tp in itertools.chain(*np.sctypes.values())}
         # void, bytes, str
         variable_sized = {tp for tp in dtypes if tp.str.endswith('0')}
@@ -2740,7 +2800,7 @@ def test_for_reference_leak(self):
 class TestLikeFuncs:
     '''Test ones_like, zeros_like, empty_like and full_like'''
 
-    def setup(self):
+    def setup_method(self):
         self.data = [
                 # Array scalars
                 (np.array(3.), None),
@@ -2769,12 +2829,11 @@ def setup(self):
     def compare_array_value(self, dz, value, fill_value):
         if value is not None:
             if fill_value:
-                try:
-                    z = dz.dtype.type(value)
-                except OverflowError:
-                    pass
-                else:
-                    assert_(np.all(dz == z))
+                # Conversion is close to what np.full_like uses
+                # but we  may want to convert directly in the future
+                # which may result in errors (where this does not).
+                z = np.array(value).astype(dz.dtype)
+                assert_(np.all(dz == z))
             else:
                 assert_(np.all(dz == value))
 
@@ -2884,7 +2943,9 @@ def test_filled_like(self):
         self.check_like_function(np.full_like, 1, True)
         self.check_like_function(np.full_like, 1000, True)
         self.check_like_function(np.full_like, 123.456, True)
-        self.check_like_function(np.full_like, np.inf, True)
+        # Inf to integer casts cause invalid-value errors: ignore them.
+        with np.errstate(invalid="ignore"):
+            self.check_like_function(np.full_like, np.inf, True)
 
     @pytest.mark.parametrize('likefunc', [np.empty_like, np.full_like,
                                           np.zeros_like, np.ones_like])
@@ -3326,6 +3387,14 @@ def test_broadcasting_shapes(self):
         for axisc in range(-2, 2):
             assert_equal(np.cross(u, u, axisc=axisc).shape, (3, 4))
 
+    def test_uint8_int32_mixed_dtypes(self):
+        # regression test for gh-19138
+        u = np.array([[195, 8, 9]], np.uint8)
+        v = np.array([250, 166, 68], np.int32)
+        z = np.array([[950, 11010, -30370]], dtype=np.int32)
+        assert_equal(np.cross(v, u), z)
+        assert_equal(np.cross(u, v), -z)
+
 
 def test_outer_out_param():
     arr1 = np.ones((5,))
diff --git a/numpy/core/tests/test_numerictypes.py b/numpy/core/tests/test_numerictypes.py
index 9cb00342dd0c..072cd65feafc 100644
--- a/numpy/core/tests/test_numerictypes.py
+++ b/numpy/core/tests/test_numerictypes.py
@@ -60,8 +60,10 @@
     # x     Info                                                color info        y                  z
     #       value y2 Info2                            name z2         Name Value
     #                name   value    y3       z3
-    ([3, 2], (6j, 6., (b'nn', [6j, 4j], [6., 4.], [1, 2]), b'NN', True), b'cc', (u'NN', 6j), [[6., 4.], [6., 4.]], 8),
-    ([4, 3], (7j, 7., (b'oo', [7j, 5j], [7., 5.], [2, 1]), b'OO', False), b'dd', (u'OO', 7j), [[7., 5.], [7., 5.]], 9),
+    ([3, 2], (6j, 6., (b'nn', [6j, 4j], [6., 4.], [1, 2]), b'NN', True),
+     b'cc', ('NN', 6j), [[6., 4.], [6., 4.]], 8),
+    ([4, 3], (7j, 7., (b'oo', [7j, 5j], [7., 5.], [2, 1]), b'OO', False),
+     b'dd', ('OO', 7j), [[7., 5.], [7., 5.]], 9),
     ]
 
 
@@ -357,7 +359,7 @@ def test_scalar_wins3(self):  # doesn't go up to 'f16' on purpose
         assert_(res == 'f8')
 
 class TestMultipleFields:
-    def setup(self):
+    def setup_method(self):
         self.ary = np.array([(1, 2, 3, 4), (5, 6, 7, 8)], dtype='i4,f4,i2,c8')
 
     def _bad_call(self):
@@ -436,6 +438,14 @@ def test_longdouble(self):
         assert_(np.sctypeDict['f8'] is not np.longdouble)
         assert_(np.sctypeDict['c16'] is not np.clongdouble)
 
+    def test_ulong(self):
+        # Test that 'ulong' behaves like 'long'. np.sctypeDict['long'] is an
+        # alias for np.int_, but np.long is not supported for historical
+        # reasons (gh-21063)
+        assert_(np.sctypeDict['ulong'] is np.uint)
+        with pytest.warns(FutureWarning):
+            # We will probably allow this in the future:
+            assert not hasattr(np, 'ulong')
 
 class TestBitName:
     def test_abstract(self):
diff --git a/numpy/core/tests/test_overrides.py b/numpy/core/tests/test_overrides.py
index 9216a3f5fdfa..63432ffa70db 100644
--- a/numpy/core/tests/test_overrides.py
+++ b/numpy/core/tests/test_overrides.py
@@ -355,6 +355,45 @@ def func(array):
                 TypeError, "no implementation found for 'my.func'"):
             func(MyArray())
 
+    def test_signature_error_message(self):
+        # The lambda function will be named "", but the TypeError
+        # should show the name as "func"
+        def _dispatcher():
+            return ()
+
+        @array_function_dispatch(_dispatcher)
+        def func():
+            pass
+
+        try:
+            func(bad_arg=3)
+        except TypeError as e:
+            expected_exception = e
+
+        try:
+            func(bad_arg=3)
+            raise AssertionError("must fail")
+        except TypeError as exc:
+            assert exc.args == expected_exception.args
+
+    @pytest.mark.parametrize("value", [234, "this func is not replaced"])
+    def test_dispatcher_error(self, value):
+        # If the dispatcher raises an error, we must not attempt to mutate it
+        error = TypeError(value)
+
+        def dispatcher():
+            raise error
+
+        @array_function_dispatch(dispatcher)
+        def func():
+            return 3
+
+        try:
+            func()
+            raise AssertionError("must fail")
+        except TypeError as exc:
+            assert exc is error  # unmodified exception
+
 
 class TestNDArrayMethods:
 
@@ -431,12 +470,13 @@ def __array_function__(self, func, types, args, kwargs):
 
 
 class TestArrayLike:
-    def setup(self):
+    def setup_method(self):
         class MyArray():
             def __init__(self, function=None):
                 self.function = function
 
             def __array_function__(self, func, types, args, kwargs):
+                assert func is getattr(np, func.__name__)
                 try:
                     my_func = getattr(self, func.__name__)
                 except AttributeError:
@@ -491,7 +531,7 @@ def test_array_like_not_implemented(self):
         ('fromiter', *func_args(range(3), dtype=int)),
         ('fromstring', *func_args('1,2', dtype=int, sep=',')),
         ('loadtxt', *func_args(lambda: StringIO('0 1\n2 3'))),
-        ('genfromtxt', *func_args(lambda: StringIO(u'1,2.1'),
+        ('genfromtxt', *func_args(lambda: StringIO('1,2.1'),
                                   dtype=[('int', 'i8'), ('float', 'f8')],
                                   delimiter=',')),
     ]
@@ -582,3 +622,21 @@ def test_exception_handling(self):
         with assert_raises(TypeError):
             # Raises the error about `value_error` being invalid first
             np.array(1, value_error=True, like=ref)
+
+    @pytest.mark.parametrize('function, args, kwargs', _array_tests)
+    def test_like_as_none(self, function, args, kwargs):
+        self.add_method('array', self.MyArray)
+        self.add_method(function, self.MyArray)
+        np_func = getattr(np, function)
+
+        like_args = tuple(a() if callable(a) else a for a in args)
+        # required for loadtxt and genfromtxt to init w/o error.
+        like_args_exp = tuple(a() if callable(a) else a for a in args)
+
+        array_like = np_func(*like_args, **kwargs, like=None)
+        expected = np_func(*like_args_exp, **kwargs)
+        # Special-case np.empty to ensure values match
+        if function == "empty":
+            array_like.fill(1)
+            expected.fill(1)
+        assert_equal(array_like, expected)
diff --git a/numpy/core/tests/test_records.py b/numpy/core/tests/test_records.py
index 4d4b4b5158de..a76ae2d99978 100644
--- a/numpy/core/tests/test_records.py
+++ b/numpy/core/tests/test_records.py
@@ -337,7 +337,7 @@ def test_tofile_fromfile(self):
 
 
 class TestRecord:
-    def setup(self):
+    def setup_method(self):
         self.data = np.rec.fromrecords([(1, 2, 3), (4, 5, 6)],
                             dtype=[("col1", " None:
         assert isinstance(alias, types.GenericAlias)
         assert alias.__origin__ is np.complexfloating
 
+    @pytest.mark.parametrize("arg_len", range(4))
+    def test_abc_complexfloating_subscript_tuple(self, arg_len: int) -> None:
+        arg_tup = (Any,) * arg_len
+        if arg_len in (1, 2):
+            assert np.complexfloating[arg_tup]
+        else:
+            match = f"Too {'few' if arg_len == 0 else 'many'} arguments"
+            with pytest.raises(TypeError, match=match):
+                np.complexfloating[arg_tup]
+
     @pytest.mark.parametrize("cls", [np.generic, np.flexible, np.character])
     def test_abc_non_numeric(self, cls: Type[np.generic]) -> None:
         with pytest.raises(TypeError):
diff --git a/numpy/core/tests/test_scalarbuffer.py b/numpy/core/tests/test_scalarbuffer.py
index 851cd3081aee..0e6ab1015e15 100644
--- a/numpy/core/tests/test_scalarbuffer.py
+++ b/numpy/core/tests/test_scalarbuffer.py
@@ -59,7 +59,6 @@ def test_scalar_code_and_properties(self, scalar, code):
                         shape=(), format=code, readonly=True)
 
         mv_x = memoryview(x)
-        print(mv_x.readonly, self._as_dict(mv_x))
         assert self._as_dict(mv_x) == expected
 
     @pytest.mark.parametrize('scalar', scalars_only, ids=codes_only)
@@ -151,4 +150,4 @@ def test_user_scalar_fails_buffer(self):
 
         # Check that we do not allow writeable buffer export
         with pytest.raises(BufferError, match="scalar buffer is readonly"):
-            get_buffer_info(r, ["WRITABLE"])
\ No newline at end of file
+            get_buffer_info(r, ["WRITABLE"])
diff --git a/numpy/core/tests/test_scalarinherit.py b/numpy/core/tests/test_scalarinherit.py
index 98d7f7cdef7f..f697c3c817d2 100644
--- a/numpy/core/tests/test_scalarinherit.py
+++ b/numpy/core/tests/test_scalarinherit.py
@@ -61,7 +61,7 @@ def test_char_radd(self):
         np_s = np.string_('abc')
         np_u = np.unicode_('abc')
         s = b'def'
-        u = u'def'
+        u = 'def'
         assert_(np_s.__radd__(np_s) is NotImplemented)
         assert_(np_s.__radd__(np_u) is NotImplemented)
         assert_(np_s.__radd__(s) is NotImplemented)
@@ -71,7 +71,7 @@ def test_char_radd(self):
         assert_(np_u.__radd__(s) is NotImplemented)
         assert_(np_u.__radd__(u) is NotImplemented)
         assert_(s + np_s == b'defabc')
-        assert_(u + np_u == u'defabc')
+        assert_(u + np_u == 'defabc')
 
         class MyStr(str, np.generic):
             # would segfault
@@ -93,6 +93,6 @@ def test_char_repeat(self):
         np_s = np.string_('abc')
         np_u = np.unicode_('abc')
         res_s = b'abc' * 5
-        res_u = u'abc' * 5
+        res_u = 'abc' * 5
         assert_(np_s * 5 == res_s)
         assert_(np_u * 5 == res_u)
diff --git a/numpy/core/tests/test_scalarmath.py b/numpy/core/tests/test_scalarmath.py
index 90078a2ea3ce..65b8121a6128 100644
--- a/numpy/core/tests/test_scalarmath.py
+++ b/numpy/core/tests/test_scalarmath.py
@@ -4,9 +4,11 @@
 import itertools
 import operator
 import platform
+from numpy.compat import _pep440
 import pytest
-from hypothesis import given, settings, Verbosity
+from hypothesis import given, settings
 from hypothesis.strategies import sampled_from
+from hypothesis.extra import numpy as hynp
 
 import numpy as np
 from numpy.testing import (
@@ -23,6 +25,14 @@
 floating_types = np.floating.__subclasses__()
 complex_floating_types = np.complexfloating.__subclasses__()
 
+objecty_things = [object(), None]
+
+reasonable_operators_for_scalars = [
+    operator.lt, operator.le, operator.eq, operator.ne, operator.ge,
+    operator.gt, operator.add, operator.floordiv, operator.mod,
+    operator.mul, operator.pow, operator.sub, operator.truediv,
+]
+
 
 # This compares scalarmath against ufuncs.
 
@@ -65,6 +75,76 @@ def test_leak(self):
             np.add(1, 1)
 
 
+def check_ufunc_scalar_equivalence(op, arr1, arr2):
+    scalar1 = arr1[()]
+    scalar2 = arr2[()]
+    assert isinstance(scalar1, np.generic)
+    assert isinstance(scalar2, np.generic)
+
+    if arr1.dtype.kind == "c" or arr2.dtype.kind == "c":
+        comp_ops = {operator.ge, operator.gt, operator.le, operator.lt}
+        if op in comp_ops and (np.isnan(scalar1) or np.isnan(scalar2)):
+            pytest.xfail("complex comp ufuncs use sort-order, scalars do not.")
+    if op == operator.pow and arr2.item() in [-1, 0, 0.5, 1, 2]:
+        # array**scalar special case can have different result dtype
+        # (Other powers may have issues also, but are not hit here.)
+        # TODO: It would be nice to resolve this issue.
+        pytest.skip("array**2 can have incorrect/weird result dtype")
+
+    # ignore fpe's since they may just mismatch for integers anyway.
+    with warnings.catch_warnings(), np.errstate(all="ignore"):
+        # Comparisons DeprecationWarnings replacing errors (2022-03):
+        warnings.simplefilter("error", DeprecationWarning)
+        try:
+            res = op(arr1, arr2)
+        except Exception as e:
+            with pytest.raises(type(e)):
+                op(scalar1, scalar2)
+        else:
+            scalar_res = op(scalar1, scalar2)
+            assert_array_equal(scalar_res, res, strict=True)
+
+
+@pytest.mark.slow
+@settings(max_examples=10000, deadline=2000)
+@given(sampled_from(reasonable_operators_for_scalars),
+       hynp.arrays(dtype=hynp.scalar_dtypes(), shape=()),
+       hynp.arrays(dtype=hynp.scalar_dtypes(), shape=()))
+def test_array_scalar_ufunc_equivalence(op, arr1, arr2):
+    """
+    This is a thorough test attempting to cover important promotion paths
+    and ensuring that arrays and scalars stay as aligned as possible.
+    However, if it creates troubles, it should maybe just be removed.
+    """
+    check_ufunc_scalar_equivalence(op, arr1, arr2)
+
+
+@pytest.mark.slow
+@given(sampled_from(reasonable_operators_for_scalars),
+       hynp.scalar_dtypes(), hynp.scalar_dtypes())
+def test_array_scalar_ufunc_dtypes(op, dt1, dt2):
+    # Same as above, but don't worry about sampling weird values so that we
+    # do not have to sample as much
+    arr1 = np.array(2, dtype=dt1)
+    arr2 = np.array(3, dtype=dt2)  # some power do weird things.
+
+    check_ufunc_scalar_equivalence(op, arr1, arr2)
+
+
+@pytest.mark.parametrize("fscalar", [np.float16, np.float32])
+def test_int_float_promotion_truediv(fscalar):
+    # Promotion for mixed int and float32/float16 must not go to float64
+    i = np.int8(1)
+    f = fscalar(1)
+    expected = np.result_type(i, f)
+    assert (i / f).dtype == expected
+    assert (f / i).dtype == expected
+    # But normal int / int true division goes to float64:
+    assert (i / i).dtype == np.dtype("float64")
+    # For int16, result has to be ast least float32 (takes ufunc path):
+    assert (np.int16(1) / f).dtype == np.dtype("float32")
+
+
 class TestBaseMath:
     def test_blocked(self):
         # test alignments offsets for simd instructions
@@ -397,7 +477,8 @@ def test_int_from_long(self):
 
     def test_iinfo_long_values(self):
         for code in 'bBhH':
-            res = np.array(np.iinfo(code).max + 1, dtype=code)
+            with pytest.warns(DeprecationWarning):
+                res = np.array(np.iinfo(code).max + 1, dtype=code)
             tgt = np.iinfo(code).min
             assert_(res == tgt)
 
@@ -638,8 +719,12 @@ def test_result(self):
             sup.filter(RuntimeWarning)
             for dt in types:
                 a = np.ones((), dtype=dt)[()]
-                assert_equal(operator.neg(a) + a, 0)
-
+                if dt in np.typecodes['UnsignedInteger']:
+                    st = np.dtype(dt).type
+                    max = st(np.iinfo(dt).max)
+                    assert_equal(operator.neg(a), max)
+                else:
+                    assert_equal(operator.neg(a) + a, 0)
 
 class TestSubtract:
     def test_exceptions(self):
@@ -680,17 +765,29 @@ def _test_abs_func(self, absfunc, test_dtype):
 
     @pytest.mark.parametrize("dtype", floating_types + complex_floating_types)
     def test_builtin_abs(self, dtype):
-        if sys.platform == "cygwin" and dtype == np.clongdouble:
+        if (
+                sys.platform == "cygwin" and dtype == np.clongdouble and
+                (
+                    _pep440.parse(platform.release().split("-")[0])
+                    < _pep440.Version("3.3.0")
+                )
+        ):
             pytest.xfail(
-                reason="absl is computed in double precision on cygwin"
+                reason="absl is computed in double precision on cygwin < 3.3"
             )
         self._test_abs_func(abs, dtype)
 
     @pytest.mark.parametrize("dtype", floating_types + complex_floating_types)
     def test_numpy_abs(self, dtype):
-        if sys.platform == "cygwin" and dtype == np.clongdouble:
+        if (
+                sys.platform == "cygwin" and dtype == np.clongdouble and
+                (
+                    _pep440.parse(platform.release().split("-")[0])
+                    < _pep440.Version("3.3.0")
+                )
+        ):
             pytest.xfail(
-                reason="absl is computed in double precision on cygwin"
+                reason="absl is computed in double precision on cygwin < 3.3"
             )
         self._test_abs_func(np.abs, dtype)
 
@@ -706,7 +803,7 @@ def test_shift_all_bits(self, type_code, op):
         nbits = dt.itemsize * 8
         for val in [5, -5]:
             for shift in [nbits, nbits + 4]:
-                val_scl = dt.type(val)
+                val_scl = np.array(val).astype(dt)[()]
                 shift_scl = dt.type(shift)
                 res_scl = op(val_scl, shift_scl)
                 if val_scl < 0 and op is operator.rshift:
@@ -716,7 +813,7 @@ def test_shift_all_bits(self, type_code, op):
                     assert_equal(res_scl, 0)
 
                 # Result on scalars should be the same as on arrays
-                val_arr = np.array([val]*32, dtype=dt)
+                val_arr = np.array([val_scl]*32, dtype=dt)
                 shift_arr = np.array([shift]*32, dtype=dt)
                 res_arr = op(val_arr, shift_arr)
                 assert_equal(res_arr, res_scl)
@@ -740,11 +837,10 @@ def test_float_and_complex_hashes(self, type_code):
             else:
                 val = float(numpy_val)
             assert val == numpy_val
-            print(repr(numpy_val), repr(val))
             assert hash(val) == hash(numpy_val)
 
         if hash(float(np.nan)) != hash(float(np.nan)):
-            # If Python distinguises different NaNs we do so too (gh-18833)
+            # If Python distinguishes different NaNs we do so too (gh-18833)
             assert hash(scalar(np.nan)) != hash(scalar(np.nan))
 
     @pytest.mark.parametrize("type_code", np.typecodes['Complex'])
@@ -766,19 +862,9 @@ def recursionlimit(n):
         sys.setrecursionlimit(o)
 
 
-objecty_things = [object(), None]
-reasonable_operators_for_scalars = [
-    operator.lt, operator.le, operator.eq, operator.ne, operator.ge,
-    operator.gt, operator.add, operator.floordiv, operator.mod,
-    operator.mul, operator.matmul, operator.pow, operator.sub,
-    operator.truediv,
-]
-
-
 @given(sampled_from(objecty_things),
        sampled_from(reasonable_operators_for_scalars),
        sampled_from(types))
-@settings(verbosity=Verbosity.verbose)
 def test_operator_object_left(o, op, type_):
     try:
         with recursionlimit(200):
@@ -809,26 +895,193 @@ def test_operator_scalars(op, type1, type2):
 
 
 @pytest.mark.parametrize("op", reasonable_operators_for_scalars)
-def test_longdouble_inf_loop(op):
+@pytest.mark.parametrize("val", [None, 2**64])
+def test_longdouble_inf_loop(op, val):
+    # Note: The 2**64 value will pass once NEP 50 is adopted.
     try:
-        op(np.longdouble(3), None)
+        op(np.longdouble(3), val)
     except TypeError:
         pass
     try:
-        op(None, np.longdouble(3))
+        op(val, np.longdouble(3))
     except TypeError:
         pass
 
 
 @pytest.mark.parametrize("op", reasonable_operators_for_scalars)
-def test_clongdouble_inf_loop(op):
-    if op in {operator.mod} and False:
-        pytest.xfail("The modulo operator is known to be broken")
+@pytest.mark.parametrize("val", [None, 2**64])
+def test_clongdouble_inf_loop(op, val):
+    # Note: The 2**64 value will pass once NEP 50 is adopted.
     try:
-        op(np.clongdouble(3), None)
+        op(np.clongdouble(3), val)
     except TypeError:
         pass
     try:
-        op(None, np.longdouble(3))
+        op(val, np.longdouble(3))
     except TypeError:
         pass
+
+
+@pytest.mark.parametrize("dtype", np.typecodes["AllInteger"])
+@pytest.mark.parametrize("operation", [
+        lambda min, max: max + max,
+        lambda min, max: min - max,
+        lambda min, max: max * max], ids=["+", "-", "*"])
+def test_scalar_integer_operation_overflow(dtype, operation):
+    st = np.dtype(dtype).type
+    min = st(np.iinfo(dtype).min)
+    max = st(np.iinfo(dtype).max)
+
+    with pytest.warns(RuntimeWarning, match="overflow encountered"):
+        operation(min, max)
+
+
+@pytest.mark.parametrize("dtype", np.typecodes["Integer"])
+@pytest.mark.parametrize("operation", [
+        lambda min, neg_1: -min,
+        lambda min, neg_1: abs(min),
+        lambda min, neg_1: min * neg_1,
+        pytest.param(lambda min, neg_1: min // neg_1,
+            marks=pytest.mark.skip(reason="broken on some platforms"))],
+        ids=["neg", "abs", "*", "//"])
+def test_scalar_signed_integer_overflow(dtype, operation):
+    # The minimum signed integer can "overflow" for some additional operations
+    st = np.dtype(dtype).type
+    min = st(np.iinfo(dtype).min)
+    neg_1 = st(-1)
+
+    with pytest.warns(RuntimeWarning, match="overflow encountered"):
+        operation(min, neg_1)
+
+
+@pytest.mark.parametrize("dtype", np.typecodes["UnsignedInteger"])
+def test_scalar_unsigned_integer_overflow(dtype):
+    val = np.dtype(dtype).type(8)
+    with pytest.warns(RuntimeWarning, match="overflow encountered"):
+        -val
+
+    zero = np.dtype(dtype).type(0)
+    -zero  # does not warn
+
+@pytest.mark.parametrize("dtype", np.typecodes["AllInteger"])
+@pytest.mark.parametrize("operation", [
+        lambda val, zero: val // zero,
+        lambda val, zero: val % zero, ], ids=["//", "%"])
+def test_scalar_integer_operation_divbyzero(dtype, operation):
+    st = np.dtype(dtype).type
+    val = st(100)
+    zero = st(0)
+
+    with pytest.warns(RuntimeWarning, match="divide by zero"):
+        operation(val, zero)
+
+
+ops_with_names = [
+    ("__lt__", "__gt__", operator.lt, True),
+    ("__le__", "__ge__", operator.le, True),
+    ("__eq__", "__eq__", operator.eq, True),
+    # Note __op__ and __rop__ may be identical here:
+    ("__ne__", "__ne__", operator.ne, True),
+    ("__gt__", "__lt__", operator.gt, True),
+    ("__ge__", "__le__", operator.ge, True),
+    ("__floordiv__", "__rfloordiv__", operator.floordiv, False),
+    ("__truediv__", "__rtruediv__", operator.truediv, False),
+    ("__add__", "__radd__", operator.add, False),
+    ("__mod__", "__rmod__", operator.mod, False),
+    ("__mul__", "__rmul__", operator.mul, False),
+    ("__pow__", "__rpow__", operator.pow, False),
+    ("__sub__", "__rsub__", operator.sub, False),
+]
+
+
+@pytest.mark.parametrize(["__op__", "__rop__", "op", "cmp"], ops_with_names)
+@pytest.mark.parametrize("sctype", [np.float32, np.float64, np.longdouble])
+def test_subclass_deferral(sctype, __op__, __rop__, op, cmp):
+    """
+    This test covers scalar subclass deferral.  Note that this is exceedingly
+    complicated, especially since it tends to fall back to the array paths and
+    these additionally add the "array priority" mechanism.
+
+    The behaviour was modified subtly in 1.22 (to make it closer to how Python
+    scalars work).  Due to its complexity and the fact that subclassing NumPy
+    scalars is probably a bad idea to begin with.  There is probably room
+    for adjustments here.
+    """
+    class myf_simple1(sctype):
+        pass
+
+    class myf_simple2(sctype):
+        pass
+
+    def op_func(self, other):
+        return __op__
+
+    def rop_func(self, other):
+        return __rop__
+
+    myf_op = type("myf_op", (sctype,), {__op__: op_func, __rop__: rop_func})
+
+    # inheritance has to override, or this is correctly lost:
+    res = op(myf_simple1(1), myf_simple2(2))
+    assert type(res) == sctype or type(res) == np.bool_
+    assert op(myf_simple1(1), myf_simple2(2)) == op(1, 2)  # inherited
+
+    # Two independent subclasses do not really define an order.  This could
+    # be attempted, but we do not since Python's `int` does neither:
+    assert op(myf_op(1), myf_simple1(2)) == __op__
+    assert op(myf_simple1(1), myf_op(2)) == op(1, 2)  # inherited
+
+
+def test_longdouble_complex():
+    # Simple test to check longdouble and complex combinations, since these
+    # need to go through promotion, which longdouble needs to be careful about.
+    x = np.longdouble(1)
+    assert x + 1j == 1+1j
+    assert 1j + x == 1+1j
+
+
+@pytest.mark.parametrize(["__op__", "__rop__", "op", "cmp"], ops_with_names)
+@pytest.mark.parametrize("subtype", [float, int, complex, np.float16])
+@np._no_nep50_warning()
+def test_pyscalar_subclasses(subtype, __op__, __rop__, op, cmp):
+    def op_func(self, other):
+        return __op__
+
+    def rop_func(self, other):
+        return __rop__
+
+    # Check that deferring is indicated using `__array_ufunc__`:
+    myt = type("myt", (subtype,),
+               {__op__: op_func, __rop__: rop_func, "__array_ufunc__": None})
+
+    # Just like normally, we should never presume we can modify the float.
+    assert op(myt(1), np.float64(2)) == __op__
+    assert op(np.float64(1), myt(2)) == __rop__
+
+    if op in {operator.mod, operator.floordiv} and subtype == complex:
+        return  # module is not support for complex.  Do not test.
+
+    if __rop__ == __op__:
+        return
+
+    # When no deferring is indicated, subclasses are handled normally.
+    myt = type("myt", (subtype,), {__rop__: rop_func})
+
+    # Check for float32, as a float subclass float64 may behave differently
+    res = op(myt(1), np.float16(2))
+    expected = op(subtype(1), np.float16(2))
+    assert res == expected
+    assert type(res) == type(expected)
+    res = op(np.float32(2), myt(1))
+    expected = op(np.float32(2), subtype(1))
+    assert res == expected
+    assert type(res) == type(expected)
+
+    # Same check for longdouble:
+    res = op(myt(1), np.longdouble(2))
+    expected = op(subtype(1), np.longdouble(2))
+    assert res == expected
+    assert type(res) == type(expected)
+    res = op(np.float32(2), myt(1))
+    expected = op(np.longdouble(2), subtype(1))
+    assert res == expected
diff --git a/numpy/core/tests/test_scalarprint.py b/numpy/core/tests/test_scalarprint.py
index ee21d4aa5e0d..4deb5a0a4c2f 100644
--- a/numpy/core/tests/test_scalarprint.py
+++ b/numpy/core/tests/test_scalarprint.py
@@ -306,6 +306,7 @@ def test_dragon4_interface(self):
             assert_equal(fpos(tp('1.2'), unique=False, precision=4, trim='-'),
                          "1.2" if tp != np.float16 else "1.2002")
             assert_equal(fpos(tp('1.'), trim='-'), "1")
+            assert_equal(fpos(tp('1.001'), precision=1, trim='-'), "1")
 
     @pytest.mark.skipif(not platform.machine().startswith("ppc64"),
                         reason="only applies to ppc float128 values")
diff --git a/numpy/core/tests/test_shape_base.py b/numpy/core/tests/test_shape_base.py
index 679e3c036351..570d006f5ad6 100644
--- a/numpy/core/tests/test_shape_base.py
+++ b/numpy/core/tests/test_shape_base.py
@@ -157,6 +157,19 @@ def test_generator(self):
         with assert_warns(FutureWarning):
             hstack(map(lambda x: x, np.ones((3, 2))))
 
+    def test_casting_and_dtype(self):
+        a = np.array([1, 2, 3])
+        b = np.array([2.5, 3.5, 4.5])
+        res = np.hstack((a, b), casting="unsafe", dtype=np.int64)
+        expected_res = np.array([1, 2, 3, 2, 3, 4])
+        assert_array_equal(res, expected_res)
+    
+    def test_casting_and_dtype_type_error(self):
+        a = np.array([1, 2, 3])
+        b = np.array([2.5, 3.5, 4.5])
+        with pytest.raises(TypeError):
+            hstack((a, b), casting="safe", dtype=np.int64)
+
 
 class TestVstack:
     def test_non_iterable(self):
@@ -197,6 +210,20 @@ def test_generator(self):
         with assert_warns(FutureWarning):
             vstack((np.arange(3) for _ in range(2)))
 
+    def test_casting_and_dtype(self):
+        a = np.array([1, 2, 3])
+        b = np.array([2.5, 3.5, 4.5])
+        res = np.vstack((a, b), casting="unsafe", dtype=np.int64)
+        expected_res = np.array([[1, 2, 3], [2, 3, 4]])
+        assert_array_equal(res, expected_res)
+    
+    def test_casting_and_dtype_type_error(self):
+        a = np.array([1, 2, 3])
+        b = np.array([2.5, 3.5, 4.5])
+        with pytest.raises(TypeError):
+            vstack((a, b), casting="safe", dtype=np.int64)
+        
+
 
 class TestConcatenate:
     def test_returns_copy(self):
@@ -233,7 +260,7 @@ def test_exceptions(self):
             np.concatenate((a, b), axis=axis[0])  # OK
             assert_raises_regex(
                 ValueError,
-                "all the input array dimensions for the concatenation axis "
+                "all the input array dimensions except for the concatenation axis "
                 "must match exactly, but along dimension {}, the array at "
                 "index 0 has size 1 and the array at index 1 has size 2"
                 .format(i),
@@ -449,6 +476,41 @@ def test_stack():
     with assert_warns(FutureWarning):
         result = stack((x for x in range(3)))
     assert_array_equal(result, np.array([0, 1, 2]))
+    #casting and dtype test
+    a = np.array([1, 2, 3])
+    b = np.array([2.5, 3.5, 4.5])
+    res = np.stack((a, b), axis=1, casting="unsafe", dtype=np.int64)
+    expected_res = np.array([[1, 2], [2, 3], [3, 4]])
+    assert_array_equal(res, expected_res)
+    #casting and dtype with TypeError
+    with assert_raises(TypeError):
+        stack((a, b), dtype=np.int64, axis=1, casting="safe")
+
+
+@pytest.mark.parametrize("axis", [0])
+@pytest.mark.parametrize("out_dtype", ["c8", "f4", "f8", ">f8", "i8"])
+@pytest.mark.parametrize("casting",
+                         ['no', 'equiv', 'safe', 'same_kind', 'unsafe'])
+def test_stack_out_and_dtype(axis, out_dtype, casting):
+    to_concat = (array([1, 2]), array([3, 4]))
+    res = array([[1, 2], [3, 4]])
+    out = np.zeros_like(res)
+
+    if not np.can_cast(to_concat[0], out_dtype, casting=casting):
+        with assert_raises(TypeError):
+            stack(to_concat, dtype=out_dtype,
+                  axis=axis, casting=casting)
+    else:
+        res_out = stack(to_concat, out=out,
+                        axis=axis, casting=casting)
+        res_dtype = stack(to_concat, dtype=out_dtype,
+                          axis=axis, casting=casting)
+        assert res_out is out
+        assert_array_equal(out, res_dtype)
+        assert res_dtype.dtype == out_dtype
+
+    with assert_raises(TypeError):
+        stack(to_concat, out=out, dtype=out_dtype, axis=axis)
 
 
 class TestBlock:
diff --git a/numpy/core/tests/test_simd.py b/numpy/core/tests/test_simd.py
index 12a67c44dde5..2c16243db306 100644
--- a/numpy/core/tests/test_simd.py
+++ b/numpy/core/tests/test_simd.py
@@ -2,9 +2,24 @@
 # may be involved in their functionality.
 import pytest, math, re
 import itertools
-from numpy.core._simd import targets
+import operator
+from numpy.core._simd import targets, clear_floatstatus, get_floatstatus
 from numpy.core._multiarray_umath import __cpu_baseline__
 
+def check_floatstatus(divbyzero=False, overflow=False,
+                      underflow=False, invalid=False,
+                      all=False):
+    #define NPY_FPE_DIVIDEBYZERO  1
+    #define NPY_FPE_OVERFLOW      2
+    #define NPY_FPE_UNDERFLOW     4
+    #define NPY_FPE_INVALID       8
+    err = get_floatstatus()
+    ret = (all or divbyzero) and (err & 1) != 0
+    ret |= (all or overflow) and (err & 2) != 0
+    ret |= (all or underflow) and (err & 4) != 0
+    ret |= (all or invalid) and (err & 8) != 0
+    return ret
+
 class _Test_Utility:
     # submodule of the desired SIMD extension, e.g. targets["AVX512F"]
     npyv = None
@@ -85,16 +100,13 @@ def _to_unsigned(self, vector):
             return getattr(self.npyv, cvt_intrin.format(sfx[1:], sfx))(vector)
 
     def _pinfinity(self):
-        v = self.npyv.setall_u32(0x7f800000)
-        return self.npyv.reinterpret_f32_u32(v)[0]
+        return float("inf")
 
     def _ninfinity(self):
-        v = self.npyv.setall_u32(0xff800000)
-        return self.npyv.reinterpret_f32_u32(v)[0]
+        return -float("inf")
 
     def _nan(self):
-        v = self.npyv.setall_u32(0x7fc00000)
-        return self.npyv.reinterpret_f32_u32(v)[0]
+        return float("nan")
 
     def _cpu_features(self):
         target = self.target_name
@@ -108,10 +120,12 @@ class _SIMD_BOOL(_Test_Utility):
     """
     To test all boolean vector types at once
     """
+    def _nlanes(self):
+        return getattr(self.npyv, "nlanes_u" + self.sfx[1:])
+
     def _data(self, start=None, count=None, reverse=False):
-        nlanes = getattr(self.npyv, "nlanes_u" + self.sfx[1:])
         true_mask = self._true_mask()
-        rng = range(nlanes)
+        rng = range(self._nlanes())
         if reverse:
             rng = reversed(rng)
         return [true_mask if x % 2 else 0 for x in rng]
@@ -126,7 +140,8 @@ def test_operators_logical(self):
         """
         Logical operations for boolean types.
         Test intrinsics:
-            npyv_xor_##SFX, npyv_and_##SFX, npyv_or_##SFX, npyv_not_##SFX
+            npyv_xor_##SFX, npyv_and_##SFX, npyv_or_##SFX, npyv_not_##SFX,
+            npyv_andc_b8, npvy_orc_b8, nvpy_xnor_b8
         """
         data_a = self._data()
         data_b = self._data(reverse=True)
@@ -148,13 +163,81 @@ def test_operators_logical(self):
         vnot = getattr(self, "not")(vdata_a)
         assert vnot == data_b
 
+        # among the boolean types, andc, orc and xnor only support b8
+        if self.sfx not in ("b8"):
+            return
+
+        data_andc = [(a & ~b) & 0xFF for a, b in zip(data_a, data_b)]
+        vandc = getattr(self, "andc")(vdata_a, vdata_b)
+        assert data_andc == vandc
+
+        data_orc = [(a | ~b) & 0xFF for a, b in zip(data_a, data_b)]
+        vorc = getattr(self, "orc")(vdata_a, vdata_b)
+        assert data_orc == vorc
+
+        data_xnor = [~(a ^ b) & 0xFF for a, b in zip(data_a, data_b)]
+        vxnor = getattr(self, "xnor")(vdata_a, vdata_b)
+        assert data_xnor == vxnor
+
     def test_tobits(self):
         data2bits = lambda data: sum([int(x != 0) << i for i, x in enumerate(data, 0)])
         for data in (self._data(), self._data(reverse=True)):
             vdata = self._load_b(data)
             data_bits = data2bits(data)
-            tobits = bin(self.tobits(vdata))
-            assert tobits == bin(data_bits)
+            tobits = self.tobits(vdata)
+            bin_tobits = bin(tobits)
+            assert bin_tobits == bin(data_bits)
+
+    def test_pack(self):
+        """
+        Pack multiple vectors into one
+        Test intrinsics:
+            npyv_pack_b8_b16
+            npyv_pack_b8_b32
+            npyv_pack_b8_b64
+        """
+        if self.sfx not in ("b16", "b32", "b64"):
+            return
+        # create the vectors
+        data = self._data()
+        rdata = self._data(reverse=True)
+        vdata = self._load_b(data)
+        vrdata = self._load_b(rdata)
+        pack_simd = getattr(self.npyv, f"pack_b8_{self.sfx}")
+        # for scalar execution, concatenate the elements of the multiple lists
+        # into a single list (spack) and then iterate over the elements of
+        # the created list applying a mask to capture the first byte of them.
+        if self.sfx == "b16":
+            spack = [(i & 0xFF) for i in (list(rdata) + list(data))]
+            vpack = pack_simd(vrdata, vdata)
+        elif self.sfx == "b32":
+            spack = [(i & 0xFF) for i in (2*list(rdata) + 2*list(data))]
+            vpack = pack_simd(vrdata, vrdata, vdata, vdata)
+        elif self.sfx == "b64":
+            spack = [(i & 0xFF) for i in (4*list(rdata) + 4*list(data))]
+            vpack = pack_simd(vrdata, vrdata, vrdata, vrdata,
+                               vdata,  vdata,  vdata,  vdata)
+        assert vpack == spack
+
+    @pytest.mark.parametrize("intrin", ["any", "all"])
+    @pytest.mark.parametrize("data", (
+        [-1, 0],
+        [0, -1],
+        [-1],
+        [0]
+    ))
+    def test_operators_crosstest(self, intrin, data):
+        """
+        Test intrinsics:
+            npyv_any_##SFX
+            npyv_all_##SFX
+        """
+        data_a = self._load_b(data * self._nlanes())
+        func = eval(intrin)
+        intrin = getattr(self, intrin)
+        desired = func(data_a)
+        simd = intrin(data_a)
+        assert not not simd == desired
 
 class _SIMD_INT(_Test_Utility):
     """
@@ -222,6 +305,18 @@ def test_math_max_min(self):
         simd_min = self.min(vdata_a, vdata_b)
         assert simd_min == data_min
 
+    @pytest.mark.parametrize("start", [-100, -10000, 0, 100, 10000])
+    def test_reduce_max_min(self, start):
+        """
+        Test intrinsics:
+            npyv_reduce_max_##sfx
+            npyv_reduce_min_##sfx
+        """
+        vdata_a = self.load(self._data(start))
+        assert self.reduce_max(vdata_a) == max(vdata_a)
+        assert self.reduce_min(vdata_a) == min(vdata_a)
+
+
 class _SIMD_FP32(_Test_Utility):
     """
     To only test single precision
@@ -330,16 +425,18 @@ def test_square(self):
         square = self.square(vdata)
         assert square == data_square
 
-    @pytest.mark.parametrize("intrin, func", [("self.ceil", math.ceil),
-    ("self.trunc", math.trunc)])
+    @pytest.mark.parametrize("intrin, func", [("ceil", math.ceil),
+    ("trunc", math.trunc), ("floor", math.floor), ("rint", round)])
     def test_rounding(self, intrin, func):
         """
         Test intrinsics:
+            npyv_rint_##SFX
             npyv_ceil_##SFX
             npyv_trunc_##SFX
+            npyv_floor##SFX
         """
         intrin_name = intrin
-        intrin = eval(intrin)
+        intrin = getattr(self, intrin)
         pinf, ninf, nan = self._pinfinity(), self._ninfinity(), self._nan()
         # special cases
         round_cases = ((nan, nan), (pinf, pinf), (ninf, ninf))
@@ -347,81 +444,106 @@ def test_rounding(self, intrin, func):
             data_round = [desired]*self.nlanes
             _round = intrin(self.setall(case))
             assert _round == pytest.approx(data_round, nan_ok=True)
+
         for x in range(0, 2**20, 256**2):
             for w in (-1.05, -1.10, -1.15, 1.05, 1.10, 1.15):
-                data = [x*w+a for a in range(self.nlanes)]
-                vdata = self.load(data)
+                data = self.load([(x+a)*w for a in range(self.nlanes)])
                 data_round = [func(x) for x in data]
-                _round = intrin(vdata)
+                _round = intrin(data)
                 assert _round == data_round
+
+        # test large numbers
+        for i in (
+            1.1529215045988576e+18, 4.6116860183954304e+18,
+            5.902958103546122e+20, 2.3611832414184488e+21
+        ):
+            x = self.setall(i)
+            y = intrin(x)
+            data_round = [func(n) for n in x]
+            assert y == data_round
+
         # signed zero
-        if "ceil" in intrin_name or "trunc" in intrin_name:
-            for w in (-0.25, -0.30, -0.45):
-                _round = self._to_unsigned(intrin(self.setall(w)))
-                data_round = self._to_unsigned(self.setall(-0.0))
-                assert _round == data_round
-    
-    def test_max(self):
-        """
-        Test intrinsics:
-            npyv_max_##SFX
-            npyv_maxp_##SFX
-        """
-        data_a = self._data()
-        data_b = self._data(self.nlanes)
-        vdata_a, vdata_b = self.load(data_a), self.load(data_b)
-        data_max = [max(a, b) for a, b in zip(data_a, data_b)]
-        _max = self.max(vdata_a, vdata_b)
-        assert _max == data_max
-        maxp = self.maxp(vdata_a, vdata_b)
-        assert maxp == data_max
-        # test IEEE standards
-        pinf, ninf, nan = self._pinfinity(), self._ninfinity(), self._nan()
-        max_cases = ((nan, nan, nan), (nan, 10, 10), (10, nan, 10),
-                     (pinf, pinf, pinf), (pinf, 10, pinf), (10, pinf, pinf),
-                     (ninf, ninf, ninf), (ninf, 10, 10), (10, ninf, 10),
-                     (10, 0, 10), (10, -10, 10))
-        for case_operand1, case_operand2, desired in max_cases:
-            data_max = [desired]*self.nlanes
-            vdata_a = self.setall(case_operand1)
-            vdata_b = self.setall(case_operand2)
-            maxp = self.maxp(vdata_a, vdata_b)
-            assert maxp == pytest.approx(data_max, nan_ok=True)
-            if nan in (case_operand1, case_operand2, desired):
-                continue
-            _max = self.max(vdata_a, vdata_b)
-            assert _max == data_max
+        if intrin_name == "floor":
+            data_szero = (-0.0,)
+        else:
+            data_szero = (-0.0, -0.25, -0.30, -0.45, -0.5)
+
+        for w in data_szero:
+            _round = self._to_unsigned(intrin(self.setall(w)))
+            data_round = self._to_unsigned(self.setall(-0.0))
+            assert _round == data_round
 
-    def test_min(self):
+    @pytest.mark.parametrize("intrin", [
+        "max", "maxp", "maxn", "min", "minp", "minn"
+    ])
+    def test_max_min(self, intrin):
         """
         Test intrinsics:
-            npyv_min_##SFX
-            npyv_minp_##SFX
+            npyv_max_##sfx
+            npyv_maxp_##sfx
+            npyv_maxn_##sfx
+            npyv_min_##sfx
+            npyv_minp_##sfx
+            npyv_minn_##sfx
+            npyv_reduce_max_##sfx
+            npyv_reduce_maxp_##sfx
+            npyv_reduce_maxn_##sfx
+            npyv_reduce_min_##sfx
+            npyv_reduce_minp_##sfx
+            npyv_reduce_minn_##sfx
         """
-        data_a = self._data()
-        data_b = self._data(self.nlanes)
-        vdata_a, vdata_b = self.load(data_a), self.load(data_b)
-        data_min = [min(a, b) for a, b in zip(data_a, data_b)]
-        _min = self.min(vdata_a, vdata_b)
-        assert _min == data_min
-        minp = self.minp(vdata_a, vdata_b)
-        assert minp == data_min
-        # test IEEE standards
         pinf, ninf, nan = self._pinfinity(), self._ninfinity(), self._nan()
-        min_cases = ((nan, nan, nan), (nan, 10, 10), (10, nan, 10),
-                     (pinf, pinf, pinf), (pinf, 10, 10), (10, pinf, 10),
-                     (ninf, ninf, ninf), (ninf, 10, ninf), (10, ninf, ninf),
-                     (10, 0, 0), (10, -10, -10))
-        for case_operand1, case_operand2, desired in min_cases:
-            data_min = [desired]*self.nlanes
-            vdata_a = self.setall(case_operand1)
-            vdata_b = self.setall(case_operand2)
-            minp = self.minp(vdata_a, vdata_b)
-            assert minp == pytest.approx(data_min, nan_ok=True)
-            if nan in (case_operand1, case_operand2, desired):
-                continue
-            _min = self.min(vdata_a, vdata_b)
-            assert _min == data_min
+        chk_nan = {"xp": 1, "np": 1, "nn": 2, "xn": 2}.get(intrin[-2:], 0)
+        func = eval(intrin[:3])
+        reduce_intrin = getattr(self, "reduce_" + intrin)
+        intrin = getattr(self, intrin)
+        hf_nlanes = self.nlanes//2
+
+        cases = (
+            ([0.0, -0.0], [-0.0, 0.0]),
+            ([10, -10],  [10, -10]),
+            ([pinf, 10], [10, ninf]),
+            ([10, pinf], [ninf, 10]),
+            ([10, -10], [10, -10]),
+            ([-10, 10], [-10, 10])
+        )
+        for op1, op2 in cases:
+            vdata_a = self.load(op1*hf_nlanes)
+            vdata_b = self.load(op2*hf_nlanes)
+            data = func(vdata_a, vdata_b)
+            simd = intrin(vdata_a, vdata_b)
+            assert simd == data
+            data = func(vdata_a)
+            simd = reduce_intrin(vdata_a)
+            assert simd == data
+
+        if not chk_nan:
+            return
+        if chk_nan == 1:
+            test_nan = lambda a, b: (
+                b if math.isnan(a) else a if math.isnan(b) else b
+            )
+        else:
+            test_nan = lambda a, b: (
+                nan if math.isnan(a) or math.isnan(b) else b
+            )
+        cases = (
+            (nan, 10),
+            (10, nan),
+            (nan, pinf),
+            (pinf, nan),
+            (nan, nan)
+        )
+        for op1, op2 in cases:
+            vdata_ab = self.load([op1, op2]*hf_nlanes)
+            data = test_nan(op1, op2)
+            simd = reduce_intrin(vdata_ab)
+            assert simd == pytest.approx(data, nan_ok=True)
+            vdata_a = self.setall(op1)
+            vdata_b = self.setall(op2)
+            data = [data] * self.nlanes
+            simd = intrin(vdata_a, vdata_b)
+            assert simd == pytest.approx(data, nan_ok=True)
 
     def test_reciprocal(self):
         pinf, ninf, nan = self._pinfinity(), self._ninfinity(), self._nan()
@@ -446,6 +568,68 @@ def test_special_cases(self):
         nnan = self.notnan(self.setall(self._nan()))
         assert nnan == [0]*self.nlanes
 
+    @pytest.mark.parametrize("intrin_name", [
+        "rint", "trunc", "ceil", "floor"
+    ])
+    def test_unary_invalid_fpexception(self, intrin_name):
+        intrin = getattr(self, intrin_name)
+        for d in [float("nan"), float("inf"), -float("inf")]:
+            v = self.setall(d)
+            clear_floatstatus()
+            intrin(v)
+            assert check_floatstatus(invalid=True) == False
+
+    @pytest.mark.parametrize('py_comp,np_comp', [
+        (operator.lt, "cmplt"),
+        (operator.le, "cmple"),
+        (operator.gt, "cmpgt"),
+        (operator.ge, "cmpge"),
+        (operator.eq, "cmpeq"),
+        (operator.ne, "cmpneq")
+    ])
+    def test_comparison_with_nan(self, py_comp, np_comp):
+        pinf, ninf, nan = self._pinfinity(), self._ninfinity(), self._nan()
+        mask_true = self._true_mask()
+
+        def to_bool(vector):
+            return [lane == mask_true for lane in vector]
+
+        intrin = getattr(self, np_comp)
+        cmp_cases = ((0, nan), (nan, 0), (nan, nan), (pinf, nan),
+                     (ninf, nan), (-0.0, +0.0))
+        for case_operand1, case_operand2 in cmp_cases:
+            data_a = [case_operand1]*self.nlanes
+            data_b = [case_operand2]*self.nlanes
+            vdata_a = self.setall(case_operand1)
+            vdata_b = self.setall(case_operand2)
+            vcmp = to_bool(intrin(vdata_a, vdata_b))
+            data_cmp = [py_comp(a, b) for a, b in zip(data_a, data_b)]
+            assert vcmp == data_cmp
+
+    @pytest.mark.parametrize("intrin", ["any", "all"])
+    @pytest.mark.parametrize("data", (
+        [float("nan"), 0],
+        [0, float("nan")],
+        [float("nan"), 1],
+        [1, float("nan")],
+        [float("nan"), float("nan")],
+        [0.0, -0.0],
+        [-0.0, 0.0],
+        [1.0, -0.0]
+    ))
+    def test_operators_crosstest(self, intrin, data):
+        """
+        Test intrinsics:
+            npyv_any_##SFX
+            npyv_all_##SFX
+        """
+        data_a = self.load(data * self.nlanes)
+        func = eval(intrin)
+        intrin = getattr(self, intrin)
+        desired = func(data_a)
+        simd = intrin(data_a)
+        assert not not simd == desired
+
 class _SIMD_ALL(_Test_Utility):
     """
     To test all vector types at once
@@ -620,6 +804,27 @@ def test_memory_noncont_partial_store(self):
                 assert storen_till[64:] == data_till
                 assert storen_till[:64] == [127]*64 # detect overflow
 
+    @pytest.mark.parametrize("intrin, table_size, elsize", [
+        ("self.lut32", 32, 32),
+        ("self.lut16", 16, 64)
+    ])
+    def test_lut(self, intrin, table_size, elsize):
+        """
+        Test lookup table intrinsics:
+            npyv_lut32_##sfx
+            npyv_lut16_##sfx
+        """
+        if elsize != self._scalar_size():
+            return
+        intrin = eval(intrin)
+        idx_itrin = getattr(self.npyv, f"setall_u{elsize}")
+        table = range(0, table_size)
+        for i in table:
+            broadi = self.setall(i)
+            idx = idx_itrin(i)
+            lut = intrin(table, idx)
+            assert lut == broadi
+
     def test_misc(self):
         broadcast_zero = self.zero()
         assert broadcast_zero == [0] * self.nlanes
@@ -642,9 +847,11 @@ def test_misc(self):
         # We're testing the sanity of _simd's type-vector,
         # reinterpret* intrinsics itself are tested via compiler
         # during the build of _simd module
-        sfxes = ["u8", "s8", "u16", "s16", "u32", "s32", "u64", "s64", "f32"]
+        sfxes = ["u8", "s8", "u16", "s16", "u32", "s32", "u64", "s64"]
         if self.npyv.simd_f64:
             sfxes.append("f64")
+        if self.npyv.simd_f32:
+            sfxes.append("f32")
         for sfx in sfxes:
             vec_name = getattr(self, "reinterpret_" + sfx)(vdata_a).__name__
             assert vec_name == "npyv_" + sfx
@@ -655,6 +862,9 @@ def test_misc(self):
         select_b = self.select(self.cmpneq(self.zero(), self.zero()), vdata_a, vdata_b)
         assert select_b == data_b
 
+        # test extract elements
+        assert self.extract0(vdata_b) == vdata_b[0]
+
         # cleanup intrinsic is only used with AVX for
         # zeroing registers to avoid the AVX-SSE transition penalty,
         # so nothing to test here
@@ -696,41 +906,29 @@ def test_reorder_rev64(self):
         rev64 = self.rev64(self.load(range(self.nlanes)))
         assert rev64 == data_rev64
 
-    def test_operators_comparison(self):
+    @pytest.mark.parametrize('func, intrin', [
+        (operator.lt, "cmplt"),
+        (operator.le, "cmple"),
+        (operator.gt, "cmpgt"),
+        (operator.ge, "cmpge"),
+        (operator.eq, "cmpeq")
+    ])
+    def test_operators_comparison(self, func, intrin):
         if self._is_fp():
             data_a = self._data()
         else:
             data_a = self._data(self._int_max() - self.nlanes)
         data_b = self._data(self._int_min(), reverse=True)
         vdata_a, vdata_b = self.load(data_a), self.load(data_b)
+        intrin = getattr(self, intrin)
 
         mask_true = self._true_mask()
         def to_bool(vector):
             return [lane == mask_true for lane in vector]
-        # equal
-        data_eq = [a == b for a, b in zip(data_a, data_b)]
-        cmpeq = to_bool(self.cmpeq(vdata_a, vdata_b))
-        assert cmpeq == data_eq
-        # not equal
-        data_neq = [a != b for a, b in zip(data_a, data_b)]
-        cmpneq = to_bool(self.cmpneq(vdata_a, vdata_b))
-        assert cmpneq == data_neq
-        # greater than
-        data_gt = [a > b for a, b in zip(data_a, data_b)]
-        cmpgt = to_bool(self.cmpgt(vdata_a, vdata_b))
-        assert cmpgt == data_gt
-        # greater than and equal
-        data_ge = [a >= b for a, b in zip(data_a, data_b)]
-        cmpge = to_bool(self.cmpge(vdata_a, vdata_b))
-        assert cmpge == data_ge
-        # less than
-        data_lt  = [a < b for a, b in zip(data_a, data_b)]
-        cmplt = to_bool(self.cmplt(vdata_a, vdata_b))
-        assert cmplt == data_lt
-        # less than and equal
-        data_le  = [a <= b for a, b in zip(data_a, data_b)]
-        cmple = to_bool(self.cmple(vdata_a, vdata_b))
-        assert cmple == data_le
+
+        data_cmp = [func(a, b) for a, b in zip(data_a, data_b)]
+        cmp = to_bool(intrin(vdata_a, vdata_b))
+        assert cmp == data_cmp
 
     def test_operators_logical(self):
         if self._is_fp():
@@ -764,6 +962,36 @@ def test_operators_logical(self):
         vnot = cast(getattr(self, "not")(vdata_a))
         assert vnot == data_not
 
+        if self.sfx not in ("u8"):
+            return
+        data_andc = [a & ~b for a, b in zip(data_cast_a, data_cast_b)]
+        vandc = cast(getattr(self, "andc")(vdata_a, vdata_b))
+        assert vandc == data_andc
+
+    @pytest.mark.parametrize("intrin", ["any", "all"])
+    @pytest.mark.parametrize("data", (
+        [1, 2, 3, 4],
+        [-1, -2, -3, -4],
+        [0, 1, 2, 3, 4],
+        [0x7f, 0x7fff, 0x7fffffff, 0x7fffffffffffffff],
+        [0, -1, -2, -3, 4],
+        [0],
+        [1],
+        [-1]
+    ))
+    def test_operators_crosstest(self, intrin, data):
+        """
+        Test intrinsics:
+            npyv_any_##SFX
+            npyv_all_##SFX
+        """
+        data_a = self.load(data * self.nlanes)
+        func = eval(intrin)
+        intrin = getattr(self, intrin)
+        desired = func(data_a)
+        simd = intrin(data_a)
+        assert not not simd == desired
+
     def test_conversion_boolean(self):
         bsfx = "b" + self.sfx[1:]
         to_boolean = getattr(self.npyv, "cvt_%s_%s" % (bsfx, self.sfx))
@@ -967,8 +1195,13 @@ def test_mask_conditional(self):
         skip = f"target '{pretty_name}' isn't supported by current machine"
     elif not npyv.simd:
         skip = f"target '{pretty_name}' isn't supported by NPYV"
-    elif not npyv.simd_f64:
-        skip_sfx["f64"] = f"target '{pretty_name}' doesn't support double-precision"
+    else:
+        if not npyv.simd_f32:
+            skip_sfx["f32"] = f"target '{pretty_name}' "\
+                               "doesn't support single-precision"
+        if not npyv.simd_f64:
+            skip_sfx["f64"] = f"target '{pretty_name}' doesn't"\
+                               "support double-precision"
 
     for sfxes, cls in tests_registry.items():
         for sfx in sfxes:
diff --git a/numpy/core/tests/test_simd_module.py b/numpy/core/tests/test_simd_module.py
index 3d710884ab09..44dc58dac098 100644
--- a/numpy/core/tests/test_simd_module.py
+++ b/numpy/core/tests/test_simd_module.py
@@ -12,7 +12,9 @@
 
 unsigned_sfx = ["u8", "u16", "u32", "u64"]
 signed_sfx = ["s8", "s16", "s32", "s64"]
-fp_sfx = ["f32"]
+fp_sfx = []
+if npyv and npyv.simd_f32:
+    fp_sfx.append("f32")
 if npyv and npyv.simd_f64:
     fp_sfx.append("f64")
 
diff --git a/numpy/core/tests/test_strings.py b/numpy/core/tests/test_strings.py
new file mode 100644
index 000000000000..42f775e857b8
--- /dev/null
+++ b/numpy/core/tests/test_strings.py
@@ -0,0 +1,99 @@
+import pytest
+
+import operator
+import numpy as np
+
+from numpy.testing import assert_array_equal
+
+
+COMPARISONS = [
+    (operator.eq, np.equal, "=="),
+    (operator.ne, np.not_equal, "!="),
+    (operator.lt, np.less, "<"),
+    (operator.le, np.less_equal, "<="),
+    (operator.gt, np.greater, ">"),
+    (operator.ge, np.greater_equal, ">="),
+]
+
+
+@pytest.mark.parametrize(["op", "ufunc", "sym"], COMPARISONS)
+def test_mixed_string_comparison_ufuncs_fail(op, ufunc, sym):
+    arr_string = np.array(["a", "b"], dtype="S")
+    arr_unicode = np.array(["a", "c"], dtype="U")
+
+    with pytest.raises(TypeError, match="did not contain a loop"):
+        ufunc(arr_string, arr_unicode)
+
+    with pytest.raises(TypeError, match="did not contain a loop"):
+        ufunc(arr_unicode, arr_string)
+
+@pytest.mark.parametrize(["op", "ufunc", "sym"], COMPARISONS)
+def test_mixed_string_comparisons_ufuncs_with_cast(op, ufunc, sym):
+    arr_string = np.array(["a", "b"], dtype="S")
+    arr_unicode = np.array(["a", "c"], dtype="U")
+
+    # While there is no loop, manual casting is acceptable:
+    res1 = ufunc(arr_string, arr_unicode, signature="UU->?", casting="unsafe")
+    res2 = ufunc(arr_string, arr_unicode, signature="SS->?", casting="unsafe")
+
+    expected = op(arr_string.astype('U'), arr_unicode)
+    assert_array_equal(res1, expected)
+    assert_array_equal(res2, expected)
+
+
+@pytest.mark.parametrize(["op", "ufunc", "sym"], COMPARISONS)
+@pytest.mark.parametrize("dtypes", [
+        ("S2", "S2"), ("S2", "S10"),
+        ("U1"), (">U1", ">U1"),
+        ("U10")])
+@pytest.mark.parametrize("aligned", [True, False])
+def test_string_comparisons(op, ufunc, sym, dtypes, aligned):
+    # ensure native byte-order for the first view to stay within unicode range
+    native_dt = np.dtype(dtypes[0]).newbyteorder("=")
+    arr = np.arange(2**15).view(native_dt).astype(dtypes[0])
+    if not aligned:
+        # Make `arr` unaligned:
+        new = np.zeros(arr.nbytes + 1, dtype=np.uint8)[1:].view(dtypes[0])
+        new[...] = arr
+        arr = new
+
+    arr2 = arr.astype(dtypes[1], copy=True)
+    np.random.shuffle(arr2)
+    arr[0] = arr2[0]  # make sure one matches
+
+    expected = [op(d1, d2) for d1, d2 in zip(arr.tolist(), arr2.tolist())]
+    assert_array_equal(op(arr, arr2), expected)
+    assert_array_equal(ufunc(arr, arr2), expected)
+    assert_array_equal(np.compare_chararrays(arr, arr2, sym, False), expected)
+
+    expected = [op(d2, d1) for d1, d2 in zip(arr.tolist(), arr2.tolist())]
+    assert_array_equal(op(arr2, arr), expected)
+    assert_array_equal(ufunc(arr2, arr), expected)
+    assert_array_equal(np.compare_chararrays(arr2, arr, sym, False), expected)
+
+
+@pytest.mark.parametrize(["op", "ufunc", "sym"], COMPARISONS)
+@pytest.mark.parametrize("dtypes", [
+        ("S2", "S2"), ("S2", "S10"), ("U10")])
+def test_string_comparisons_empty(op, ufunc, sym, dtypes):
+    arr = np.empty((1, 0, 1, 5), dtype=dtypes[0])
+    arr2 = np.empty((100, 1, 0, 1), dtype=dtypes[1])
+
+    expected = np.empty(np.broadcast_shapes(arr.shape, arr2.shape), dtype=bool)
+    assert_array_equal(op(arr, arr2), expected)
+    assert_array_equal(ufunc(arr, arr2), expected)
+    assert_array_equal(np.compare_chararrays(arr, arr2, sym, False), expected)
+
+
+@pytest.mark.parametrize("str_dt", ["S", "U"])
+@pytest.mark.parametrize("float_dt", np.typecodes["AllFloat"])
+def test_float_to_string_cast(str_dt, float_dt):
+    float_dt = np.dtype(float_dt)
+    fi = np.finfo(float_dt)
+    arr = np.array([np.nan, np.inf, -np.inf, fi.max, fi.min], dtype=float_dt)
+    expected = ["nan", "inf", "-inf", repr(fi.max), repr(fi.min)]
+    if float_dt.kind == 'c':
+        expected = [f"({r}+0j)" for r in expected]
+
+    res = arr.astype(str_dt)
+    assert_array_equal(res, np.array(expected, dtype=str_dt))
diff --git a/numpy/core/tests/test_ufunc.py b/numpy/core/tests/test_ufunc.py
index ef0bac9574bc..cae84669740b 100644
--- a/numpy/core/tests/test_ufunc.py
+++ b/numpy/core/tests/test_ufunc.py
@@ -1,8 +1,10 @@
 import warnings
 import itertools
 import sys
+import ctypes as ct
 
 import pytest
+from pytest import param
 
 import numpy as np
 import numpy.core._umath_tests as umt
@@ -12,8 +14,9 @@
 from numpy.testing import (
     assert_, assert_equal, assert_raises, assert_array_equal,
     assert_almost_equal, assert_array_almost_equal, assert_no_warnings,
-    assert_allclose, HAS_REFCOUNT, suppress_warnings
+    assert_allclose, HAS_REFCOUNT, suppress_warnings, IS_WASM
     )
+from numpy.testing._private.utils import requires_memory
 from numpy.compat import pickle
 
 
@@ -333,7 +336,7 @@ def test_signature2(self):
 
     def test_signature3(self):
         enabled, num_dims, ixs, flags, sizes = umt.test_signature(
-            2, 1, u"(i1, i12),   (J_1)->(i12, i2)")
+            2, 1, "(i1, i12),   (J_1)->(i12, i2)")
         assert_equal(enabled, 1)
         assert_equal(num_dims, (2, 1, 2))
         assert_equal(ixs, (0, 1, 2, 1, 3))
@@ -388,7 +391,7 @@ def test_signature8(self):
         assert_equal(ixs, (0, 0, 0, 1, 2))
         assert_equal(flags, (self.can_ignore, self.size_inferred, 0))
         assert_equal(sizes, (3, -1, 9))
-    
+
     def test_signature9(self):
         enabled, num_dims, ixs, flags, sizes = umt.test_signature(
             1, 1, "(  3)  -> ( )")
@@ -476,6 +479,34 @@ def test_signature_dtype_type(self):
         float_dtype = type(np.dtype(np.float64))
         np.add(3, 4, signature=(float_dtype, float_dtype, None))
 
+    @pytest.mark.parametrize("get_kwarg", [
+            lambda dt: dict(dtype=x),
+            lambda dt: dict(signature=(x, None, None))])
+    def test_signature_dtype_instances_allowed(self, get_kwarg):
+        # We allow certain dtype instances when there is a clear singleton
+        # and the given one is equivalent; mainly for backcompat.
+        int64 = np.dtype("int64")
+        int64_2 = pickle.loads(pickle.dumps(int64))
+        # Relies on pickling behavior, if assert fails just remove test...
+        assert int64 is not int64_2
+
+        assert np.add(1, 2, **get_kwarg(int64_2)).dtype == int64
+        td = np.timedelta(2, "s")
+        assert np.add(td, td, **get_kwarg("m8")).dtype == "m8[s]"
+
+    @pytest.mark.parametrize("get_kwarg", [
+            param(lambda x: dict(dtype=x), id="dtype"),
+            param(lambda x: dict(signature=(x, None, None)), id="signature")])
+    def test_signature_dtype_instances_allowed(self, get_kwarg):
+        msg = "The `dtype` and `signature` arguments to ufuncs"
+
+        with pytest.raises(TypeError, match=msg):
+            np.add(3, 5, **get_kwarg(np.dtype("int64").newbyteorder()))
+        with pytest.raises(TypeError, match=msg):
+            np.add(3, 5, **get_kwarg(np.dtype("m8[ns]")))
+        with pytest.raises(TypeError, match=msg):
+            np.add(3, 5, **get_kwarg("m8[ns]"))
+
     @pytest.mark.parametrize("casting", ["unsafe", "same_kind", "safe"])
     def test_partial_signature_mismatch(self, casting):
         # If the second argument matches already, no need to specify it:
@@ -491,6 +522,15 @@ def test_partial_signature_mismatch(self, casting):
         with pytest.raises(TypeError):
             np.ldexp(1., np.uint64(3), signature=(None, None, "d"))
 
+    def test_partial_signature_mismatch_with_cache(self):
+        with pytest.raises(TypeError):
+            np.add(np.float16(1), np.uint64(2), sig=("e", "d", None))
+        # Ensure e,d->None is in the dispatching cache (double loop)
+        np.add(np.float16(1), np.float64(2))
+        # The error must still be raised:
+        with pytest.raises(TypeError):
+            np.add(np.float16(1), np.uint64(2), sig=("e", "d", None))
+
     def test_use_output_signature_for_all_arguments(self):
         # Test that providing only `dtype=` or `signature=(None, None, dtype)`
         # is sufficient if falling back to a homogeneous signature works.
@@ -619,8 +659,9 @@ def test_true_divide(self):
                                 atol = max(np.finfo(dtout).tiny, 3e-308)
                             else:
                                 atol = 3e-308
-                        # Some test values result in invalid for float16.
-                        with np.errstate(invalid='ignore'):
+                        # Some test values result in invalid for float16
+                        # and the cast to it may overflow to inf.
+                        with np.errstate(invalid='ignore', over='ignore'):
                             res = np.true_divide(x, y, dtype=dtout)
                         if not np.isfinite(res) and tcout == 'e':
                             continue
@@ -660,24 +701,27 @@ def test_sum_stability(self):
         a = np.ones(500, dtype=np.float64)
         assert_almost_equal((a / 10.).sum() - a.size / 10., 0, 13)
 
+    @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm")
     def test_sum(self):
         for dt in (int, np.float16, np.float32, np.float64, np.longdouble):
             for v in (0, 1, 2, 7, 8, 9, 15, 16, 19, 127,
                       128, 1024, 1235):
-                tgt = dt(v * (v + 1) / 2)
-                d = np.arange(1, v + 1, dtype=dt)
-
                 # warning if sum overflows, which it does in float16
-                overflow = not np.isfinite(tgt)
-
                 with warnings.catch_warnings(record=True) as w:
-                    warnings.simplefilter("always")
-                    assert_almost_equal(np.sum(d), tgt)
+                    warnings.simplefilter("always", RuntimeWarning)
+
+                    tgt = dt(v * (v + 1) / 2)
+                    overflow = not np.isfinite(tgt)
                     assert_equal(len(w), 1 * overflow)
 
-                    assert_almost_equal(np.sum(d[::-1]), tgt)
+                    d = np.arange(1, v + 1, dtype=dt)
+
+                    assert_almost_equal(np.sum(d), tgt)
                     assert_equal(len(w), 2 * overflow)
 
+                    assert_almost_equal(np.sum(d[::-1]), tgt)
+                    assert_equal(len(w), 3 * overflow)
+
             d = np.ones(500, dtype=dt)
             assert_almost_equal(np.sum(d[::2]), 250.)
             assert_almost_equal(np.sum(d[1::2]), 250.)
@@ -798,6 +842,20 @@ def test_out_broadcasts(self):
         # the result would be just a scalar `5`, but is broadcast fully:
         assert (out == 5).all()
 
+    @pytest.mark.parametrize(["arr", "out"], [
+                ([2], np.empty(())),
+                ([1, 2], np.empty(1)),
+                (np.ones((4, 3)), np.empty((4, 1)))],
+            ids=["(1,)->()", "(2,)->(1,)", "(4, 3)->(4, 1)"])
+    def test_out_broadcast_errors(self, arr, out):
+        # Output is (currently) allowed to broadcast inputs, but it cannot be
+        # smaller than the actual result.
+        with pytest.raises(ValueError, match="non-broadcastable"):
+            np.positive(arr, out=out)
+
+        with pytest.raises(ValueError, match="non-broadcastable"):
+            np.add(np.ones(()), arr, out=out)
+
     def test_type_cast(self):
         msg = "type cast"
         a = np.arange(6, dtype='short').reshape((2, 3))
@@ -1555,6 +1613,17 @@ def check_identityless_reduction(self, a):
                                     [[0, 1, 1], [1, 1, 1]])
         assert_equal(np.minimum.reduce(a, axis=()), a)
 
+    @requires_memory(6 * 1024**3)
+    def test_identityless_reduction_huge_array(self):
+        # Regression test for gh-20921 (copying identity incorrectly failed)
+        arr = np.zeros((2, 2**31), 'uint8')
+        arr[:, 0] = [1, 3]
+        arr[:, -1] = [4, 1]
+        res = np.maximum.reduce(arr, axis=0)
+        del arr
+        assert res[0] == 3
+        assert res[-1] == 4
+
     def test_identityless_reduction_corder(self):
         a = np.empty((2, 3, 4), order='C')
         self.check_identityless_reduction(a)
@@ -1762,12 +1831,15 @@ def test_ufunc_custom_out(self):
         result = _rational_tests.test_add(a, b)
         assert_equal(result, target)
 
-        # But since we use the old type resolver, this may not work
-        # for dtype variations unless the output dtype is given:
+        # This works even more generally, so long the default common-dtype
+        # promoter works out:
         result = _rational_tests.test_add(a, b.astype(np.uint16), out=c)
         assert_equal(result, target)
+
+        # But, it can be fooled, e.g. (use scalars, which forces legacy
+        # type resolution to kick in, which then fails):
         with assert_raises(TypeError):
-            _rational_tests.test_add(a, b.astype(np.uint16))
+            _rational_tests.test_add(a, np.uint16(2))
 
     def test_operand_flags(self):
         a = np.arange(16, dtype='l').reshape(4, 4)
@@ -1987,6 +2059,20 @@ def test_inplace_fancy_indexing(self):
         # Test multiple output ufuncs raise error, gh-5665
         assert_raises(ValueError, np.modf.at, np.arange(10), [1])
 
+        # Test maximum
+        a = np.array([1, 2, 3])
+        np.maximum.at(a, [0], 0)
+        assert_equal(np.array([1, 2, 3]), a)
+
+    def test_at_not_none_signature(self):
+        # Test ufuncs with non-trivial signature raise a TypeError
+        a = np.ones((2, 2, 2))
+        b = np.ones((1, 2, 2))
+        assert_raises(TypeError, np.matmul.at, a, [0], b)
+
+        a = np.array([[[1, 2], [3, 4]]])
+        assert_raises(TypeError, np.linalg._umath_linalg.det.at, a, [0])
+
     def test_reduce_arguments(self):
         f = np.add.reduce
         d = np.ones((5,2), dtype=int)
@@ -2119,10 +2205,38 @@ def test_logical_ufuncs_mixed_object_signatures(self, ufunc, signature):
             [np.logical_and, np.logical_or, np.logical_xor])
     def test_logical_ufuncs_support_anything(self, ufunc):
         # The logical ufuncs support even input that can't be promoted:
-        a = np.array('1')
+        a = np.array(b'1', dtype="V3")
         c = np.array([1., 2.])
         assert_array_equal(ufunc(a, c), ufunc([True, True], True))
         assert ufunc.reduce(a) == True
+        # check that the output has no effect:
+        out = np.zeros(2, dtype=np.int32)
+        expected = ufunc([True, True], True).astype(out.dtype)
+        assert_array_equal(ufunc(a, c, out=out), expected)
+        out = np.zeros((), dtype=np.int32)
+        assert ufunc.reduce(a, out=out) == True
+        # Last check, test reduction when out and a match (the complexity here
+        # is that the "i,i->?" may seem right, but should not match.
+        a = np.array([3], dtype="i")
+        out = np.zeros((), dtype=a.dtype)
+        assert ufunc.reduce(a, out=out) == 1
+
+    @pytest.mark.parametrize("ufunc",
+            [np.logical_and, np.logical_or, np.logical_xor])
+    def test_logical_ufuncs_reject_string(self, ufunc):
+        """
+        Logical ufuncs are normally well defined by working with the boolean
+        equivalent, i.e. casting all inputs to bools should work.
+
+        However, casting strings to bools is *currently* weird, because it
+        actually uses `bool(int(str))`.  Thus we explicitly reject strings.
+        This test should succeed (and can probably just be removed) as soon as
+        string to bool casts are well defined in NumPy.
+        """
+        with pytest.raises(TypeError, match="contain a loop with signature"):
+            ufunc(["1"], ["3"])
+        with pytest.raises(TypeError, match="contain a loop with signature"):
+            ufunc.reduce(["1", "2", "0"])
 
     @pytest.mark.parametrize("ufunc",
              [np.logical_and, np.logical_or, np.logical_xor])
@@ -2134,6 +2248,60 @@ def test_logical_ufuncs_out_cast_check(self, ufunc):
             # It would be safe, but not equiv casting:
             ufunc(a, c, out=out, casting="equiv")
 
+    def test_reducelike_byteorder_resolution(self):
+        # See gh-20699, byte-order changes need some extra care in the type
+        # resolution to make the following succeed:
+        arr_be = np.arange(10, dtype=">i8")
+        arr_le = np.arange(10, dtype=" 0 or use_initial:
+            assert _check_neg_zero(res)
+        else:
+            # `sum([])` should probably be 0.0 and not -0.0 like `sum([-0.0])`
+            assert not np.signbit(res.real)
+            assert not np.signbit(res.imag)
+
+class TestLowlevelAPIAccess:
+    def test_resolve_dtypes_basic(self):
+        # Basic test for dtype resolution:
+        i4 = np.dtype("i4")
+        f4 = np.dtype("f4")
+        f8 = np.dtype("f8")
+
+        r = np.add.resolve_dtypes((i4, f4, None))
+        assert r == (f8, f8, f8)
+
+        # Signature uses the same logic to parse as ufunc (less strict)
+        # the following is "same-kind" casting so works:
+        r = np.add.resolve_dtypes((
+                i4, i4, None), signature=(None, None, "f4"))
+        assert r == (f4, f4, f4)
+
+        # Check NEP 50 "weak" promotion also:
+        r = np.add.resolve_dtypes((f4, int, None))
+        assert r == (f4, f4, f4)
+
+        with pytest.raises(TypeError):
+            np.add.resolve_dtypes((i4, f4, None), casting="no")
+
+    def test_weird_dtypes(self):
+        S0 = np.dtype("S0")
+        # S0 is often converted by NumPy to S1, but not here:
+        r = np.equal.resolve_dtypes((S0, S0, None))
+        assert r == (S0, S0, np.dtype(bool))
+
+        # Subarray dtypes are weird and only really exist nested, they need
+        # the shift to full NEP 50 to be implemented nicely:
+        dts = np.dtype("10i")
+        with pytest.raises(NotImplementedError):
+            np.equal.resolve_dtypes((dts, dts, None))
+
+    def test_resolve_dtypes_reduction(self):
+        i4 = np.dtype("i4")
+        with pytest.raises(NotImplementedError):
+            np.add.resolve_dtypes((i4, i4, i4), reduction=True)
+
+    @pytest.mark.parametrize("dtypes", [
+            (np.dtype("i"), np.dtype("i")),
+            (None, np.dtype("i"), np.dtype("f")),
+            (np.dtype("i"), None, np.dtype("f")),
+            ("i4", "i4", None)])
+    def test_resolve_dtypes_errors(self, dtypes):
+        with pytest.raises(TypeError):
+            np.add.resolve_dtypes(dtypes)
+
+    def test_resolve_dtypes_reduction(self):
+        i2 = np.dtype("i2")
+        long_ = np.dtype("long")
+        # Check special addition resolution:
+        res = np.add.resolve_dtypes((None, i2, None), reduction=True)
+        assert res == (long_, long_, long_)
+
+    def test_resolve_dtypes_reduction_errors(self):
+        i2 = np.dtype("i2")
+
+        with pytest.raises(TypeError):
+            np.add.resolve_dtypes((None, i2, i2))
+
+        with pytest.raises(TypeError):
+            np.add.signature((None, None, "i4"))
+
+    @pytest.mark.skipif(not hasattr(ct, "pythonapi"),
+            reason="`ctypes.pythonapi` required for capsule unpacking.")
+    def test_loop_access(self):
+        # This is a basic test for the full strided loop access
+        data_t = ct.ARRAY(ct.c_char_p, 2)
+        dim_t = ct.ARRAY(ct.c_ssize_t, 1)
+        strides_t = ct.ARRAY(ct.c_ssize_t, 2)
+        strided_loop_t = ct.CFUNCTYPE(
+                ct.c_int, ct.c_void_p, data_t, dim_t, strides_t, ct.c_void_p)
+
+        class call_info_t(ct.Structure):
+            _fields_ = [
+                ("strided_loop", strided_loop_t),
+                ("context", ct.c_void_p),
+                ("auxdata", ct.c_void_p),
+                ("requires_pyapi", ct.c_byte),
+                ("no_floatingpoint_errors", ct.c_byte),
+            ]
+
+        i4 = np.dtype("i4")
+        dt, call_info_obj = np.negative._resolve_dtypes_and_context((i4, i4))
+        assert dt == (i4, i4)  # can be used without casting
+
+        # Fill in the rest of the information:
+        np.negative._get_strided_loop(call_info_obj)
+
+        ct.pythonapi.PyCapsule_GetPointer.restype = ct.c_void_p
+        call_info = ct.pythonapi.PyCapsule_GetPointer(
+                ct.py_object(call_info_obj),
+                ct.c_char_p(b"numpy_1.24_ufunc_call_info"))
+
+        call_info = ct.cast(call_info, ct.POINTER(call_info_t)).contents
+
+        arr = np.arange(10, dtype=i4)
+        call_info.strided_loop(
+                call_info.context,
+                data_t(arr.ctypes.data, arr.ctypes.data),
+                arr.ctypes.shape,  # is a C-array with 10 here
+                strides_t(arr.ctypes.strides[0], arr.ctypes.strides[0]),
+                call_info.auxdata)
+
+        # We just directly called the negative inner-loop in-place:
+        assert_array_equal(arr, -np.arange(10, dtype=i4))
+
+    @pytest.mark.parametrize("strides", [1, (1, 2, 3), (1, "2")])
+    def test__get_strided_loop_errors_bad_strides(self, strides):
+        i4 = np.dtype("i4")
+        dt, call_info = np.negative._resolve_dtypes_and_context((i4, i4))
+
+        with pytest.raises(TypeError, match="fixed_strides.*tuple.*or None"):
+            np.negative._get_strided_loop(call_info, fixed_strides=strides)
+
+    def test__get_strided_loop_errors_bad_call_info(self):
+        i4 = np.dtype("i4")
+        dt, call_info = np.negative._resolve_dtypes_and_context((i4, i4))
+
+        with pytest.raises(ValueError, match="PyCapsule"):
+            np.negative._get_strided_loop("not the capsule!")
+
+        with pytest.raises(TypeError, match=".*incompatible context"):
+            np.add._get_strided_loop(call_info)
+
+        np.negative._get_strided_loop(call_info)
+        with pytest.raises(TypeError):
+            # cannot call it a second time:
+            np.negative._get_strided_loop(call_info)
+
+    def test_long_arrays(self):
+        t = np.zeros((1029, 917), dtype=np.single)
+        t[0][0] = 1
+        t[28][414] = 1
+        tc = np.cos(t)
+        assert_equal(tc[0][0], tc[28][414])
diff --git a/numpy/core/tests/test_umath.py b/numpy/core/tests/test_umath.py
index fc7c592f05f6..03bed0aba615 100644
--- a/numpy/core/tests/test_umath.py
+++ b/numpy/core/tests/test_umath.py
@@ -5,8 +5,10 @@
 import pytest
 import sys
 import os
+import operator
 from fractions import Fraction
 from functools import reduce
+from collections import namedtuple
 
 import numpy.core.umath as ncu
 from numpy.core import _umath_tests as ncu_tests
@@ -15,20 +17,82 @@
     assert_, assert_equal, assert_raises, assert_raises_regex,
     assert_array_equal, assert_almost_equal, assert_array_almost_equal,
     assert_array_max_ulp, assert_allclose, assert_no_warnings, suppress_warnings,
-    _gen_alignment_data, assert_array_almost_equal_nulp
+    _gen_alignment_data, assert_array_almost_equal_nulp, IS_WASM
     )
+from numpy.testing._private.utils import _glibc_older_than
+
+UFUNCS = [obj for obj in np.core.umath.__dict__.values()
+         if isinstance(obj, np.ufunc)]
+
+UFUNCS_UNARY = [
+    uf for uf in UFUNCS if uf.nin == 1
+]
+UFUNCS_UNARY_FP = [
+    uf for uf in UFUNCS_UNARY if 'f->f' in uf.types
+]
+
+UFUNCS_BINARY = [
+    uf for uf in UFUNCS if uf.nin == 2
+]
+UFUNCS_BINARY_ACC = [
+    uf for uf in UFUNCS_BINARY if hasattr(uf, "accumulate") and uf.nout == 1
+]
+
+def interesting_binop_operands(val1, val2, dtype):
+    """
+    Helper to create "interesting" operands to cover common code paths:
+    * scalar inputs
+    * only first "values" is an array (e.g. scalar division fast-paths)
+    * Longer array (SIMD) placing the value of interest at different positions
+    * Oddly strided arrays which may not be SIMD compatible
+
+    It does not attempt to cover unaligned access or mixed dtypes.
+    These are normally handled by the casting/buffering machinery.
+
+    This is not a fixture (currently), since I believe a fixture normally
+    only yields once?
+    """
+    fill_value = 1  # could be a parameter, but maybe not an optional one?
+
+    arr1 = np.full(10003, dtype=dtype, fill_value=fill_value)
+    arr2 = np.full(10003, dtype=dtype, fill_value=fill_value)
+
+    arr1[0] = val1
+    arr2[0] = val2
+
+    extractor = lambda res: res
+    yield arr1[0], arr2[0], extractor, "scalars"
+
+    extractor = lambda res: res
+    yield arr1[0, ...], arr2[0, ...], extractor, "scalar-arrays"
+
+    # reset array values to fill_value:
+    arr1[0] = fill_value
+    arr2[0] = fill_value
+
+    for pos in [0, 1, 2, 3, 4, 5, -1, -2, -3, -4]:
+        arr1[pos] = val1
+        arr2[pos] = val2
+
+        extractor = lambda res: res[pos]
+        yield arr1, arr2, extractor, f"off-{pos}"
+        yield arr1, arr2[pos], extractor, f"off-{pos}-with-scalar"
 
-def get_glibc_version():
-    try:
-        ver = os.confstr('CS_GNU_LIBC_VERSION').rsplit(' ')[1]
-    except Exception as inst:
-        ver = '0.0'
+        arr1[pos] = fill_value
+        arr2[pos] = fill_value
 
-    return ver
+    for stride in [-1, 113]:
+        op1 = arr1[::stride]
+        op2 = arr2[::stride]
+        op1[10] = val1
+        op2[10] = val2
 
+        extractor = lambda res: res[10]
+        yield op1, op2, extractor, f"stride-{stride}"
+
+        op1[10] = fill_value
+        op2[10] = fill_value
 
-glibcver = get_glibc_version()
-glibc_older_than = lambda x: (glibcver != '0.0' and glibcver < x)
 
 def on_powerpc():
     """ True if we are running on a Power PC platform."""
@@ -37,12 +101,17 @@ def on_powerpc():
 
 
 def bad_arcsinh():
-    """The blocklisted trig functions are not accurate on aarch64 for
+    """The blocklisted trig functions are not accurate on aarch64/PPC for
     complex256. Rather than dig through the actual problem skip the
     test. This should be fixed when we can move past glibc2.17
     which is the version in manylinux2014
     """
-    x = 1.78e-10
+    if platform.machine() == 'aarch64':
+        x = 1.78e-10
+    elif on_powerpc():
+        x = 2.16e-10
+    else:
+        return False
     v1 = np.arcsinh(np.float128(x))
     v2 = np.arcsinh(np.complex256(x)).real
     # The eps for float128 is 1-e33, so this is way bigger
@@ -50,10 +119,10 @@ def bad_arcsinh():
 
 
 class _FilterInvalids:
-    def setup(self):
+    def setup_method(self):
         self.olderr = np.seterr(invalid='ignore')
 
-    def teardown(self):
+    def teardown_method(self):
         np.seterr(**self.olderr)
 
 
@@ -195,6 +264,52 @@ def __array_wrap__(self, arr, context):
 
 
 class TestComparisons:
+    import operator
+
+    @pytest.mark.parametrize('dtype', np.sctypes['uint'] + np.sctypes['int'] +
+                             np.sctypes['float'] + [np.bool_])
+    @pytest.mark.parametrize('py_comp,np_comp', [
+        (operator.lt, np.less),
+        (operator.le, np.less_equal),
+        (operator.gt, np.greater),
+        (operator.ge, np.greater_equal),
+        (operator.eq, np.equal),
+        (operator.ne, np.not_equal)
+    ])
+    def test_comparison_functions(self, dtype, py_comp, np_comp):
+        # Initialize input arrays
+        if dtype == np.bool_:
+            a = np.random.choice(a=[False, True], size=1000)
+            b = np.random.choice(a=[False, True], size=1000)
+            scalar = True
+        else:
+            a = np.random.randint(low=1, high=10, size=1000).astype(dtype)
+            b = np.random.randint(low=1, high=10, size=1000).astype(dtype)
+            scalar = 5
+        np_scalar = np.dtype(dtype).type(scalar)
+        a_lst = a.tolist()
+        b_lst = b.tolist()
+
+        # (Binary) Comparison (x1=array, x2=array)
+        comp_b = np_comp(a, b).view(np.uint8)
+        comp_b_list = [int(py_comp(x, y)) for x, y in zip(a_lst, b_lst)]
+
+        # (Scalar1) Comparison (x1=scalar, x2=array)
+        comp_s1 = np_comp(np_scalar, b).view(np.uint8)
+        comp_s1_list = [int(py_comp(scalar, x)) for x in b_lst]
+
+        # (Scalar2) Comparison (x1=array, x2=scalar)
+        comp_s2 = np_comp(a, np_scalar).view(np.uint8)
+        comp_s2_list = [int(py_comp(x, scalar)) for x in a_lst]
+
+        # Sequence: Binary, Scalar1 and Scalar2
+        assert_(comp_b.tolist() == comp_b_list,
+            f"Failed comparison ({py_comp.__name__})")
+        assert_(comp_s1.tolist() == comp_s1_list,
+            f"Failed comparison ({py_comp.__name__})")
+        assert_(comp_s2.tolist() == comp_s2_list,
+            f"Failed comparison ({py_comp.__name__})")
+
     def test_ignore_object_identity_in_equal(self):
         # Check comparing identical objects whose comparison
         # is not a simple boolean, e.g., arrays that are compared elementwise.
@@ -231,6 +346,29 @@ def __ne__(self, other):
         a = np.array([np.nan], dtype=object)
         assert_equal(np.not_equal(a, a), [True])
 
+    def test_error_in_equal_reduce(self):
+        # gh-20929
+        # make sure np.equal.reduce raises a TypeError if an array is passed
+        # without specifying the dtype
+        a = np.array([0, 0])
+        assert_equal(np.equal.reduce(a, dtype=bool), True)
+        assert_raises(TypeError, np.equal.reduce, a)
+
+    def test_object_dtype(self):
+        assert np.equal(1, [1], dtype=object).dtype == object
+        assert np.equal(1, [1], signature=(None, None, "O")).dtype == object
+
+    def test_object_nonbool_dtype_error(self):
+        # bool output dtype is fine of course:
+        assert np.equal(1, [1], dtype=bool).dtype == bool
+
+        # but the following are examples do not have a loop:
+        with pytest.raises(TypeError, match="No loop matching"):
+            np.equal(1, 1, dtype=np.int64)
+
+        with pytest.raises(TypeError, match="No loop matching"):
+            np.equal(1, 1, sig=(None, None, "l"))
+
 
 class TestAdd:
     def test_reduce_alignment(self):
@@ -255,28 +393,29 @@ def test_division_int(self):
         assert_equal(x // 100, [0, 0, 0, 1, -1, -1, -1, -1, -2])
         assert_equal(x % 100, [5, 10, 90, 0, 95, 90, 10, 0, 80])
 
+    @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm")
     @pytest.mark.parametrize("dtype,ex_val", itertools.product(
         np.sctypes['int'] + np.sctypes['uint'], (
             (
                 # dividend
-                "np.arange(fo.max-lsize, fo.max, dtype=dtype),"
+                "np.array(range(fo.max-lsize, fo.max)).astype(dtype),"
                 # divisors
-                "np.arange(lsize, dtype=dtype),"
+                "np.arange(lsize).astype(dtype),"
                 # scalar divisors
                 "range(15)"
             ),
             (
                 # dividend
-                "np.arange(fo.min, fo.min+lsize, dtype=dtype),"
+                "np.arange(fo.min, fo.min+lsize).astype(dtype),"
                 # divisors
-                "np.arange(lsize//-2, lsize//2, dtype=dtype),"
+                "np.arange(lsize//-2, lsize//2).astype(dtype),"
                 # scalar divisors
                 "range(fo.min, fo.min + 15)"
             ), (
                 # dividend
-                "np.arange(fo.max-lsize, fo.max, dtype=dtype),"
+                "np.array(range(fo.max-lsize, fo.max)).astype(dtype),"
                 # divisors
-                "np.arange(lsize, dtype=dtype),"
+                "np.arange(lsize).astype(dtype),"
                 # scalar divisors
                 "[1,3,9,13,neg, fo.min+1, fo.min//2, fo.max//3, fo.max//4]"
             )
@@ -291,7 +430,9 @@ def test_division_int_boundary(self, dtype, ex_val):
         a_lst, b_lst = a.tolist(), b.tolist()
 
         c_div = lambda n, d: (
-            0 if d == 0 or (n and n == fo.min and d == -1) else n//d
+            0 if d == 0 else (
+                fo.min if (n and n == fo.min and d == -1) else n//d
+            )
         )
         with np.errstate(divide='ignore'):
             ac = a.copy()
@@ -306,7 +447,7 @@ def test_division_int_boundary(self, dtype, ex_val):
 
         for divisor in divisors:
             ac = a.copy()
-            with np.errstate(divide='ignore'):
+            with np.errstate(divide='ignore', over='ignore'):
                 div_a = a // divisor
                 ac //= divisor
             div_lst = [c_div(i, divisor) for i in a_lst]
@@ -314,32 +455,37 @@ def test_division_int_boundary(self, dtype, ex_val):
             assert all(div_a == div_lst), msg
             assert all(ac == div_lst), msg_eq
 
-        with np.errstate(divide='raise'):
-            if 0 in b or (fo.min and -1 in b and fo.min in a):
+        with np.errstate(divide='raise', over='raise'):
+            if 0 in b:
                 # Verify overflow case
-                with pytest.raises(FloatingPointError):
+                with pytest.raises(FloatingPointError,
+                        match="divide by zero encountered in floor_divide"):
                     a // b
             else:
                 a // b
             if fo.min and fo.min in a:
-                with pytest.raises(FloatingPointError):
+                with pytest.raises(FloatingPointError,
+                        match='overflow encountered in floor_divide'):
                     a // -1
             elif fo.min:
                 a // -1
-            with pytest.raises(FloatingPointError):
+            with pytest.raises(FloatingPointError,
+                    match="divide by zero encountered in floor_divide"):
                 a // 0
-            with pytest.raises(FloatingPointError):
+            with pytest.raises(FloatingPointError,
+                    match="divide by zero encountered in floor_divide"):
                 ac = a.copy()
                 ac //= 0
 
             np.array([], dtype=dtype) // 0
 
+    @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm")
     @pytest.mark.parametrize("dtype,ex_val", itertools.product(
         np.sctypes['int'] + np.sctypes['uint'], (
             "np.array([fo.max, 1, 2, 1, 1, 2, 3], dtype=dtype)",
-            "np.array([fo.min, 1, -2, 1, 1, 2, -3], dtype=dtype)",
+            "np.array([fo.min, 1, -2, 1, 1, 2, -3]).astype(dtype)",
             "np.arange(fo.min, fo.min+(100*10), 10, dtype=dtype)",
-            "np.arange(fo.max-(100*7), fo.max, 7, dtype=dtype)",
+            "np.array(range(fo.max-(100*7), fo.max, 7)).astype(dtype)",
         )
     ))
     def test_division_int_reduce(self, dtype, ex_val):
@@ -356,11 +502,13 @@ def test_division_int_reduce(self, dtype, ex_val):
         msg = "Reduce floor integer division check"
         assert div_a == div_lst, msg
 
-        with np.errstate(divide='raise'):
-            with pytest.raises(FloatingPointError):
-                np.floor_divide.reduce(np.arange(-100, 100, dtype=dtype))
+        with np.errstate(divide='raise', over='raise'):
+            with pytest.raises(FloatingPointError,
+                    match="divide by zero encountered in reduce"):
+                np.floor_divide.reduce(np.arange(-100, 100).astype(dtype))
             if fo.min:
-                with pytest.raises(FloatingPointError):
+                with pytest.raises(FloatingPointError,
+                        match='overflow encountered in reduce'):
                     np.floor_divide.reduce(
                         np.array([fo.min, 1, -1], dtype=dtype)
                     )
@@ -393,6 +541,8 @@ def test_division_int_timedelta(self, dividend, divisor, quotient):
             quotient_array = np.array([quotient]*5)
             assert all(dividend_array // divisor == quotient_array), msg
         else:
+            if IS_WASM:
+                pytest.skip("fp errors don't work in wasm")
             with np.errstate(divide='raise', invalid='raise'):
                 with pytest.raises(FloatingPointError):
                     dividend // divisor
@@ -439,6 +589,7 @@ def test_floor_division_signed_zero(self):
         assert_equal(np.signbit(x//1), 0)
         assert_equal(np.signbit((-x)//1), 1)
 
+    @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm")
     @pytest.mark.parametrize('dtype', np.typecodes['Float'])
     def test_floor_division_errors(self, dtype):
         fnan = np.array(np.nan, dtype=dtype)
@@ -553,6 +704,7 @@ def test_float_remainder_roundoff(self):
                     else:
                         assert_(b > rem >= 0, msg)
 
+    @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm")
     @pytest.mark.xfail(sys.platform.startswith("darwin"),
             reason="MacOS seems to not give the correct 'invalid' warning for "
                    "`fmod`.  Hopefully, others always do.")
@@ -579,6 +731,7 @@ def test_float_divmod_errors(self, dtype):
             # inf / 0 does not set any flags, only the modulo creates a NaN
             np.divmod(finf, fzero)
 
+    @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm")
     @pytest.mark.xfail(sys.platform.startswith("darwin"),
            reason="MacOS seems to not give the correct 'invalid' warning for "
                   "`fmod`.  Hopefully, others always do.")
@@ -600,6 +753,7 @@ def test_float_remainder_errors(self, dtype, fn):
             fn(fone, fnan)
             fn(fnan, fone)
 
+    @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm")
     def test_float_remainder_overflow(self):
         a = np.finfo(np.float64).tiny
         with np.errstate(over='ignore', invalid='ignore'):
@@ -696,6 +850,143 @@ def test_float_remainder_corner_cases(self):
                 assert_(np.isnan(fmod), 'dt: %s, fmod: %s' % (dt, rem))
 
 
+class TestDivisionIntegerOverflowsAndDivideByZero:
+    result_type = namedtuple('result_type',
+            ['nocast', 'casted'])
+    helper_lambdas = {
+        'zero': lambda dtype: 0,
+        'min': lambda dtype: np.iinfo(dtype).min,
+        'neg_min': lambda dtype: -np.iinfo(dtype).min,
+        'min-zero': lambda dtype: (np.iinfo(dtype).min, 0),
+        'neg_min-zero': lambda dtype: (-np.iinfo(dtype).min, 0),
+    }
+    overflow_results = {
+        np.remainder: result_type(
+            helper_lambdas['zero'], helper_lambdas['zero']),
+        np.fmod: result_type(
+            helper_lambdas['zero'], helper_lambdas['zero']),
+        operator.mod: result_type(
+            helper_lambdas['zero'], helper_lambdas['zero']),
+        operator.floordiv: result_type(
+            helper_lambdas['min'], helper_lambdas['neg_min']),
+        np.floor_divide: result_type(
+            helper_lambdas['min'], helper_lambdas['neg_min']),
+        np.divmod: result_type(
+            helper_lambdas['min-zero'], helper_lambdas['neg_min-zero'])
+    }
+
+    @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm")
+    @pytest.mark.parametrize("dtype", np.typecodes["Integer"])
+    def test_signed_division_overflow(self, dtype):
+        to_check = interesting_binop_operands(np.iinfo(dtype).min, -1, dtype)
+        for op1, op2, extractor, operand_identifier in to_check:
+            with pytest.warns(RuntimeWarning, match="overflow encountered"):
+                res = op1 // op2
+
+            assert res.dtype == op1.dtype
+            assert extractor(res) == np.iinfo(op1.dtype).min
+
+            # Remainder is well defined though, and does not warn:
+            res = op1 % op2
+            assert res.dtype == op1.dtype
+            assert extractor(res) == 0
+            # Check fmod as well:
+            res = np.fmod(op1, op2)
+            assert extractor(res) == 0
+
+            # Divmod warns for the division part:
+            with pytest.warns(RuntimeWarning, match="overflow encountered"):
+                res1, res2 = np.divmod(op1, op2)
+
+            assert res1.dtype == res2.dtype == op1.dtype
+            assert extractor(res1) == np.iinfo(op1.dtype).min
+            assert extractor(res2) == 0
+
+    @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm")
+    @pytest.mark.parametrize("dtype", np.typecodes["AllInteger"])
+    def test_divide_by_zero(self, dtype):
+        # Note that the return value cannot be well defined here, but NumPy
+        # currently uses 0 consistently.  This could be changed.
+        to_check = interesting_binop_operands(1, 0, dtype)
+        for op1, op2, extractor, operand_identifier in to_check:
+            with pytest.warns(RuntimeWarning, match="divide by zero"):
+                res = op1 // op2
+
+            assert res.dtype == op1.dtype
+            assert extractor(res) == 0
+
+            with pytest.warns(RuntimeWarning, match="divide by zero"):
+                res1, res2 = np.divmod(op1, op2)
+
+            assert res1.dtype == res2.dtype == op1.dtype
+            assert extractor(res1) == 0
+            assert extractor(res2) == 0
+
+    @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm")
+    @pytest.mark.parametrize("dividend_dtype",
+            np.sctypes['int'])
+    @pytest.mark.parametrize("divisor_dtype",
+            np.sctypes['int'])
+    @pytest.mark.parametrize("operation",
+            [np.remainder, np.fmod, np.divmod, np.floor_divide,
+             operator.mod, operator.floordiv])
+    @np.errstate(divide='warn', over='warn')
+    def test_overflows(self, dividend_dtype, divisor_dtype, operation):
+        # SIMD tries to perform the operation on as many elements as possible
+        # that is a multiple of the register's size. We resort to the
+        # default implementation for the leftover elements.
+        # We try to cover all paths here.
+        arrays = [np.array([np.iinfo(dividend_dtype).min]*i,
+                           dtype=dividend_dtype) for i in range(1, 129)]
+        divisor = np.array([-1], dtype=divisor_dtype)
+        # If dividend is a larger type than the divisor (`else` case),
+        # then, result will be a larger type than dividend and will not
+        # result in an overflow for `divmod` and `floor_divide`.
+        if np.dtype(dividend_dtype).itemsize >= np.dtype(
+                divisor_dtype).itemsize and operation in (
+                        np.divmod, np.floor_divide, operator.floordiv):
+            with pytest.warns(
+                    RuntimeWarning,
+                    match="overflow encountered in"):
+                result = operation(
+                            dividend_dtype(np.iinfo(dividend_dtype).min),
+                            divisor_dtype(-1)
+                        )
+                assert result == self.overflow_results[operation].nocast(
+                        dividend_dtype)
+
+            # Arrays
+            for a in arrays:
+                # In case of divmod, we need to flatten the result
+                # column first as we get a column vector of quotient and
+                # remainder and a normal flatten of the expected result.
+                with pytest.warns(
+                        RuntimeWarning,
+                        match="overflow encountered in"):
+                    result = np.array(operation(a, divisor)).flatten('f')
+                    expected_array = np.array(
+                            [self.overflow_results[operation].nocast(
+                                dividend_dtype)]*len(a)).flatten()
+                    assert_array_equal(result, expected_array)
+        else:
+            # Scalars
+            result = operation(
+                        dividend_dtype(np.iinfo(dividend_dtype).min),
+                        divisor_dtype(-1)
+                    )
+            assert result == self.overflow_results[operation].casted(
+                    dividend_dtype)
+
+            # Arrays
+            for a in arrays:
+                # See above comment on flatten
+                result = np.array(operation(a, divisor)).flatten('f')
+                expected_array = np.array(
+                        [self.overflow_results[operation].casted(
+                            dividend_dtype)]*len(a)).flatten()
+                assert_array_equal(result, expected_array)
+
+
 class TestCbrt:
     def test_cbrt_scalar(self):
         assert_almost_equal((np.cbrt(np.float32(-2.5)**3)), -2.5)
@@ -847,6 +1138,14 @@ def test_integer_to_negative_power(self):
             assert_raises(ValueError, np.power, one, b)
             assert_raises(ValueError, np.power, one, minusone)
 
+    def test_float_to_inf_power(self):
+        for dt in [np.float32, np.float64]:
+            a = np.array([1, 1, 2, 2, -2, -2, np.inf, -np.inf], dt)
+            b = np.array([np.inf, -np.inf, np.inf, -np.inf,
+                                np.inf, -np.inf, np.inf, -np.inf], dt)
+            r = np.array([1, 1, np.inf, 0, np.inf, 0, np.inf, 0], dt)
+            assert_equal(np.power(a, b), r)
+
 
 class TestFloat_power:
     def test_type_conversion(self):
@@ -875,6 +1174,7 @@ def test_log2_ints(self, i):
         v = np.log2(2.**i)
         assert_equal(v, float(i), err_msg='at exponent %d' % i)
 
+    @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm")
     def test_log2_special(self):
         assert_equal(np.log2(1.), 0.)
         assert_equal(np.log2(np.inf), np.inf)
@@ -1005,37 +1305,41 @@ def test_exp_strides(self):
 
 class TestSpecialFloats:
     def test_exp_values(self):
-        x = [np.nan,  np.nan, np.inf, 0.]
-        y = [np.nan, -np.nan, np.inf, -np.inf]
-        for dt in ['f', 'd', 'g']:
-            xf = np.array(x, dtype=dt)
-            yf = np.array(y, dtype=dt)
-            assert_equal(np.exp(yf), xf)
+        with np.errstate(under='raise', over='raise'):
+            x = [np.nan,  np.nan, np.inf, 0.]
+            y = [np.nan, -np.nan, np.inf, -np.inf]
+            for dt in ['e', 'f', 'd', 'g']:
+                xf = np.array(x, dtype=dt)
+                yf = np.array(y, dtype=dt)
+                assert_equal(np.exp(yf), xf)
 
     # See: https://github.com/numpy/numpy/issues/19192
     @pytest.mark.xfail(
-        glibc_older_than("2.17"),
+        _glibc_older_than("2.17"),
         reason="Older glibc versions may not raise appropriate FP exceptions"
     )
     def test_exp_exceptions(self):
         with np.errstate(over='raise'):
+            assert_raises(FloatingPointError, np.exp, np.float16(11.0899))
             assert_raises(FloatingPointError, np.exp, np.float32(100.))
             assert_raises(FloatingPointError, np.exp, np.float32(1E19))
             assert_raises(FloatingPointError, np.exp, np.float64(800.))
             assert_raises(FloatingPointError, np.exp, np.float64(1E19))
 
         with np.errstate(under='raise'):
+            assert_raises(FloatingPointError, np.exp, np.float16(-17.5))
             assert_raises(FloatingPointError, np.exp, np.float32(-1000.))
             assert_raises(FloatingPointError, np.exp, np.float32(-1E19))
             assert_raises(FloatingPointError, np.exp, np.float64(-1000.))
             assert_raises(FloatingPointError, np.exp, np.float64(-1E19))
 
+    @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm")
     def test_log_values(self):
         with np.errstate(all='ignore'):
             x = [np.nan, np.nan, np.inf, np.nan, -np.inf, np.nan]
             y = [np.nan, -np.nan, np.inf, -np.inf, 0.0, -1.0]
             y1p = [np.nan, -np.nan, np.inf, -np.inf, -1.0, -2.0]
-            for dt in ['f', 'd', 'g']:
+            for dt in ['e', 'f', 'd', 'g']:
                 xf = np.array(x, dtype=dt)
                 yf = np.array(y, dtype=dt)
                 yf1p = np.array(y1p, dtype=dt)
@@ -1045,7 +1349,7 @@ def test_log_values(self):
                 assert_equal(np.log1p(yf1p), xf)
 
         with np.errstate(divide='raise'):
-            for dt in ['f', 'd']:
+            for dt in ['e', 'f', 'd']:
                 assert_raises(FloatingPointError, np.log,
                               np.array(0.0, dtype=dt))
                 assert_raises(FloatingPointError, np.log2,
@@ -1056,7 +1360,7 @@ def test_log_values(self):
                               np.array(-1.0, dtype=dt))
 
         with np.errstate(invalid='raise'):
-            for dt in ['f', 'd']:
+            for dt in ['e', 'f', 'd']:
                 assert_raises(FloatingPointError, np.log,
                               np.array(-np.inf, dtype=dt))
                 assert_raises(FloatingPointError, np.log,
@@ -1079,23 +1383,26 @@ def test_log_values(self):
             a = np.array(1e9, dtype='float32')
             np.log(a)
 
+    @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm")
     def test_sincos_values(self):
         with np.errstate(all='ignore'):
             x = [np.nan, np.nan, np.nan, np.nan]
             y = [np.nan, -np.nan, np.inf, -np.inf]
-            for dt in ['f', 'd', 'g']:
+            for dt in ['e', 'f', 'd', 'g']:
                 xf = np.array(x, dtype=dt)
                 yf = np.array(y, dtype=dt)
                 assert_equal(np.sin(yf), xf)
                 assert_equal(np.cos(yf), xf)
 
+
         with np.errstate(invalid='raise'):
-            assert_raises(FloatingPointError, np.sin, np.float32(-np.inf))
-            assert_raises(FloatingPointError, np.sin, np.float32(np.inf))
-            assert_raises(FloatingPointError, np.cos, np.float32(-np.inf))
-            assert_raises(FloatingPointError, np.cos, np.float32(np.inf))
+            for callable in [np.sin, np.cos]:
+                for value in [np.inf, -np.inf]:
+                    for dt in ['e', 'f', 'd']:
+                        assert_raises(FloatingPointError, callable,
+                                np.array([value], dtype=dt))
 
-    @pytest.mark.parametrize('dt', ['f', 'd', 'g'])
+    @pytest.mark.parametrize('dt', ['e', 'f', 'd', 'g'])
     def test_sqrt_values(self, dt):
         with np.errstate(all='ignore'):
             x = [np.nan, np.nan, np.inf, np.nan, 0.]
@@ -1112,61 +1419,67 @@ def test_sqrt_values(self, dt):
     def test_abs_values(self):
         x = [np.nan,  np.nan, np.inf, np.inf, 0., 0., 1.0, 1.0]
         y = [np.nan, -np.nan, np.inf, -np.inf, 0., -0., -1.0, 1.0]
-        for dt in ['f', 'd', 'g']:
+        for dt in ['e', 'f', 'd', 'g']:
             xf = np.array(x, dtype=dt)
             yf = np.array(y, dtype=dt)
             assert_equal(np.abs(yf), xf)
 
+    @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm")
     def test_square_values(self):
         x = [np.nan,  np.nan, np.inf, np.inf]
         y = [np.nan, -np.nan, np.inf, -np.inf]
         with np.errstate(all='ignore'):
-            for dt in ['f', 'd', 'g']:
+            for dt in ['e', 'f', 'd', 'g']:
                 xf = np.array(x, dtype=dt)
                 yf = np.array(y, dtype=dt)
                 assert_equal(np.square(yf), xf)
 
         with np.errstate(over='raise'):
+            assert_raises(FloatingPointError, np.square,
+                          np.array(1E3, dtype='e'))
             assert_raises(FloatingPointError, np.square,
                           np.array(1E32, dtype='f'))
             assert_raises(FloatingPointError, np.square,
                           np.array(1E200, dtype='d'))
 
+    @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm")
     def test_reciprocal_values(self):
         with np.errstate(all='ignore'):
             x = [np.nan,  np.nan, 0.0, -0.0, np.inf, -np.inf]
             y = [np.nan, -np.nan, np.inf, -np.inf, 0., -0.]
-            for dt in ['f', 'd', 'g']:
+            for dt in ['e', 'f', 'd', 'g']:
                 xf = np.array(x, dtype=dt)
                 yf = np.array(y, dtype=dt)
                 assert_equal(np.reciprocal(yf), xf)
 
         with np.errstate(divide='raise'):
-            for dt in ['f', 'd', 'g']:
+            for dt in ['e', 'f', 'd', 'g']:
                 assert_raises(FloatingPointError, np.reciprocal,
                               np.array(-0.0, dtype=dt))
 
+    @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm")
     def test_tan(self):
         with np.errstate(all='ignore'):
             in_ = [np.nan, -np.nan, 0.0, -0.0, np.inf, -np.inf]
             out = [np.nan, np.nan, 0.0, -0.0, np.nan, np.nan]
-            for dt in ['f', 'd']:
+            for dt in ['e', 'f', 'd']:
                 in_arr = np.array(in_, dtype=dt)
                 out_arr = np.array(out, dtype=dt)
                 assert_equal(np.tan(in_arr), out_arr)
 
         with np.errstate(invalid='raise'):
-            for dt in ['f', 'd']:
+            for dt in ['e', 'f', 'd']:
                 assert_raises(FloatingPointError, np.tan,
                               np.array(np.inf, dtype=dt))
                 assert_raises(FloatingPointError, np.tan,
                               np.array(-np.inf, dtype=dt))
 
+    @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm")
     def test_arcsincos(self):
         with np.errstate(all='ignore'):
             in_ = [np.nan, -np.nan, np.inf, -np.inf]
             out = [np.nan, np.nan, np.nan, np.nan]
-            for dt in ['f', 'd']:
+            for dt in ['e', 'f', 'd']:
                 in_arr = np.array(in_, dtype=dt)
                 out_arr = np.array(out, dtype=dt)
                 assert_equal(np.arcsin(in_arr), out_arr)
@@ -1174,7 +1487,7 @@ def test_arcsincos(self):
 
         for callable in [np.arcsin, np.arccos]:
             for value in [np.inf, -np.inf, 2.0, -2.0]:
-                for dt in ['f', 'd']:
+                for dt in ['e', 'f', 'd']:
                     with np.errstate(invalid='raise'):
                         assert_raises(FloatingPointError, callable,
                                       np.array(value, dtype=dt))
@@ -1183,34 +1496,40 @@ def test_arctan(self):
         with np.errstate(all='ignore'):
             in_ = [np.nan, -np.nan]
             out = [np.nan, np.nan]
-            for dt in ['f', 'd']:
+            for dt in ['e', 'f', 'd']:
                 in_arr = np.array(in_, dtype=dt)
                 out_arr = np.array(out, dtype=dt)
                 assert_equal(np.arctan(in_arr), out_arr)
 
+    @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm")
     def test_sinh(self):
         in_ = [np.nan, -np.nan, np.inf, -np.inf]
         out = [np.nan, np.nan, np.inf, -np.inf]
-        for dt in ['f', 'd']:
+        for dt in ['e', 'f', 'd']:
             in_arr = np.array(in_, dtype=dt)
             out_arr = np.array(out, dtype=dt)
             assert_equal(np.sinh(in_arr), out_arr)
 
         with np.errstate(over='raise'):
+            assert_raises(FloatingPointError, np.sinh,
+                          np.array(12.0, dtype='e'))
             assert_raises(FloatingPointError, np.sinh,
                           np.array(120.0, dtype='f'))
             assert_raises(FloatingPointError, np.sinh,
                           np.array(1200.0, dtype='d'))
 
+    @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm")
     def test_cosh(self):
         in_ = [np.nan, -np.nan, np.inf, -np.inf]
         out = [np.nan, np.nan, np.inf, np.inf]
-        for dt in ['f', 'd']:
+        for dt in ['e', 'f', 'd']:
             in_arr = np.array(in_, dtype=dt)
             out_arr = np.array(out, dtype=dt)
             assert_equal(np.cosh(in_arr), out_arr)
 
         with np.errstate(over='raise'):
+            assert_raises(FloatingPointError, np.cosh,
+                          np.array(12.0, dtype='e'))
             assert_raises(FloatingPointError, np.cosh,
                           np.array(120.0, dtype='f'))
             assert_raises(FloatingPointError, np.cosh,
@@ -1219,7 +1538,7 @@ def test_cosh(self):
     def test_tanh(self):
         in_ = [np.nan, -np.nan, np.inf, -np.inf]
         out = [np.nan, np.nan, 1.0, -1.0]
-        for dt in ['f', 'd']:
+        for dt in ['e', 'f', 'd']:
             in_arr = np.array(in_, dtype=dt)
             out_arr = np.array(out, dtype=dt)
             assert_equal(np.tanh(in_arr), out_arr)
@@ -1227,69 +1546,148 @@ def test_tanh(self):
     def test_arcsinh(self):
         in_ = [np.nan, -np.nan, np.inf, -np.inf]
         out = [np.nan, np.nan, np.inf, -np.inf]
-        for dt in ['f', 'd']:
+        for dt in ['e', 'f', 'd']:
             in_arr = np.array(in_, dtype=dt)
             out_arr = np.array(out, dtype=dt)
             assert_equal(np.arcsinh(in_arr), out_arr)
 
+    @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm")
     def test_arccosh(self):
         with np.errstate(all='ignore'):
             in_ = [np.nan, -np.nan, np.inf, -np.inf, 1.0, 0.0]
             out = [np.nan, np.nan, np.inf, np.nan, 0.0, np.nan]
-            for dt in ['f', 'd']:
+            for dt in ['e', 'f', 'd']:
                 in_arr = np.array(in_, dtype=dt)
                 out_arr = np.array(out, dtype=dt)
                 assert_equal(np.arccosh(in_arr), out_arr)
 
         for value in [0.0, -np.inf]:
             with np.errstate(invalid='raise'):
-                for dt in ['f', 'd']:
+                for dt in ['e', 'f', 'd']:
                     assert_raises(FloatingPointError, np.arccosh,
                                   np.array(value, dtype=dt))
 
+    @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm")
     def test_arctanh(self):
         with np.errstate(all='ignore'):
             in_ = [np.nan, -np.nan, np.inf, -np.inf, 1.0, -1.0, 2.0]
             out = [np.nan, np.nan, np.nan, np.nan, np.inf, -np.inf, np.nan]
-            for dt in ['f', 'd']:
+            for dt in ['e', 'f', 'd']:
                 in_arr = np.array(in_, dtype=dt)
                 out_arr = np.array(out, dtype=dt)
                 assert_equal(np.arctanh(in_arr), out_arr)
 
         for value in [1.01, np.inf, -np.inf, 1.0, -1.0]:
             with np.errstate(invalid='raise', divide='raise'):
-                for dt in ['f', 'd']:
+                for dt in ['e', 'f', 'd']:
                     assert_raises(FloatingPointError, np.arctanh,
                                   np.array(value, dtype=dt))
 
+    # See: https://github.com/numpy/numpy/issues/20448
+    @pytest.mark.xfail(
+        _glibc_older_than("2.17"),
+        reason="Older glibc versions may not raise appropriate FP exceptions"
+    )
     def test_exp2(self):
         with np.errstate(all='ignore'):
             in_ = [np.nan, -np.nan, np.inf, -np.inf]
             out = [np.nan, np.nan, np.inf, 0.0]
-            for dt in ['f', 'd']:
+            for dt in ['e', 'f', 'd']:
                 in_arr = np.array(in_, dtype=dt)
                 out_arr = np.array(out, dtype=dt)
                 assert_equal(np.exp2(in_arr), out_arr)
 
         for value in [2000.0, -2000.0]:
             with np.errstate(over='raise', under='raise'):
-                for dt in ['f', 'd']:
+                for dt in ['e', 'f', 'd']:
                     assert_raises(FloatingPointError, np.exp2,
                                   np.array(value, dtype=dt))
 
+    @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm")
     def test_expm1(self):
         with np.errstate(all='ignore'):
             in_ = [np.nan, -np.nan, np.inf, -np.inf]
             out = [np.nan, np.nan, np.inf, -1.0]
-            for dt in ['f', 'd']:
+            for dt in ['e', 'f', 'd']:
                 in_arr = np.array(in_, dtype=dt)
                 out_arr = np.array(out, dtype=dt)
                 assert_equal(np.expm1(in_arr), out_arr)
 
         for value in [200.0, 2000.0]:
             with np.errstate(over='raise'):
-                assert_raises(FloatingPointError, np.expm1,
-                              np.array(value, dtype='f'))
+                for dt in ['e', 'f']:
+                    assert_raises(FloatingPointError, np.expm1,
+                                  np.array(value, dtype=dt))
+
+    # test to ensure no spurious FP exceptions are raised due to SIMD
+    INF_INVALID_ERR = [
+        np.cos, np.sin, np.tan, np.arccos, np.arcsin, np.spacing, np.arctanh
+    ]
+    NEG_INVALID_ERR = [
+        np.log, np.log2, np.log10, np.log1p, np.sqrt, np.arccosh,
+        np.arctanh
+    ]
+    ONE_INVALID_ERR = [
+        np.arctanh,
+    ]
+    LTONE_INVALID_ERR = [
+        np.arccosh,
+    ]
+    BYZERO_ERR = [
+        np.log, np.log2, np.log10, np.reciprocal, np.arccosh
+    ]
+
+    @pytest.mark.parametrize("ufunc", UFUNCS_UNARY_FP)
+    @pytest.mark.parametrize("dtype", ('e', 'f', 'd'))
+    @pytest.mark.parametrize("data, escape", (
+        ([0.03], LTONE_INVALID_ERR),
+        ([0.03]*32, LTONE_INVALID_ERR),
+        # neg
+        ([-1.0], NEG_INVALID_ERR),
+        ([-1.0]*32, NEG_INVALID_ERR),
+        # flat
+        ([1.0], ONE_INVALID_ERR),
+        ([1.0]*32, ONE_INVALID_ERR),
+        # zero
+        ([0.0], BYZERO_ERR),
+        ([0.0]*32, BYZERO_ERR),
+        ([-0.0], BYZERO_ERR),
+        ([-0.0]*32, BYZERO_ERR),
+        # nan
+        ([0.5, 0.5, 0.5, np.nan], LTONE_INVALID_ERR),
+        ([0.5, 0.5, 0.5, np.nan]*32, LTONE_INVALID_ERR),
+        ([np.nan, 1.0, 1.0, 1.0], ONE_INVALID_ERR),
+        ([np.nan, 1.0, 1.0, 1.0]*32, ONE_INVALID_ERR),
+        ([np.nan], []),
+        ([np.nan]*32, []),
+        # inf
+        ([0.5, 0.5, 0.5, np.inf], INF_INVALID_ERR + LTONE_INVALID_ERR),
+        ([0.5, 0.5, 0.5, np.inf]*32, INF_INVALID_ERR + LTONE_INVALID_ERR),
+        ([np.inf, 1.0, 1.0, 1.0], INF_INVALID_ERR),
+        ([np.inf, 1.0, 1.0, 1.0]*32, INF_INVALID_ERR),
+        ([np.inf], INF_INVALID_ERR),
+        ([np.inf]*32, INF_INVALID_ERR),
+        # ninf
+        ([0.5, 0.5, 0.5, -np.inf],
+         NEG_INVALID_ERR + INF_INVALID_ERR + LTONE_INVALID_ERR),
+        ([0.5, 0.5, 0.5, -np.inf]*32,
+         NEG_INVALID_ERR + INF_INVALID_ERR + LTONE_INVALID_ERR),
+        ([-np.inf, 1.0, 1.0, 1.0], NEG_INVALID_ERR + INF_INVALID_ERR),
+        ([-np.inf, 1.0, 1.0, 1.0]*32, NEG_INVALID_ERR + INF_INVALID_ERR),
+        ([-np.inf], NEG_INVALID_ERR + INF_INVALID_ERR),
+        ([-np.inf]*32, NEG_INVALID_ERR + INF_INVALID_ERR),
+    ))
+    def test_unary_spurious_fpexception(self, ufunc, dtype, data, escape):
+        if escape and ufunc in escape:
+            return
+        # FIXME: NAN raises FP invalid exception:
+        #  - ceil/float16 on MSVC:32-bit
+        #  - spacing/float16 on almost all platforms
+        if ufunc in (np.spacing, np.ceil) and dtype == 'e':
+            return
+        array = np.array(data, dtype=dtype)
+        with assert_no_warnings():
+            ufunc(array)
 
 class TestFPClass:
     @pytest.mark.parametrize("stride", [-4,-2,-1,1,2,4])
@@ -1397,7 +1795,7 @@ def test_sincos_float32(self):
         M = np.int_(N/20)
         index = np.random.randint(low=0, high=N, size=M)
         x_f32 = np.float32(np.random.uniform(low=-100.,high=100.,size=N))
-        if not glibc_older_than("2.17"):
+        if not _glibc_older_than("2.17"):
             # test coverage for elements > 117435.992f for which glibc is used
             # this is known to be problematic on old glibc, so skip it there
             x_f32[index] = np.float32(10E+10*np.random.rand(M))
@@ -1733,6 +2131,27 @@ def test_strided_array(self):
         assert_equal(np.maximum(arr1[:6:2], arr2[::3], out=out[::3]), np.array([-2.0, 10., np.nan]))
         assert_equal(out, out_maxtrue)
 
+    def test_precision(self):
+        dtypes = [np.float16, np.float32, np.float64, np.longdouble]
+
+        for dt in dtypes:
+            dtmin = np.finfo(dt).min
+            dtmax = np.finfo(dt).max
+            d1 = dt(0.1)
+            d1_next = np.nextafter(d1, np.inf)
+
+            test_cases = [
+                # v1    v2          expected
+                (dtmin, -np.inf,    dtmin),
+                (dtmax, -np.inf,    dtmax),
+                (d1,    d1_next,    d1_next),
+                (dtmax, np.nan,     np.nan),
+            ]
+
+            for v1, v2, expected in test_cases:
+                assert_equal(np.maximum([v1], [v2]), [expected])
+                assert_equal(np.maximum.reduce([v1, v2]), expected)
+
 
 class TestMinimum(_FilterInvalids):
     def test_reduce(self):
@@ -1804,6 +2223,28 @@ def test_strided_array(self):
         assert_equal(np.minimum(arr1[:6:2], arr2[::3], out=out[::3]), np.array([-4.0, 1.0, np.nan]))
         assert_equal(out, out_mintrue)
 
+    def test_precision(self):
+        dtypes = [np.float16, np.float32, np.float64, np.longdouble]
+
+        for dt in dtypes:
+            dtmin = np.finfo(dt).min
+            dtmax = np.finfo(dt).max
+            d1 = dt(0.1)
+            d1_next = np.nextafter(d1, np.inf)
+
+            test_cases = [
+                # v1    v2          expected
+                (dtmin, np.inf,     dtmin),
+                (dtmax, np.inf,     dtmax),
+                (d1,    d1_next,    d1),
+                (dtmin, np.nan,     np.nan),
+            ]
+
+            for v1, v2, expected in test_cases:
+                assert_equal(np.minimum([v1], [v2]), [expected])
+                assert_equal(np.minimum.reduce([v1, v2]), expected)
+
+
 class TestFmax(_FilterInvalids):
     def test_reduce(self):
         dflt = np.typecodes['AllFloat']
@@ -1845,6 +2286,27 @@ def test_complex_nans(self):
             out = np.array([0,    0, nan], dtype=complex)
             assert_equal(np.fmax(arg1, arg2), out)
 
+    def test_precision(self):
+        dtypes = [np.float16, np.float32, np.float64, np.longdouble]
+
+        for dt in dtypes:
+            dtmin = np.finfo(dt).min
+            dtmax = np.finfo(dt).max
+            d1 = dt(0.1)
+            d1_next = np.nextafter(d1, np.inf)
+
+            test_cases = [
+                # v1    v2          expected
+                (dtmin, -np.inf,    dtmin),
+                (dtmax, -np.inf,    dtmax),
+                (d1,    d1_next,    d1_next),
+                (dtmax, np.nan,     dtmax),
+            ]
+
+            for v1, v2, expected in test_cases:
+                assert_equal(np.fmax([v1], [v2]), [expected])
+                assert_equal(np.fmax.reduce([v1, v2]), expected)
+
 
 class TestFmin(_FilterInvalids):
     def test_reduce(self):
@@ -1887,6 +2349,27 @@ def test_complex_nans(self):
             out = np.array([0,    0, nan], dtype=complex)
             assert_equal(np.fmin(arg1, arg2), out)
 
+    def test_precision(self):
+        dtypes = [np.float16, np.float32, np.float64, np.longdouble]
+
+        for dt in dtypes:
+            dtmin = np.finfo(dt).min
+            dtmax = np.finfo(dt).max
+            d1 = dt(0.1)
+            d1_next = np.nextafter(d1, np.inf)
+
+            test_cases = [
+                # v1    v2          expected
+                (dtmin, np.inf,     dtmin),
+                (dtmax, np.inf,     dtmax),
+                (d1,    d1_next,    d1),
+                (dtmin, np.nan,     dtmin),
+            ]
+
+            for v1, v2, expected in test_cases:
+                assert_equal(np.fmin([v1], [v2]), [expected])
+                assert_equal(np.fmin.reduce([v1, v2]), expected)
+
 
 class TestBool:
     def test_exceptions(self):
@@ -1958,7 +2441,7 @@ class TestBitwiseUFuncs:
     def test_values(self):
         for dt in self.bitwise_types:
             zeros = np.array([0], dtype=dt)
-            ones = np.array([-1], dtype=dt)
+            ones = np.array([-1]).astype(dt)
             msg = "dt = '%s'" % dt.char
 
             assert_equal(np.bitwise_not(zeros), ones, err_msg=msg)
@@ -1982,7 +2465,7 @@ def test_values(self):
     def test_types(self):
         for dt in self.bitwise_types:
             zeros = np.array([0], dtype=dt)
-            ones = np.array([-1], dtype=dt)
+            ones = np.array([-1]).astype(dt)
             msg = "dt = '%s'" % dt.char
 
             assert_(np.bitwise_not(zeros).dtype == dt, msg)
@@ -2000,7 +2483,7 @@ def test_reduction(self):
 
         for dt in self.bitwise_types:
             zeros = np.array([0], dtype=dt)
-            ones = np.array([-1], dtype=dt)
+            ones = np.array([-1]).astype(dt)
             for f in binary_funcs:
                 msg = "dt: '%s', f: '%s'" % (dt, f)
                 assert_equal(f.reduce(zeros), zeros, err_msg=msg)
@@ -2012,7 +2495,7 @@ def test_reduction(self):
             empty = np.array([], dtype=dt)
             for f in binary_funcs:
                 msg = "dt: '%s', f: '%s'" % (dt, f)
-                tgt = np.array(f.identity, dtype=dt)
+                tgt = np.array(f.identity).astype(dt)
                 res = f.reduce(empty)
                 assert_equal(res, tgt, err_msg=msg)
                 assert_(res.dtype == tgt.dtype, msg)
@@ -3316,6 +3799,7 @@ def test_it(self):
             assert_almost_equal(fz.real, fr, err_msg='real part %s' % f)
             assert_almost_equal(fz.imag, 0., err_msg='imag part %s' % f)
 
+    @pytest.mark.xfail(IS_WASM, reason="doesn't work")
     def test_precisions_consistent(self):
         z = 1 + 1j
         for f in self.funcs:
@@ -3325,6 +3809,7 @@ def test_precisions_consistent(self):
             assert_almost_equal(fcf, fcd, decimal=6, err_msg='fch-fcd %s' % f)
             assert_almost_equal(fcl, fcd, decimal=15, err_msg='fch-fcl %s' % f)
 
+    @pytest.mark.xfail(IS_WASM, reason="doesn't work")
     def test_branch_cuts(self):
         # check branch cuts and continuity on them
         _check_branch_cut(np.log,   -0.5, 1j, 1, -1, True)
@@ -3350,6 +3835,7 @@ def test_branch_cuts(self):
         _check_branch_cut(np.arccosh, [0-2j, 2j, 2], [1,  1,  1j], 1, 1)
         _check_branch_cut(np.arctanh, [0-2j, 2j, 0], [1,  1,  1j], 1, 1)
 
+    @pytest.mark.xfail(IS_WASM, reason="doesn't work")
     def test_branch_cuts_complex64(self):
         # check branch cuts and continuity on them
         _check_branch_cut(np.log,   -0.5, 1j, 1, -1, True, np.complex64)
@@ -3394,6 +3880,7 @@ def test_against_cmath(self):
                 b = cfunc(p)
                 assert_(abs(a - b) < atol, "%s %s: %s; cmath: %s" % (fname, p, a, b))
 
+    @pytest.mark.xfail(IS_WASM, reason="doesn't work")
     @pytest.mark.parametrize('dtype', [np.complex64, np.complex_, np.longcomplex])
     def test_loss_of_precision(self, dtype):
         """Check loss of precision in complex arc* functions"""
@@ -3433,11 +3920,11 @@ def check(x, rtol):
         x_series = np.logspace(-20, -3.001, 200)
         x_basic = np.logspace(-2.999, 0, 10, endpoint=False)
 
-        if glibc_older_than("2.19") and dtype is np.longcomplex:
-            if (platform.machine() == 'aarch64' and bad_arcsinh()):
+        if dtype is np.longcomplex:
+            if bad_arcsinh():
                 pytest.skip("Trig functions of np.longcomplex values known "
-                            "to be inaccurate on aarch64 for some compilation "
-                            "configurations.")
+                            "to be inaccurate on aarch64 and PPC for some "
+                            "compilation configurations.")
             # It's not guaranteed that the system-provided arc functions
             # are accurate down to a few epsilons. (Eg. on Linux 64-bit)
             # So, give more leeway for long complex tests here:
@@ -3484,6 +3971,14 @@ def check(func, z0, d=1):
             check(func, pts, 1j)
             check(func, pts, 1+1j)
 
+    @np.errstate(all="ignore")
+    def test_promotion_corner_cases(self):
+        for func in self.funcs:
+            assert func(np.float16(1)).dtype == np.float16
+            # Integer to low precision float promotion is a dubious choice:
+            assert func(np.uint8(1)).dtype == np.float16
+            assert func(np.int16(1)).dtype == np.float32
+
 
 class TestAttributes:
     def test_attributes(self):
@@ -3793,6 +4288,7 @@ def test_rint_big_int():
     # Rint should not change the value
     assert_equal(val, np.rint(val))
 
+
 @pytest.mark.parametrize('ftype', [np.float32, np.float64])
 def test_memoverlap_accumulate(ftype):
     # Reproduces bug https://github.com/numpy/numpy/issues/15597
@@ -3802,6 +4298,38 @@ def test_memoverlap_accumulate(ftype):
     assert_equal(np.maximum.accumulate(arr), out_max)
     assert_equal(np.minimum.accumulate(arr), out_min)
 
+@pytest.mark.parametrize("ufunc, dtype", [
+    (ufunc, t[0])
+    for ufunc in UFUNCS_BINARY_ACC
+    for t in ufunc.types
+    if t[-1] == '?' and t[0] not in 'DFGMmO'
+])
+def test_memoverlap_accumulate_cmp(ufunc, dtype):
+    if ufunc.signature:
+        pytest.skip('For generic signatures only')
+    for size in (2, 8, 32, 64, 128, 256):
+        arr = np.array([0, 1, 1]*size, dtype=dtype)
+        acc = ufunc.accumulate(arr, dtype='?')
+        acc_u8 = acc.view(np.uint8)
+        exp = np.array(list(itertools.accumulate(arr, ufunc)), dtype=np.uint8)
+        assert_equal(exp, acc_u8)
+
+@pytest.mark.parametrize("ufunc, dtype", [
+    (ufunc, t[0])
+    for ufunc in UFUNCS_BINARY_ACC
+    for t in ufunc.types
+    if t[0] == t[1] and t[0] == t[-1] and t[0] not in 'DFGMmO?'
+])
+def test_memoverlap_accumulate_symmetric(ufunc, dtype):
+    if ufunc.signature:
+        pytest.skip('For generic signatures only')
+    with np.errstate(all='ignore'):
+        for size in (2, 8, 32, 64, 128, 256):
+            arr = np.array([0, 1, 2]*size).astype(dtype)
+            acc = ufunc.accumulate(arr, dtype=dtype)
+            exp = np.array(list(itertools.accumulate(arr, ufunc)), dtype=dtype)
+            assert_equal(exp, acc)
+
 def test_signaling_nan_exceptions():
     with assert_no_warnings():
         a = np.ndarray(shape=(), dtype='float32', buffer=b'\x00\xe0\xbf\xff')
diff --git a/numpy/core/tests/test_umath_accuracy.py b/numpy/core/tests/test_umath_accuracy.py
index 32e2dca66151..6ee4d2fee080 100644
--- a/numpy/core/tests/test_umath_accuracy.py
+++ b/numpy/core/tests/test_umath_accuracy.py
@@ -5,11 +5,19 @@
 import pytest
 from ctypes import c_longlong, c_double, c_float, c_int, cast, pointer, POINTER
 from numpy.testing import assert_array_max_ulp
+from numpy.testing._private.utils import _glibc_older_than
 from numpy.core._multiarray_umath import __cpu_features__
 
+UNARY_UFUNCS = [obj for obj in np.core.umath.__dict__.values() if
+        isinstance(obj, np.ufunc)]
+UNARY_OBJECT_UFUNCS = [uf for uf in UNARY_UFUNCS if "O->O" in uf.types]
+UNARY_OBJECT_UFUNCS.remove(getattr(np, 'invert'))
+
 IS_AVX = __cpu_features__.get('AVX512F', False) or \
         (__cpu_features__.get('FMA3', False) and __cpu_features__.get('AVX2', False))
-runtest = sys.platform.startswith('linux') and IS_AVX
+# only run on linux with AVX, also avoid old glibc (numpy/numpy#20448).
+runtest = (sys.platform.startswith('linux')
+           and IS_AVX and not _glibc_older_than("2.17"))
 platform_skip = pytest.mark.skipif(not runtest,
                                    reason="avoid testing inconsistent platform "
                                    "library implementations")
@@ -56,3 +64,12 @@ def test_validate_transcendentals(self):
                         outval = outval[perm]
                         maxulperr = data_subset['ulperr'].max()
                         assert_array_max_ulp(npfunc(inval), outval, maxulperr)
+
+    @pytest.mark.parametrize("ufunc", UNARY_OBJECT_UFUNCS)
+    def test_validate_fp16_transcendentals(self, ufunc):
+        with np.errstate(all='ignore'):
+            arr = np.arange(65536, dtype=np.int16)
+            datafp16 = np.frombuffer(arr.tobytes(), dtype=np.float16)
+            datafp32 = datafp16.astype(np.float32)
+            assert_array_max_ulp(ufunc(datafp16), ufunc(datafp32),
+                    maxulp=1, dtype=np.float16)
diff --git a/numpy/core/tests/test_umath_complex.py b/numpy/core/tests/test_umath_complex.py
index af5bbe59e698..8aa9a28ff48d 100644
--- a/numpy/core/tests/test_umath_complex.py
+++ b/numpy/core/tests/test_umath_complex.py
@@ -354,10 +354,10 @@ def _check_ninf_nan(dummy):
         # cuts first)
 
 class TestCpow:
-    def setup(self):
+    def setup_method(self):
         self.olderr = np.seterr(invalid='ignore')
 
-    def teardown(self):
+    def teardown_method(self):
         np.seterr(**self.olderr)
 
     def test_simple(self):
@@ -407,10 +407,10 @@ def test_array(self):
             assert_almost_equal(n_r[i], p_r[i], err_msg='Loop %d\n' % i)
 
 class TestCabs:
-    def setup(self):
+    def setup_method(self):
         self.olderr = np.seterr(invalid='ignore')
 
-    def teardown(self):
+    def teardown_method(self):
         np.seterr(**self.olderr)
 
     def test_simple(self):
diff --git a/numpy/core/tests/test_unicode.py b/numpy/core/tests/test_unicode.py
index 8e0dd47cb077..2d7c2818e986 100644
--- a/numpy/core/tests/test_unicode.py
+++ b/numpy/core/tests/test_unicode.py
@@ -1,3 +1,5 @@
+import pytest
+
 import numpy as np
 from numpy.testing import assert_, assert_equal, assert_array_equal
 
@@ -20,12 +22,13 @@ def buffer_length(arr):
     else:
         return np.prod(v.shape) * v.itemsize
 
+
 # In both cases below we need to make sure that the byte swapped value (as
 # UCS4) is still a valid unicode:
 # Value that can be represented in UCS2 interpreters
-ucs2_value = u'\u0900'
+ucs2_value = '\u0900'
 # Value that cannot be represented in UCS2 interpreters (but can in UCS4)
-ucs4_value = u'\U00100900'
+ucs4_value = '\U00100900'
 
 
 def test_string_cast():
@@ -33,8 +36,11 @@ def test_string_cast():
     uni_arr1 = str_arr.astype('>U')
     uni_arr2 = str_arr.astype(' _ctypes: ...
+    def from_param(cls: type[_ndptr[None]], obj: ndarray[Any, Any]) -> _ctypes: ...
     @overload
     @classmethod
-    def from_param(cls: Type[_ndptr[_DType]], obj: ndarray[Any, _DType]) -> _ctypes: ...
+    def from_param(cls: type[_ndptr[_DType]], obj: ndarray[Any, _DType]) -> _ctypes: ...
 
 class _concrete_ndptr(_ndptr[_DType]):
     _dtype_: ClassVar[_DType]
-    _shape_: ClassVar[Tuple[int, ...]]
+    _shape_: ClassVar[tuple[int, ...]]
     @property
     def contents(self) -> ndarray[Any, _DType]: ...
 
@@ -124,7 +107,7 @@ def load_library(
     loader_path: str | bytes | os.PathLike[str] | os.PathLike[bytes],
 ) -> ctypes.CDLL: ...
 
-__all__: List[str]
+__all__: list[str]
 
 c_intp = _c_intp
 
@@ -134,7 +117,7 @@ def ndpointer(
     ndim: int = ...,
     shape: None | _ShapeLike = ...,
     flags: None | _FlagsKind | Iterable[_FlagsKind] | int | flagsobj = ...,
-) -> Type[_ndptr[None]]: ...
+) -> type[_ndptr[None]]: ...
 @overload
 def ndpointer(
     dtype: _DTypeLike[_SCT],
@@ -142,7 +125,7 @@ def ndpointer(
     *,
     shape: _ShapeLike,
     flags: None | _FlagsKind | Iterable[_FlagsKind] | int | flagsobj = ...,
-) -> Type[_concrete_ndptr[dtype[_SCT]]]: ...
+) -> type[_concrete_ndptr[dtype[_SCT]]]: ...
 @overload
 def ndpointer(
     dtype: DTypeLike,
@@ -150,54 +133,54 @@ def ndpointer(
     *,
     shape: _ShapeLike,
     flags: None | _FlagsKind | Iterable[_FlagsKind] | int | flagsobj = ...,
-) -> Type[_concrete_ndptr[dtype[Any]]]: ...
+) -> type[_concrete_ndptr[dtype[Any]]]: ...
 @overload
 def ndpointer(
     dtype: _DTypeLike[_SCT],
     ndim: int = ...,
     shape: None = ...,
     flags: None | _FlagsKind | Iterable[_FlagsKind] | int | flagsobj = ...,
-) -> Type[_ndptr[dtype[_SCT]]]: ...
+) -> type[_ndptr[dtype[_SCT]]]: ...
 @overload
 def ndpointer(
     dtype: DTypeLike,
     ndim: int = ...,
     shape: None = ...,
     flags: None | _FlagsKind | Iterable[_FlagsKind] | int | flagsobj = ...,
-) -> Type[_ndptr[dtype[Any]]]: ...
+) -> type[_ndptr[dtype[Any]]]: ...
 
 @overload
-def as_ctypes_type(dtype: _BoolCodes | _DTypeLike[bool_] | Type[ctypes.c_bool]) -> Type[ctypes.c_bool]: ...
+def as_ctypes_type(dtype: _BoolCodes | _DTypeLike[bool_] | type[ctypes.c_bool]) -> type[ctypes.c_bool]: ...
 @overload
-def as_ctypes_type(dtype: _ByteCodes | _DTypeLike[byte] | Type[ctypes.c_byte]) -> Type[ctypes.c_byte]: ...
+def as_ctypes_type(dtype: _ByteCodes | _DTypeLike[byte] | type[ctypes.c_byte]) -> type[ctypes.c_byte]: ...
 @overload
-def as_ctypes_type(dtype: _ShortCodes | _DTypeLike[short] | Type[ctypes.c_short]) -> Type[ctypes.c_short]: ...
+def as_ctypes_type(dtype: _ShortCodes | _DTypeLike[short] | type[ctypes.c_short]) -> type[ctypes.c_short]: ...
 @overload
-def as_ctypes_type(dtype: _IntCCodes | _DTypeLike[intc] | Type[ctypes.c_int]) -> Type[ctypes.c_int]: ...
+def as_ctypes_type(dtype: _IntCCodes | _DTypeLike[intc] | type[ctypes.c_int]) -> type[ctypes.c_int]: ...
 @overload
-def as_ctypes_type(dtype: _IntCodes | _DTypeLike[int_] | Type[int | ctypes.c_long]) -> Type[ctypes.c_long]: ...
+def as_ctypes_type(dtype: _IntCodes | _DTypeLike[int_] | type[int | ctypes.c_long]) -> type[ctypes.c_long]: ...
 @overload
-def as_ctypes_type(dtype: _LongLongCodes | _DTypeLike[longlong] | Type[ctypes.c_longlong]) -> Type[ctypes.c_longlong]: ...
+def as_ctypes_type(dtype: _LongLongCodes | _DTypeLike[longlong] | type[ctypes.c_longlong]) -> type[ctypes.c_longlong]: ...
 @overload
-def as_ctypes_type(dtype: _UByteCodes | _DTypeLike[ubyte] | Type[ctypes.c_ubyte]) -> Type[ctypes.c_ubyte]: ...
+def as_ctypes_type(dtype: _UByteCodes | _DTypeLike[ubyte] | type[ctypes.c_ubyte]) -> type[ctypes.c_ubyte]: ...
 @overload
-def as_ctypes_type(dtype: _UShortCodes | _DTypeLike[ushort] | Type[ctypes.c_ushort]) -> Type[ctypes.c_ushort]: ...
+def as_ctypes_type(dtype: _UShortCodes | _DTypeLike[ushort] | type[ctypes.c_ushort]) -> type[ctypes.c_ushort]: ...
 @overload
-def as_ctypes_type(dtype: _UIntCCodes | _DTypeLike[uintc] | Type[ctypes.c_uint]) -> Type[ctypes.c_uint]: ...
+def as_ctypes_type(dtype: _UIntCCodes | _DTypeLike[uintc] | type[ctypes.c_uint]) -> type[ctypes.c_uint]: ...
 @overload
-def as_ctypes_type(dtype: _UIntCodes | _DTypeLike[uint] | Type[ctypes.c_ulong]) -> Type[ctypes.c_ulong]: ...
+def as_ctypes_type(dtype: _UIntCodes | _DTypeLike[uint] | type[ctypes.c_ulong]) -> type[ctypes.c_ulong]: ...
 @overload
-def as_ctypes_type(dtype: _ULongLongCodes | _DTypeLike[ulonglong] | Type[ctypes.c_ulonglong]) -> Type[ctypes.c_ulonglong]: ...
+def as_ctypes_type(dtype: _ULongLongCodes | _DTypeLike[ulonglong] | type[ctypes.c_ulonglong]) -> type[ctypes.c_ulonglong]: ...
 @overload
-def as_ctypes_type(dtype: _SingleCodes | _DTypeLike[single] | Type[ctypes.c_float]) -> Type[ctypes.c_float]: ...
+def as_ctypes_type(dtype: _SingleCodes | _DTypeLike[single] | type[ctypes.c_float]) -> type[ctypes.c_float]: ...
 @overload
-def as_ctypes_type(dtype: _DoubleCodes | _DTypeLike[double] | Type[float | ctypes.c_double]) -> Type[ctypes.c_double]: ...
+def as_ctypes_type(dtype: _DoubleCodes | _DTypeLike[double] | type[float | ctypes.c_double]) -> type[ctypes.c_double]: ...
 @overload
-def as_ctypes_type(dtype: _LongDoubleCodes | _DTypeLike[longdouble] | Type[ctypes.c_longdouble]) -> Type[ctypes.c_longdouble]: ...
+def as_ctypes_type(dtype: _LongDoubleCodes | _DTypeLike[longdouble] | type[ctypes.c_longdouble]) -> type[ctypes.c_longdouble]: ...
 @overload
-def as_ctypes_type(dtype: _VoidDTypeLike) -> Type[Any]: ...  # `ctypes.Union` or `ctypes.Structure`
+def as_ctypes_type(dtype: _VoidDTypeLike) -> type[Any]: ...  # `ctypes.Union` or `ctypes.Structure`
 @overload
-def as_ctypes_type(dtype: str) -> Type[Any]: ...
+def as_ctypes_type(dtype: str) -> type[Any]: ...
 
 @overload
 def as_array(obj: ctypes._PointerLike, shape: Sequence[int]) -> NDArray[Any]: ...
diff --git a/numpy/distutils/__init__.py b/numpy/distutils/__init__.py
index 79974d1c220a..f74ed4d3f6db 100644
--- a/numpy/distutils/__init__.py
+++ b/numpy/distutils/__init__.py
@@ -19,6 +19,8 @@
 
 """
 
+import warnings
+
 # Must import local ccompiler ASAP in order to get
 # customized CCompiler.spawn effective.
 from . import ccompiler
@@ -26,6 +28,17 @@
 
 from .npy_pkg_config import *
 
+warnings.warn("\n\n"
+    "  `numpy.distutils` is deprecated since NumPy 1.23.0, as a result\n"
+    "  of the deprecation of `distutils` itself. It will be removed for\n"
+    "  Python >= 3.12. For older Python versions it will remain present.\n"
+    "  It is recommended to use `setuptools < 60.0` for those Python versions.\n"
+    "  For more details, see:\n"
+    "    https://numpy.org/devdocs/reference/distutils_status_migration.html \n\n",
+    DeprecationWarning, stacklevel=2
+)
+del warnings
+
 # If numpy is installed, add distutils.test()
 try:
     from . import __config__
diff --git a/numpy/distutils/armccompiler.py b/numpy/distutils/armccompiler.py
new file mode 100644
index 000000000000..afba7eb3b352
--- /dev/null
+++ b/numpy/distutils/armccompiler.py
@@ -0,0 +1,26 @@
+from distutils.unixccompiler import UnixCCompiler                              
+
+class ArmCCompiler(UnixCCompiler):
+
+    """
+    Arm compiler.
+    """
+
+    compiler_type = 'arm'
+    cc_exe = 'armclang'
+    cxx_exe = 'armclang++'
+
+    def __init__(self, verbose=0, dry_run=0, force=0):
+        UnixCCompiler.__init__(self, verbose, dry_run, force)
+        cc_compiler = self.cc_exe
+        cxx_compiler = self.cxx_exe
+        self.set_executables(compiler=cc_compiler +
+                                      ' -O3 -fPIC',
+                             compiler_so=cc_compiler +
+                                         ' -O3 -fPIC',
+                             compiler_cxx=cxx_compiler +
+                                          ' -O3 -fPIC',
+                             linker_exe=cc_compiler +
+                                        ' -lamath',
+                             linker_so=cc_compiler +
+                                       ' -lamath -shared')
diff --git a/numpy/distutils/ccompiler.py b/numpy/distutils/ccompiler.py
index 713b8c72f739..f0487cb64fdb 100644
--- a/numpy/distutils/ccompiler.py
+++ b/numpy/distutils/ccompiler.py
@@ -109,7 +109,7 @@ class where more documentation can be found.
 
 
 # Using customized CCompiler.spawn.
-def CCompiler_spawn(self, cmd, display=None):
+def CCompiler_spawn(self, cmd, display=None, env=None):
     """
     Execute a command in a sub-process.
 
@@ -120,6 +120,7 @@ def CCompiler_spawn(self, cmd, display=None):
     display : str or sequence of str, optional
         The text to add to the log file kept by `numpy.distutils`.
         If not given, `display` is equal to `cmd`.
+    env : a dictionary for environment variables, optional
 
     Returns
     -------
@@ -131,6 +132,7 @@ def CCompiler_spawn(self, cmd, display=None):
         If the command failed, i.e. the exit status was not 0.
 
     """
+    env = env if env is not None else dict(os.environ)
     if display is None:
         display = cmd
         if is_sequence(display):
@@ -138,9 +140,9 @@ def CCompiler_spawn(self, cmd, display=None):
     log.info(display)
     try:
         if self.verbose:
-            subprocess.check_output(cmd)
+            subprocess.check_output(cmd, env=env)
         else:
-            subprocess.check_output(cmd, stderr=subprocess.STDOUT)
+            subprocess.check_output(cmd, stderr=subprocess.STDOUT, env=env)
     except subprocess.CalledProcessError as exc:
         o = exc.output
         s = exc.returncode
@@ -353,10 +355,10 @@ def single_compile(args):
 
     if len(build) > 1 and jobs > 1:
         # build parallel
-        import multiprocessing.pool
-        pool = multiprocessing.pool.ThreadPool(jobs)
-        pool.map(single_compile, build_items)
-        pool.close()
+        from concurrent.futures import ThreadPoolExecutor
+        with ThreadPoolExecutor(jobs) as pool:
+            res = pool.map(single_compile, build_items)
+        list(res)  # access result to raise errors
     else:
         # build serial
         for o in build_items:
@@ -684,10 +686,17 @@ def CCompiler_cxx_compiler(self):
     cxx.compiler_cxx = cxx.compiler_cxx
     cxx.compiler_so = [cxx.compiler_cxx[0]] + \
                       sanitize_cxx_flags(cxx.compiler_so[1:])
-    if sys.platform.startswith('aix') and 'ld_so_aix' in cxx.linker_so[0]:
+    if (sys.platform.startswith(('aix', 'os400')) and
+            'ld_so_aix' in cxx.linker_so[0]):
         # AIX needs the ld_so_aix script included with Python
         cxx.linker_so = [cxx.linker_so[0], cxx.compiler_cxx[0]] \
                         + cxx.linker_so[2:]
+    if sys.platform.startswith('os400'):
+        #This is required by i 7.4 and prievous for PRId64 in printf() call.
+        cxx.compiler_so.append('-D__STDC_FORMAT_MACROS')
+        #This a bug of gcc10.3, which failed to handle the TLS init.
+        cxx.compiler_so.append('-fno-extern-tls-init')
+        cxx.linker_so.append('-fno-extern-tls-init')
     else:
         cxx.linker_so = [cxx.compiler_cxx[0]] + cxx.linker_so[1:]
     return cxx
@@ -706,6 +715,9 @@ def CCompiler_cxx_compiler(self):
                               "Intel C Compiler for 64-bit applications on Windows")
 compiler_class['pathcc'] = ('pathccompiler', 'PathScaleCCompiler',
                             "PathScale Compiler for SiCortex-based applications")
+compiler_class['arm'] = ('armccompiler', 'ArmCCompiler',
+                            "Arm C Compiler")
+
 ccompiler._default_compilers += (('linux.*', 'intel'),
                                  ('linux.*', 'intele'),
                                  ('linux.*', 'intelem'),
diff --git a/numpy/distutils/ccompiler_opt.py b/numpy/distutils/ccompiler_opt.py
index 39847c20fead..da550722cb39 100644
--- a/numpy/distutils/ccompiler_opt.py
+++ b/numpy/distutils/ccompiler_opt.py
@@ -16,6 +16,14 @@
 import subprocess
 import textwrap
 
+# These flags are used to compile any C++ source within Numpy.
+# They are chosen to have very few runtime dependencies.
+NPY_CXX_FLAGS = [
+    '-std=c++11',  # Minimal standard version
+    '-D__STDC_VERSION__=0',  # for compatibility with C headers
+    '-fno-exceptions',  # no exception support
+    '-fno-rtti']  # no runtime type information
+
 
 class _Config:
     """An abstract class holds all configurable attributes of `CCompilerOpt`,
@@ -169,7 +177,7 @@ class _Config:
 
             If the compiler able to successfully compile the C file then `CCompilerOpt`
             will add a C ``#define`` for it into the main dispatch header, e.g.
-            ```#define {conf_c_prefix}_XXXX`` where ``XXXX`` is the case name in upper case.
+            ``#define {conf_c_prefix}_XXXX`` where ``XXXX`` is the case name in upper case.
 
         **NOTES**:
             * space can be used as separator with options that supports "str or list"
@@ -228,6 +236,7 @@ class _Config:
         x64 = "SSE SSE2 SSE3",
         ppc64 = '', # play it safe
         ppc64le = "VSX VSX2",
+        s390x = '',
         armhf = '', # play it safe
         aarch64 = "NEON NEON_FP16 NEON_VFPV4 ASIMD"
     )
@@ -293,6 +302,16 @@ class _Config:
         VSX2 = dict(interest=2, implies="VSX", implies_detect=False),
         ## Power9/ISA 3.00
         VSX3 = dict(interest=3, implies="VSX2", implies_detect=False),
+        ## Power10/ISA 3.1
+        VSX4 = dict(interest=4, implies="VSX3", implies_detect=False,
+                    extra_checks="VSX4_MMA"),
+        # IBM/Z
+        ## VX(z13) support
+        VX = dict(interest=1, headers="vecintrin.h"),
+        ## Vector-Enhancements Facility
+        VXE = dict(interest=2, implies="VX", implies_detect=False),
+        ## Vector-Enhancements Facility 2
+        VXE2 = dict(interest=3, implies="VXE", implies_detect=False),
         # ARM
         NEON  = dict(interest=1, headers="arm_neon.h"),
         NEON_FP16 = dict(interest=2, implies="NEON"),
@@ -335,7 +354,7 @@ class attribute `conf_features`, also its override
             FMA4   = dict(flags="-mfma4"),
             FMA3   = dict(flags="-mfma"),
             AVX2   = dict(flags="-mavx2"),
-            AVX512F = dict(flags="-mavx512f"),
+            AVX512F = dict(flags="-mavx512f -mno-mmx"),
             AVX512CD = dict(flags="-mavx512cd"),
             AVX512_KNL = dict(flags="-mavx512er -mavx512pf"),
             AVX512_KNM = dict(
@@ -463,15 +482,36 @@ class attribute `conf_features`, also its override
                 ),
                 VSX3 = dict(
                     flags="-mcpu=power9 -mtune=power9", implies_detect=False
+                ),
+                VSX4 = dict(
+                    flags="-mcpu=power10 -mtune=power10", implies_detect=False
                 )
             )
             if self.cc_is_clang:
                 partial["VSX"]["flags"]  = "-maltivec -mvsx"
                 partial["VSX2"]["flags"] = "-mpower8-vector"
                 partial["VSX3"]["flags"] = "-mpower9-vector"
+                partial["VSX4"]["flags"] = "-mpower10-vector"
 
             return partial
 
+        on_zarch = self.cc_on_s390x
+        if on_zarch:
+            partial = dict(
+                VX = dict(
+                    flags="-march=arch11 -mzvector"
+                ),
+                VXE = dict(
+                    flags="-march=arch12", implies_detect=False
+                ),
+                VXE2 = dict(
+                    flags="-march=arch13", implies_detect=False
+                )
+            )
+
+            return partial
+
+
         if self.cc_on_aarch64 and is_unix: return dict(
             NEON = dict(
                 implies="NEON_FP16 NEON_VFPV4 ASIMD", autovec=True
@@ -654,9 +694,9 @@ def dist_log(*args, stderr=False):
     @staticmethod
     def dist_load_module(name, path):
         """Load a module from file, required by the abstract class '_Cache'."""
-        from numpy.compat import npy_load_module
+        from .misc_util import exec_mod_from_location
         try:
-            return npy_load_module(name, path)
+            return exec_mod_from_location(name, path)
         except Exception as e:
             _Distutils.dist_log(e, stderr=True)
         return None
@@ -707,7 +747,7 @@ def _dist_test_spawn_paths(self, cmd, display=None):
     def _dist_test_spawn(cmd, display=None):
         try:
             o = subprocess.check_output(cmd, stderr=subprocess.STDOUT,
-                                        universal_newlines=True)
+                                        text=True)
             if o and re.match(_Distutils._dist_warn_regex, o):
                 _Distutils.dist_error(
                     "Flags in command", cmd ,"aren't supported by the compiler"
@@ -737,18 +777,18 @@ class _Cache:
 
     Parameters
     ----------
-    cache_path: str or None
+    cache_path : str or None
         The path of cache file, if None then cache in file will disabled.
 
-    *factors:
+    *factors :
         The caching factors that need to utilize next to `conf_cache_factors`.
 
     Attributes
     ----------
-    cache_private: set
+    cache_private : set
         Hold the attributes that need be skipped from "in-memory cache".
 
-    cache_infile: bool
+    cache_infile : bool
         Utilized during initializing this class, to determine if the cache was able
         to loaded from the specified cache path in 'cache_path'.
     """
@@ -874,7 +914,11 @@ class _CCompiler:
     cc_on_x64 : bool
         True when the target architecture is 64-bit x86
     cc_on_ppc64 : bool
-        True when the target architecture is 64-bit big-endian PowerPC
+        True when the target architecture is 64-bit big-endian powerpc
+    cc_on_ppc64le : bool
+        True when the target architecture is 64-bit litle-endian powerpc
+    cc_on_s390x : bool
+        True when the target architecture is IBM/ZARCH on linux
     cc_on_armhf : bool
         True when the target architecture is 32-bit ARMv7+
     cc_on_aarch64 : bool
@@ -911,50 +955,61 @@ class _CCompiler:
     def __init__(self):
         if hasattr(self, "cc_is_cached"):
             return
-        #      attr                regex
+        #      attr            regex        compiler-expression
         detect_arch = (
-            ("cc_on_x64",      ".*(x|x86_|amd)64.*"),
-            ("cc_on_x86",      ".*(win32|x86|i386|i686).*"),
-            ("cc_on_ppc64le",  ".*(powerpc|ppc)64(el|le).*"),
-            ("cc_on_ppc64",    ".*(powerpc|ppc)64.*"),
-            ("cc_on_aarch64",  ".*(aarch64|arm64).*"),
-            ("cc_on_armhf",    ".*arm.*"),
+            ("cc_on_x64",      ".*(x|x86_|amd)64.*", ""),
+            ("cc_on_x86",      ".*(win32|x86|i386|i686).*", ""),
+            ("cc_on_ppc64le",  ".*(powerpc|ppc)64(el|le).*|.*powerpc.*",
+                                          "defined(__powerpc64__) && "
+                                          "defined(__LITTLE_ENDIAN__)"),
+            ("cc_on_ppc64",    ".*(powerpc|ppc).*|.*powerpc.*",
+                                          "defined(__powerpc64__) && "
+                                          "defined(__BIG_ENDIAN__)"),
+            ("cc_on_aarch64",  ".*(aarch64|arm64).*", ""),
+            ("cc_on_armhf",    ".*arm.*", "defined(__ARM_ARCH_7__) || "
+                                          "defined(__ARM_ARCH_7A__)"),
+            ("cc_on_s390x",    ".*s390x.*", ""),
             # undefined platform
-            ("cc_on_noarch",    ""),
+            ("cc_on_noarch",   "", ""),
         )
         detect_compiler = (
-            ("cc_is_gcc",     r".*(gcc|gnu\-g).*"),
-            ("cc_is_clang",    ".*clang.*"),
-            ("cc_is_iccw",     ".*(intelw|intelemw|iccw).*"), # intel msvc like
-            ("cc_is_icc",      ".*(intel|icc).*"), # intel unix like
-            ("cc_is_msvc",     ".*msvc.*"),
+            ("cc_is_gcc",     r".*(gcc|gnu\-g).*", ""),
+            ("cc_is_clang",    ".*clang.*", ""),
+            # intel msvc like
+            ("cc_is_iccw",     ".*(intelw|intelemw|iccw).*", ""),
+            ("cc_is_icc",      ".*(intel|icc).*", ""),  # intel unix like
+            ("cc_is_msvc",     ".*msvc.*", ""),
             # undefined compiler will be treat it as gcc
-            ("cc_is_nocc",     ""),
+            ("cc_is_nocc",     "", ""),
         )
         detect_args = (
-           ("cc_has_debug",  ".*(O0|Od|ggdb|coverage|debug:full).*"),
-           ("cc_has_native", ".*(-march=native|-xHost|/QxHost).*"),
+           ("cc_has_debug",  ".*(O0|Od|ggdb|coverage|debug:full).*", ""),
+           ("cc_has_native", ".*(-march=native|-xHost|/QxHost).*", ""),
            # in case if the class run with -DNPY_DISABLE_OPTIMIZATION
-           ("cc_noopt", ".*DISABLE_OPT.*"),
+           ("cc_noopt", ".*DISABLE_OPT.*", ""),
         )
 
         dist_info = self.dist_info()
         platform, compiler_info, extra_args = dist_info
         # set False to all attrs
         for section in (detect_arch, detect_compiler, detect_args):
-            for attr, rgex in section:
+            for attr, rgex, cexpr in section:
                 setattr(self, attr, False)
 
         for detect, searchin in ((detect_arch, platform), (detect_compiler, compiler_info)):
-            for attr, rgex in detect:
+            for attr, rgex, cexpr in detect:
                 if rgex and not re.match(rgex, searchin, re.IGNORECASE):
                     continue
+                if cexpr and not self.cc_test_cexpr(cexpr):
+                    continue
                 setattr(self, attr, True)
                 break
 
-        for attr, rgex in detect_args:
+        for attr, rgex, cexpr in detect_args:
             if rgex and not re.match(rgex, extra_args, re.IGNORECASE):
                 continue
+            if cexpr and not self.cc_test_cexpr(cexpr):
+                continue
             setattr(self, attr, True)
 
         if self.cc_on_noarch:
@@ -983,7 +1038,8 @@ def __init__(self):
             self.cc_is_gcc = True
 
         self.cc_march = "unknown"
-        for arch in ("x86", "x64", "ppc64", "ppc64le", "armhf", "aarch64"):
+        for arch in ("x86", "x64", "ppc64", "ppc64le",
+                     "armhf", "aarch64", "s390x"):
             if getattr(self, "cc_on_" + arch):
                 self.cc_march = arch
                 break
@@ -1025,6 +1081,25 @@ def cc_test_flags(self, flags):
             self.dist_log("testing failed", stderr=True)
         return test
 
+    @_Cache.me
+    def cc_test_cexpr(self, cexpr, flags=[]):
+        """
+        Same as the above but supports compile-time expressions.
+        """
+        self.dist_log("testing compiler expression", cexpr)
+        test_path = os.path.join(self.conf_tmp_path, "npy_dist_test_cexpr.c")
+        with open(test_path, "w") as fd:
+            fd.write(textwrap.dedent(f"""\
+               #if !({cexpr})
+                   #error "unsupported expression"
+               #endif
+               int dummy;
+            """))
+        test = self.dist_test(test_path, flags)
+        if not test:
+            self.dist_log("testing failed", stderr=True)
+        return test
+
     def cc_normalize_flags(self, flags):
         """
         Remove the conflicts that caused due gathering implied features flags.
@@ -1063,7 +1138,9 @@ def cc_normalize_flags(self, flags):
     _cc_normalize_unix_frgx = re.compile(
         # 2- to remove any flags starts with
         # -march, -mcpu, -x(INTEL) and '-m' without '='
-        r"^(?!(-mcpu=|-march=|-x[A-Z0-9\-]))(?!-m[a-z0-9\-\.]*.$)"
+        r"^(?!(-mcpu=|-march=|-x[A-Z0-9\-]|-m[a-z0-9\-\.]*.$))|"
+        # exclude:
+        r"(?:-mzvector)"
     )
     _cc_normalize_unix_krgx = re.compile(
         # 3- keep only the highest of
@@ -1191,12 +1268,12 @@ def feature_names(self, names=None, force_flags=None, macros=[]):
 
         Parameters
         ----------
-        names: sequence or None, optional
+        names : sequence or None, optional
             Specify certain CPU features to test it against the **C** compiler.
             if None(default), it will test all current supported features.
             **Note**: feature names must be in upper-case.
 
-        force_flags: list or None, optional
+        force_flags : list or None, optional
             If None(default), default compiler flags for every CPU feature will
             be used during the test.
 
@@ -1265,10 +1342,10 @@ def feature_implies(self, names, keep_origins=False):
 
         Parameters
         ----------
-        names: str or sequence of str
+        names : str or sequence of str
             CPU feature name(s) in uppercase.
 
-        keep_origins: bool
+        keep_origins : bool
             if False(default) then the returned set will not contain any
             features from 'names'. This case happens only when two features
             imply each other.
@@ -1458,10 +1535,10 @@ def feature_test(self, name, force_flags=None, macros=[]):
 
         Parameters
         ----------
-        name: str
+        name : str
             Supported CPU feature name.
 
-        force_flags: list or None, optional
+        force_flags : list or None, optional
             If None(default), the returned flags from `feature_flags()`
             will be used.
 
@@ -1497,10 +1574,10 @@ def feature_is_supported(self, name, force_flags=None, macros=[]):
 
         Parameters
         ----------
-        name: str
+        name : str
             CPU feature name in uppercase.
 
-        force_flags: list or None, optional
+        force_flags : list or None, optional
             If None(default), default compiler flags for every CPU feature will
             be used during test.
 
@@ -1542,7 +1619,7 @@ def feature_extra_checks(self, name):
 
         Parameters
         ----------
-        names: str
+        names : str
             CPU feature name in uppercase.
         """
         assert isinstance(name, str)
@@ -1628,10 +1705,10 @@ class _Parse:
 
     Parameters
     ----------
-    cpu_baseline: str or None
+    cpu_baseline : str or None
         minimal set of required CPU features or special options.
 
-    cpu_dispatch: str or None
+    cpu_dispatch : str or None
         dispatched set of additional CPU features or special options.
 
     Special options can be:
@@ -1764,7 +1841,7 @@ def parse_targets(self, source):
 
         Parameters
         ----------
-        source: str
+        source : str
             the path of **C** source file.
 
         Returns
@@ -2203,7 +2280,7 @@ def try_dispatch(self, sources, src_dir=None, ccompiler=None, **kwargs):
             Path of parent directory for the generated headers and wrapped sources.
             If None(default) the files will generated in-place.
 
-        ccompiler: CCompiler
+        ccompiler : CCompiler
             Distutils `CCompiler` instance to be used for compilation.
             If None (default), the provided instance during the initialization
             will be used instead.
@@ -2511,6 +2588,8 @@ def _generate_config(self, output_dir, dispatch_src, targets, has_baseline=False
         except OSError:
             pass
 
+        os.makedirs(os.path.dirname(config_path), exist_ok=True)
+
         self.dist_log("generate dispatched config -> ", config_path)
         dispatch_calls = []
         for tar in targets:
diff --git a/numpy/distutils/checks/cpu_asimd.c b/numpy/distutils/checks/cpu_asimd.c
index 8df556b6c303..6bc9022a58d3 100644
--- a/numpy/distutils/checks/cpu_asimd.c
+++ b/numpy/distutils/checks/cpu_asimd.c
@@ -3,9 +3,10 @@
 #endif
 #include 
 
-int main(void)
+int main(int argc, char **argv)
 {
-    float32x4_t v1 = vdupq_n_f32(1.0f), v2 = vdupq_n_f32(2.0f);
+    float *src = (float*)argv[argc-1];
+    float32x4_t v1 = vdupq_n_f32(src[0]), v2 = vdupq_n_f32(src[1]);
     /* MAXMIN */
     int ret  = (int)vgetq_lane_f32(vmaxnmq_f32(v1, v2), 0);
         ret += (int)vgetq_lane_f32(vminnmq_f32(v1, v2), 0);
@@ -13,7 +14,8 @@ int main(void)
     ret += (int)vgetq_lane_f32(vrndq_f32(v1), 0);
 #ifdef __aarch64__
     {
-        float64x2_t vd1 = vdupq_n_f64(1.0), vd2 = vdupq_n_f64(2.0);
+        double *src2 = (double*)argv[argc-1];
+        float64x2_t vd1 = vdupq_n_f64(src2[0]), vd2 = vdupq_n_f64(src2[1]);
         /* MAXMIN */
         ret += (int)vgetq_lane_f64(vmaxnmq_f64(vd1, vd2), 0);
         ret += (int)vgetq_lane_f64(vminnmq_f64(vd1, vd2), 0);
diff --git a/numpy/distutils/checks/cpu_asimddp.c b/numpy/distutils/checks/cpu_asimddp.c
index 0158d13543ad..e7068ce02e19 100644
--- a/numpy/distutils/checks/cpu_asimddp.c
+++ b/numpy/distutils/checks/cpu_asimddp.c
@@ -3,9 +3,10 @@
 #endif
 #include 
 
-int main(void)
+int main(int argc, char **argv)
 {
-    uint8x16_t v1 = vdupq_n_u8((unsigned char)1), v2 = vdupq_n_u8((unsigned char)2);
+    unsigned char *src = (unsigned char*)argv[argc-1];
+    uint8x16_t v1 = vdupq_n_u8(src[0]), v2 = vdupq_n_u8(src[1]);
     uint32x4_t va = vdupq_n_u32(3);
     int ret = (int)vgetq_lane_u32(vdotq_u32(va, v1, v2), 0);
 #ifdef __aarch64__
diff --git a/numpy/distutils/checks/cpu_asimdfhm.c b/numpy/distutils/checks/cpu_asimdfhm.c
index bb437aa40352..54e328098d17 100644
--- a/numpy/distutils/checks/cpu_asimdfhm.c
+++ b/numpy/distutils/checks/cpu_asimdfhm.c
@@ -3,15 +3,17 @@
 #endif
 #include 
 
-int main(void)
+int main(int argc, char **argv)
 {
-    float16x8_t vhp  = vdupq_n_f16((float16_t)1);
-    float16x4_t vlhp = vdup_n_f16((float16_t)1);
-    float32x4_t vf   = vdupq_n_f32(1.0f);
-    float32x2_t vlf  = vdup_n_f32(1.0f);
+    float16_t *src = (float16_t*)argv[argc-1];
+    float *src2 = (float*)argv[argc-2];
+    float16x8_t vhp  = vdupq_n_f16(src[0]);
+    float16x4_t vlhp = vdup_n_f16(src[1]);
+    float32x4_t vf   = vdupq_n_f32(src2[0]);
+    float32x2_t vlf  = vdup_n_f32(src2[1]);
 
-    int ret  = (int)vget_lane_f32(vfmlal_low_u32(vlf, vlhp, vlhp), 0);
-        ret += (int)vgetq_lane_f32(vfmlslq_high_u32(vf, vhp, vhp), 0);
+    int ret  = (int)vget_lane_f32(vfmlal_low_f16(vlf, vlhp, vlhp), 0);
+        ret += (int)vgetq_lane_f32(vfmlslq_high_f16(vf, vhp, vhp), 0);
 
     return ret;
 }
diff --git a/numpy/distutils/checks/cpu_asimdhp.c b/numpy/distutils/checks/cpu_asimdhp.c
index 80b94000f04e..e2de0306e0ac 100644
--- a/numpy/distutils/checks/cpu_asimdhp.c
+++ b/numpy/distutils/checks/cpu_asimdhp.c
@@ -3,10 +3,11 @@
 #endif
 #include 
 
-int main(void)
+int main(int argc, char **argv)
 {
-    float16x8_t vhp  = vdupq_n_f16((float16_t)-1);
-    float16x4_t vlhp = vdup_n_f16((float16_t)-1);
+    float16_t *src = (float16_t*)argv[argc-1];
+    float16x8_t vhp  = vdupq_n_f16(src[0]);
+    float16x4_t vlhp = vdup_n_f16(src[1]);
 
     int ret  =  (int)vgetq_lane_f16(vabdq_f16(vhp, vhp), 0);
         ret  += (int)vget_lane_f16(vabd_f16(vlhp, vlhp), 0);
diff --git a/numpy/distutils/checks/cpu_neon.c b/numpy/distutils/checks/cpu_neon.c
index 4eab1f384a72..8c64f864dea6 100644
--- a/numpy/distutils/checks/cpu_neon.c
+++ b/numpy/distutils/checks/cpu_neon.c
@@ -3,12 +3,16 @@
 #endif
 #include 
 
-int main(void)
+int main(int argc, char **argv)
 {
-    float32x4_t v1 = vdupq_n_f32(1.0f), v2 = vdupq_n_f32(2.0f);
+    // passing from untraced pointers to avoid optimizing out any constants
+    // so we can test against the linker.
+    float *src = (float*)argv[argc-1];
+    float32x4_t v1 = vdupq_n_f32(src[0]), v2 = vdupq_n_f32(src[1]);
     int ret = (int)vgetq_lane_f32(vmulq_f32(v1, v2), 0);
 #ifdef __aarch64__
-    float64x2_t vd1 = vdupq_n_f64(1.0), vd2 = vdupq_n_f64(2.0);
+    double *src2 = (double*)argv[argc-2];
+    float64x2_t vd1 = vdupq_n_f64(src2[0]), vd2 = vdupq_n_f64(src2[1]);
     ret += (int)vgetq_lane_f64(vmulq_f64(vd1, vd2), 0);
 #endif
     return ret;
diff --git a/numpy/distutils/checks/cpu_neon_fp16.c b/numpy/distutils/checks/cpu_neon_fp16.c
index 745d2e793c4b..f3b949770db6 100644
--- a/numpy/distutils/checks/cpu_neon_fp16.c
+++ b/numpy/distutils/checks/cpu_neon_fp16.c
@@ -3,9 +3,9 @@
 #endif
 #include 
 
-int main(void)
+int main(int argc, char **argv)
 {
-    short z4[] = {0, 0, 0, 0, 0, 0, 0, 0};
-    float32x4_t v_z4 = vcvt_f32_f16((float16x4_t)vld1_s16((const short*)z4));
+    short *src = (short*)argv[argc-1];
+    float32x4_t v_z4 = vcvt_f32_f16((float16x4_t)vld1_s16(src));
     return (int)vgetq_lane_f32(v_z4, 0);
 }
diff --git a/numpy/distutils/checks/cpu_neon_vfpv4.c b/numpy/distutils/checks/cpu_neon_vfpv4.c
index 45f7b5d69da4..a039159ddeed 100644
--- a/numpy/distutils/checks/cpu_neon_vfpv4.c
+++ b/numpy/distutils/checks/cpu_neon_vfpv4.c
@@ -3,16 +3,18 @@
 #endif
 #include 
 
-int main(void)
+int main(int argc, char **argv)
 {
-    float32x4_t v1 = vdupq_n_f32(1.0f);
-    float32x4_t v2 = vdupq_n_f32(2.0f);
-    float32x4_t v3 = vdupq_n_f32(3.0f);
+    float *src = (float*)argv[argc-1];
+    float32x4_t v1 = vdupq_n_f32(src[0]);
+    float32x4_t v2 = vdupq_n_f32(src[1]);
+    float32x4_t v3 = vdupq_n_f32(src[2]);
     int ret = (int)vgetq_lane_f32(vfmaq_f32(v1, v2, v3), 0);
 #ifdef __aarch64__
-    float64x2_t vd1 = vdupq_n_f64(1.0);
-    float64x2_t vd2 = vdupq_n_f64(2.0);
-    float64x2_t vd3 = vdupq_n_f64(3.0);
+    double *src2 = (double*)argv[argc-2];
+    float64x2_t vd1 = vdupq_n_f64(src2[0]);
+    float64x2_t vd2 = vdupq_n_f64(src2[1]);
+    float64x2_t vd3 = vdupq_n_f64(src2[2]);
     ret += (int)vgetq_lane_f64(vfmaq_f64(vd1, vd2, vd3), 0);
 #endif
     return ret;
diff --git a/numpy/distutils/checks/cpu_vsx4.c b/numpy/distutils/checks/cpu_vsx4.c
new file mode 100644
index 000000000000..a6acc7384dd9
--- /dev/null
+++ b/numpy/distutils/checks/cpu_vsx4.c
@@ -0,0 +1,14 @@
+#ifndef __VSX__
+    #error "VSX is not supported"
+#endif
+#include 
+
+typedef __vector unsigned int v_uint32x4;
+
+int main(void)
+{
+    v_uint32x4 v1 = (v_uint32x4){2, 4, 8, 16};
+    v_uint32x4 v2 = (v_uint32x4){2, 2, 2, 2};
+    v_uint32x4 v3 = vec_mod(v1, v2);
+    return (int)vec_extractm(v3);
+}
diff --git a/numpy/distutils/checks/cpu_vx.c b/numpy/distutils/checks/cpu_vx.c
new file mode 100644
index 000000000000..18fb7ef94a24
--- /dev/null
+++ b/numpy/distutils/checks/cpu_vx.c
@@ -0,0 +1,16 @@
+#if (__VEC__ < 10301) || (__ARCH__ < 11)
+    #error VX not supported
+#endif
+
+#include 
+int main(int argc, char **argv)
+{
+    __vector double x = vec_abs(vec_xl(argc, (double*)argv));
+    __vector double y = vec_load_len((double*)argv, (unsigned int)argc);
+
+    x = vec_round(vec_ceil(x) + vec_floor(y));
+    __vector bool long long m = vec_cmpge(x, y);
+    __vector long long i = vec_signed(vec_sel(x, y, m));
+
+    return (int)vec_extract(i, 0);
+}
diff --git a/numpy/distutils/checks/cpu_vxe.c b/numpy/distutils/checks/cpu_vxe.c
new file mode 100644
index 000000000000..e6933adce3d0
--- /dev/null
+++ b/numpy/distutils/checks/cpu_vxe.c
@@ -0,0 +1,25 @@
+#if (__VEC__ < 10302) || (__ARCH__ < 12)
+    #error VXE not supported
+#endif
+
+#include 
+int main(int argc, char **argv)
+{
+    __vector float x = vec_nabs(vec_xl(argc, (float*)argv));
+    __vector float y = vec_load_len((float*)argv, (unsigned int)argc);
+    
+    x = vec_round(vec_ceil(x) + vec_floor(y));
+    __vector bool int m = vec_cmpge(x, y);
+    x = vec_sel(x, y, m);
+
+    // need to test the existence of intrin "vflls" since vec_doublee
+    // is vec_doublee maps to wrong intrin "vfll".
+    // see https://gcc.gnu.org/bugzilla/show_bug.cgi?id=100871
+#if defined(__GNUC__) && !defined(__clang__)
+    __vector long long i = vec_signed(__builtin_s390_vflls(x));
+#else
+    __vector long long i = vec_signed(vec_doublee(x));
+#endif
+
+    return (int)vec_extract(i, 0);
+}
diff --git a/numpy/distutils/checks/cpu_vxe2.c b/numpy/distutils/checks/cpu_vxe2.c
new file mode 100644
index 000000000000..f36d57129af6
--- /dev/null
+++ b/numpy/distutils/checks/cpu_vxe2.c
@@ -0,0 +1,21 @@
+#if (__VEC__ < 10303) || (__ARCH__ < 13)
+    #error VXE2 not supported
+#endif
+
+#include 
+
+int main(int argc, char **argv)
+{
+    int val;
+    __vector signed short large = { 'a', 'b', 'c', 'a', 'g', 'h', 'g', 'o' };
+    __vector signed short search = { 'g', 'h', 'g', 'o' };
+    __vector unsigned char len = { 0 };
+    __vector unsigned char res = vec_search_string_cc(large, search, len, &val);
+    __vector float x = vec_xl(argc, (float*)argv);
+    __vector int i = vec_signed(x);
+
+    i = vec_srdb(vec_sldb(i, i, 2), i, 3);
+    val += (int)vec_extract(res, 1);
+    val += vec_extract(i, 0);
+    return val;
+}
diff --git a/numpy/distutils/checks/extra_vsx4_mma.c b/numpy/distutils/checks/extra_vsx4_mma.c
new file mode 100644
index 000000000000..a70b2a9f6f95
--- /dev/null
+++ b/numpy/distutils/checks/extra_vsx4_mma.c
@@ -0,0 +1,21 @@
+#ifndef __VSX__
+    #error "VSX is not supported"
+#endif
+#include 
+
+typedef __vector float fv4sf_t;
+typedef __vector unsigned char vec_t;
+
+int main(void)
+{
+    __vector_quad acc0;
+    float a[4] = {0,1,2,3};
+    float b[4] = {0,1,2,3};
+    vec_t *va = (vec_t *) a;
+    vec_t *vb = (vec_t *) b;
+    __builtin_mma_xvf32ger(&acc0, va[0], vb[0]);
+    fv4sf_t result[4];
+    __builtin_mma_disassemble_acc((void *)result, &acc0);
+    fv4sf_t c0 = result[0];
+    return (int)((float*)&c0)[0];
+}
diff --git a/numpy/distutils/command/build.py b/numpy/distutils/command/build.py
index a4fda537d5dc..80830d559c61 100644
--- a/numpy/distutils/command/build.py
+++ b/numpy/distutils/command/build.py
@@ -47,7 +47,8 @@ def initialize_options(self):
             - not part of dispatch-able features(--cpu-dispatch)
             - not supported by compiler or platform
         """
-        self.simd_test = "BASELINE SSE2 SSE42 XOP FMA4 (FMA3 AVX2) AVX512F AVX512_SKX VSX VSX2 VSX3 NEON ASIMD"
+        self.simd_test = "BASELINE SSE2 SSE42 XOP FMA4 (FMA3 AVX2) AVX512F " \
+                         "AVX512_SKX VSX VSX2 VSX3 VSX4 NEON ASIMD VX VXE VXE2"
 
     def finalize_options(self):
         build_scripts = self.build_scripts
diff --git a/numpy/distutils/command/build_ext.py b/numpy/distutils/command/build_ext.py
index 7040a241167c..6dc6b4265f8e 100644
--- a/numpy/distutils/command/build_ext.py
+++ b/numpy/distutils/command/build_ext.py
@@ -231,20 +231,36 @@ def report(copt):
             l = ext.language or self.compiler.detect_language(ext.sources)
             if l:
                 ext_languages.add(l)
+
             # reset language attribute for choosing proper linker
+            #
+            # When we build extensions with multiple languages, we have to
+            # choose a linker. The rules here are:
+            #   1. if there is Fortran code, always prefer the Fortran linker,
+            #   2. otherwise prefer C++ over C,
+            #   3. Users can force a particular linker by using
+            #          `language='c'`  # or 'c++', 'f90', 'f77'
+            #      in their config.add_extension() calls.
             if 'c++' in ext_languages:
                 ext_language = 'c++'
-            elif 'f90' in ext_languages:
+            else:
+                ext_language = 'c'  # default
+
+            has_fortran = False
+            if 'f90' in ext_languages:
                 ext_language = 'f90'
+                has_fortran = True
             elif 'f77' in ext_languages:
                 ext_language = 'f77'
-            else:
-                ext_language = 'c'  # default
-            if l and l != ext_language and ext.language:
-                log.warn('resetting extension %r language from %r to %r.' %
-                         (ext.name, l, ext_language))
-            if not ext.language:
+                has_fortran = True
+
+            if not ext.language or has_fortran:
+                if l and l != ext_language and ext.language:
+                    log.warn('resetting extension %r language from %r to %r.' %
+                             (ext.name, l, ext_language))
+
                 ext.language = ext_language
+
             # global language
             all_languages.update(ext_languages)
 
@@ -377,8 +393,8 @@ def build_extension(self, ext):
             log.info("building '%s' extension", ext.name)
 
         extra_args = ext.extra_compile_args or []
-        extra_cflags = ext.extra_c_compile_args or []
-        extra_cxxflags = ext.extra_cxx_compile_args or []
+        extra_cflags = getattr(ext, 'extra_c_compile_args', None) or []
+        extra_cxxflags = getattr(ext, 'extra_cxx_compile_args', None) or []
 
         macros = ext.define_macros[:]
         for undef in ext.undef_macros:
@@ -570,6 +586,13 @@ def build_extension(self, ext):
             # not using fcompiler linker
             self._libs_with_msvc_and_fortran(
                 fcompiler, libraries, library_dirs)
+            if ext.runtime_library_dirs:
+                # gcc adds RPATH to the link. On windows, copy the dll into
+                # self.extra_dll_dir instead.
+                for d in ext.runtime_library_dirs:
+                    for f in glob(d + '/*.dll'):
+                        copy_file(f, self.extra_dll_dir)
+                ext.runtime_library_dirs = []
 
         elif ext.language in ['f77', 'f90'] and fcompiler is not None:
             linker = fcompiler.link_shared_object
diff --git a/numpy/distutils/command/config.py b/numpy/distutils/command/config.py
index 1f4037bb5c7a..fdb650d36600 100644
--- a/numpy/distutils/command/config.py
+++ b/numpy/distutils/command/config.py
@@ -46,7 +46,7 @@ def _check_compiler (self):
             # XXX: hack to circumvent a python 2.6 bug with msvc9compiler:
             # initialize call query_vcvarsall, which throws an IOError, and
             # causes an error along the way without much information. We try to
-            # catch it here, hoping it is early enough, and print an helpful
+            # catch it here, hoping it is early enough, and print a helpful
             # message instead of Error: None.
             if not self.compiler.initialized:
                 try:
@@ -56,8 +56,7 @@ def _check_compiler (self):
                         Could not initialize compiler instance: do you have Visual Studio
                         installed?  If you are trying to build with MinGW, please use "python setup.py
                         build -c mingw32" instead.  If you have Visual Studio installed, check it is
-                        correctly installed, and the right version (VS 2008 for python 2.6, 2.7 and 3.2,
-                        VS 2010 for >= 3.3).
+                        correctly installed, and the right version (VS 2015 as of this writing).
 
                         Original exception was: %s, and the Compiler class was %s
                         ============================================================================""") \
diff --git a/numpy/distutils/exec_command.py b/numpy/distutils/exec_command.py
index 79998cf5d478..a67453abf624 100644
--- a/numpy/distutils/exec_command.py
+++ b/numpy/distutils/exec_command.py
@@ -276,14 +276,13 @@ def _exec_command(command, use_shell=None, use_tee = None, **env):
     # Inherit environment by default
     env = env or None
     try:
-        # universal_newlines is set to False so that communicate()
+        # text is set to False so that communicate()
         # will return bytes. We need to decode the output ourselves
         # so that Python will not raise a UnicodeDecodeError when
         # it encounters an invalid character; rather, we simply replace it
-        proc = subprocess.Popen(command, shell=use_shell, env=env,
+        proc = subprocess.Popen(command, shell=use_shell, env=env, text=False,
                                 stdout=subprocess.PIPE,
-                                stderr=subprocess.STDOUT,
-                                universal_newlines=False)
+                                stderr=subprocess.STDOUT)
     except OSError:
         # Return 127, as os.spawn*() and /bin/sh do
         return 127, ''
diff --git a/numpy/distutils/fcompiler/__init__.py b/numpy/distutils/fcompiler/__init__.py
index c333517c0f80..ecba3e5d581c 100644
--- a/numpy/distutils/fcompiler/__init__.py
+++ b/numpy/distutils/fcompiler/__init__.py
@@ -527,6 +527,12 @@ def get_flags(tag, flags):
                 ld_so_aix = os.path.join(python_lib, 'config', 'ld_so_aix')
                 python_exp = os.path.join(python_lib, 'config', 'python.exp')
                 linker_so = [ld_so_aix] + linker_so + ['-bI:'+python_exp]
+            if sys.platform.startswith('os400'):
+                from distutils.sysconfig import get_config_var
+                python_config = get_config_var('LIBPL')
+                ld_so_aix = os.path.join(python_config, 'ld_so_aix')
+                python_exp = os.path.join(python_config, 'python.exp')
+                linker_so = [ld_so_aix] + linker_so + ['-bI:'+python_exp]
             self.set_commands(linker_so=linker_so+linker_so_flags)
 
         linker_exe = self.linker_exe
@@ -743,8 +749,9 @@ def wrap_unlinkable_objects(self, objects, output_dir, extra_dll_dir):
     ('win32', ('gnu', 'intelv', 'absoft', 'compaqv', 'intelev', 'gnu95', 'g95',
                'intelvem', 'intelem', 'flang')),
     ('cygwin.*', ('gnu', 'intelv', 'absoft', 'compaqv', 'intelev', 'gnu95', 'g95')),
-    ('linux.*', ('gnu95', 'intel', 'lahey', 'pg', 'nv', 'absoft', 'nag', 'vast', 'compaq',
-                 'intele', 'intelem', 'gnu', 'g95', 'pathf95', 'nagfor', 'fujitsu')),
+    ('linux.*', ('arm', 'gnu95', 'intel', 'lahey', 'pg', 'nv', 'absoft', 'nag',
+                 'vast', 'compaq', 'intele', 'intelem', 'gnu', 'g95', 
+                 'pathf95', 'nagfor', 'fujitsu')),
     ('darwin.*', ('gnu95', 'nag', 'nagfor', 'absoft', 'ibm', 'intel', 'gnu',
                  'g95', 'pg')),
     ('sunos.*', ('sun', 'gnu', 'gnu95', 'g95')),
diff --git a/numpy/distutils/fcompiler/arm.py b/numpy/distutils/fcompiler/arm.py
new file mode 100644
index 000000000000..3eb7e9af9c8c
--- /dev/null
+++ b/numpy/distutils/fcompiler/arm.py
@@ -0,0 +1,71 @@
+import sys                                                                     
+                                                                               
+from numpy.distutils.fcompiler import FCompiler, dummy_fortran_file
+from sys import platform                                                       
+from os.path import join, dirname, normpath
+
+compilers = ['ArmFlangCompiler']
+
+import functools
+
+class ArmFlangCompiler(FCompiler):
+    compiler_type = 'arm'
+    description = 'Arm Compiler'
+    version_pattern = r'\s*Arm.*version (?P[\d.-]+).*'
+
+    ar_exe = 'lib.exe'
+    possible_executables = ['armflang']
+
+    executables = {
+        'version_cmd': ["", "--version"],
+        'compiler_f77': ["armflang", "-fPIC"],
+        'compiler_fix': ["armflang", "-fPIC", "-ffixed-form"],
+        'compiler_f90': ["armflang", "-fPIC"],
+        'linker_so': ["armflang", "-fPIC", "-shared"],
+        'archiver': ["ar", "-cr"],
+        'ranlib':  None
+    }
+
+    pic_flags = ["-fPIC", "-DPIC"]
+    c_compiler = 'arm'
+    module_dir_switch = '-module '  # Don't remove ending space!
+
+    def get_libraries(self):
+        opt = FCompiler.get_libraries(self)
+        opt.extend(['flang', 'flangrti', 'ompstub'])
+        return opt
+
+    @functools.lru_cache(maxsize=128)
+    def get_library_dirs(self):
+        """List of compiler library directories."""
+        opt = FCompiler.get_library_dirs(self)
+        flang_dir = dirname(self.executables['compiler_f77'][0])
+        opt.append(normpath(join(flang_dir, '..', 'lib')))
+
+        return opt
+
+    def get_flags(self):
+        return []
+
+    def get_flags_free(self):
+        return []
+
+    def get_flags_debug(self):
+        return ['-g']
+
+    def get_flags_opt(self):
+        return ['-O3']
+
+    def get_flags_arch(self):
+        return []
+
+    def runtime_library_dir_option(self, dir):
+        return '-Wl,-rpath=%s' % dir
+
+
+if __name__ == '__main__':
+    from distutils import log
+    log.set_verbosity(2)
+    from numpy.distutils import customized_fcompiler
+    print(customized_fcompiler(compiler='armflang').get_version())
+
diff --git a/numpy/distutils/fcompiler/gnu.py b/numpy/distutils/fcompiler/gnu.py
index 39178071d511..3472b5d4c095 100644
--- a/numpy/distutils/fcompiler/gnu.py
+++ b/numpy/distutils/fcompiler/gnu.py
@@ -256,7 +256,7 @@ def runtime_library_dir_option(self, dir):
 
         if sys.platform == 'darwin':
             return f'-Wl,-rpath,{dir}'
-        elif sys.platform[:3] == 'aix':
+        elif sys.platform.startswith(('aix', 'os400')):
             # AIX RPATH is called LIBPATH
             return f'-Wl,-blibpath:{dir}'
         else:
@@ -305,7 +305,7 @@ def version_match(self, version_string):
     module_dir_switch = '-J'
     module_include_switch = '-I'
 
-    if sys.platform[:3] == 'aix':
+    if sys.platform.startswith(('aix', 'os400')):
         executables['linker_so'].append('-lpthread')
         if platform.architecture()[0][:2] == '64':
             for key in ['compiler_f77', 'compiler_f90','compiler_fix','linker_so', 'linker_exe']:
@@ -324,7 +324,7 @@ def _universal_flags(self, cmd):
             c_archs[c_archs.index("i386")] = "i686"
         # check the arches the Fortran compiler supports, and compare with
         # arch flags from C compiler
-        for arch in ["ppc", "i686", "x86_64", "ppc64"]:
+        for arch in ["ppc", "i686", "x86_64", "ppc64", "s390x"]:
             if _can_target(cmd, arch) and arch in c_archs:
                 arch_flags.extend(["-arch", arch])
         return arch_flags
@@ -382,7 +382,13 @@ def get_libraries(self):
 
     def get_target(self):
         try:
-            output = subprocess.check_output(self.compiler_f77 + ['-v'])
+            p = subprocess.Popen(
+                self.compiler_f77 + ['-v'],
+                stdin=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+            stdout, stderr = p.communicate()
+            output = (stdout or b"") + (stderr or b"")
         except (OSError, subprocess.CalledProcessError):
             pass
         else:
diff --git a/numpy/distutils/fcompiler/intel.py b/numpy/distutils/fcompiler/intel.py
index f97c5b3483e1..1d6065904110 100644
--- a/numpy/distutils/fcompiler/intel.py
+++ b/numpy/distutils/fcompiler/intel.py
@@ -154,7 +154,8 @@ def update_executables(self):
     module_include_switch = '/I'
 
     def get_flags(self):
-        opt = ['/nologo', '/MD', '/nbs', '/names:lowercase', '/assume:underscore']
+        opt = ['/nologo', '/MD', '/nbs', '/names:lowercase', 
+               '/assume:underscore', '/fpp']
         return opt
 
     def get_flags_free(self):
diff --git a/numpy/distutils/lib2def.py b/numpy/distutils/lib2def.py
index 820ed71f5808..851682c63310 100644
--- a/numpy/distutils/lib2def.py
+++ b/numpy/distutils/lib2def.py
@@ -64,7 +64,7 @@ def getnm(nm_cmd=['nm', '-Cs', 'python%s.lib' % py_ver], shell=True):
 
 nm_output = getnm(nm_cmd = 'nm -Cs py_lib')"""
     p = subprocess.Popen(nm_cmd, shell=shell, stdout=subprocess.PIPE,
-                         stderr=subprocess.PIPE, universal_newlines=True)
+                         stderr=subprocess.PIPE, text=True)
     nm_output, nm_err = p.communicate()
     if p.returncode != 0:
         raise RuntimeError('failed to run "%s": "%s"' % (
diff --git a/numpy/distutils/mingw32ccompiler.py b/numpy/distutils/mingw32ccompiler.py
index fbe3655c965c..5d1c27a651f2 100644
--- a/numpy/distutils/mingw32ccompiler.py
+++ b/numpy/distutils/mingw32ccompiler.py
@@ -37,9 +37,6 @@ def get_msvcr_replacement():
     msvcr = msvc_runtime_library()
     return [] if msvcr is None else [msvcr]
 
-# monkey-patch cygwinccompiler with our updated version from misc_util
-# to avoid getting an exception raised on Python 3.5
-distutils.cygwinccompiler.get_msvcr = get_msvcr_replacement
 
 # Useful to generate table of symbols from a dll
 _START = re.compile(r'\[Ordinal/Name Pointer\] Table')
@@ -187,14 +184,11 @@ def find_python_dll():
     # We can't do much here:
     # - find it in the virtualenv (sys.prefix)
     # - find it in python main dir (sys.base_prefix, if in a virtualenv)
-    # - sys.real_prefix is main dir for virtualenvs in Python 2.7
     # - in system32,
     # - ortherwise (Sxs), I don't know how to get it.
     stems = [sys.prefix]
-    if hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix:
+    if sys.base_prefix != sys.prefix:
         stems.append(sys.base_prefix)
-    elif hasattr(sys, 'real_prefix') and sys.real_prefix != sys.prefix:
-        stems.append(sys.real_prefix)
 
     sub_dirs = ['', 'lib', 'bin']
     # generate possible combinations of directory trees and sub-directories
@@ -215,7 +209,7 @@ def find_python_dll():
     elif implementation == 'PyPy':
         dllname = f'libpypy{major_version}-c.dll'
     else:
-        dllname = 'Unknown platform {implementation}' 
+        dllname = f'Unknown platform {implementation}' 
     print("Looking for %s" % dllname)
     for folder in lib_dirs:
         dll = os.path.join(folder, dllname)
diff --git a/numpy/distutils/misc_util.py b/numpy/distutils/misc_util.py
index f0f9b4bd7ce4..79ba08515452 100644
--- a/numpy/distutils/misc_util.py
+++ b/numpy/distutils/misc_util.py
@@ -31,8 +31,6 @@ def clean_up_temporary_directory():
 
 atexit.register(clean_up_temporary_directory)
 
-from numpy.compat import npy_load_module
-
 __all__ = ['Configuration', 'get_numpy_include_dirs', 'default_config_dict',
            'dict_append', 'appendpath', 'generate_config_py',
            'get_cmd', 'allpath', 'get_mathlibs',
@@ -44,7 +42,8 @@ def clean_up_temporary_directory():
            'dot_join', 'get_frame', 'minrelpath', 'njoin',
            'is_sequence', 'is_string', 'as_list', 'gpaths', 'get_language',
            'get_build_architecture', 'get_info', 'get_pkg_info',
-           'get_num_build_jobs', 'sanitize_cxx_flags']
+           'get_num_build_jobs', 'sanitize_cxx_flags',
+           'exec_mod_from_location']
 
 class InstallableLib:
     """
@@ -359,7 +358,7 @@ def colour_text(s, fg=None, bg=None, bold=False):
             fgcode = 30 + _colour_codes.get(fg.lower(), 0)
             seq.append(str(fgcode))
         if bg:
-            bgcode = 40 + _colour_codes.get(fg.lower(), 7)
+            bgcode = 40 + _colour_codes.get(bg.lower(), 7)
             seq.append(str(bgcode))
         if seq:
             return '\x1b[%sm%s\x1b[0m' % (';'.join(seq), s)
@@ -417,7 +416,7 @@ def cyg2win32(path: str) -> str:
     if sys.platform != "cygwin":
         return path
     return subprocess.check_output(
-        ["/usr/bin/cygpath", "--windows", path], universal_newlines=True
+        ["/usr/bin/cygpath", "--windows", path], text=True
     )
 
 
@@ -695,15 +694,11 @@ def get_shared_lib_extension(is_python_ext=False):
     -----
     For Python shared libs, `so_ext` will typically be '.so' on Linux and OS X,
     and '.pyd' on Windows.  For Python >= 3.2 `so_ext` has a tag prepended on
-    POSIX systems according to PEP 3149.  For Python 3.2 this is implemented on
-    Linux, but not on OS X.
+    POSIX systems according to PEP 3149.
 
     """
     confvars = distutils.sysconfig.get_config_vars()
-    # SO is deprecated in 3.3.1, use EXT_SUFFIX instead
-    so_ext = confvars.get('EXT_SUFFIX', None)
-    if so_ext is None:
-        so_ext = confvars.get('SO', '')
+    so_ext = confvars.get('EXT_SUFFIX', '')
 
     if not is_python_ext:
         # hardcode known values, config vars (including SHLIB_SUFFIX) are
@@ -945,9 +940,8 @@ def _get_configuration_from_setup_py(self, setup_py,
         try:
             setup_name = os.path.splitext(os.path.basename(setup_py))[0]
             n = dot_join(self.name, subpackage_name, setup_name)
-            setup_module = npy_load_module('_'.join(n.split('.')),
-                                           setup_py,
-                                           ('.py', 'U', 1))
+            setup_module = exec_mod_from_location(
+                                '_'.join(n.split('.')), setup_py)
             if not hasattr(setup_module, 'configuration'):
                 if not self.options['assume_default_configuration']:
                     self.warn('Assuming default configuration '\
@@ -1993,8 +1987,8 @@ def get_version(self, version_file=None, version_variable=None):
                 name = os.path.splitext(os.path.basename(fn))[0]
                 n = dot_join(self.name, name)
                 try:
-                    version_module = npy_load_module('_'.join(n.split('.')),
-                                                     fn, info)
+                    version_module = exec_mod_from_location(
+                                        '_'.join(n.split('.')), fn)
                 except ImportError as e:
                     self.warn(str(e))
                     version_module = None
@@ -2354,11 +2348,7 @@ def generate_config_py(target):
             extra_dll_dir = os.path.join(os.path.dirname(__file__), '.libs')
 
             if sys.platform == 'win32' and os.path.isdir(extra_dll_dir):
-                if sys.version_info >= (3, 8):
-                    os.add_dll_directory(extra_dll_dir)
-                else:
-                    os.environ.setdefault('PATH', '')
-                    os.environ['PATH'] += os.pathsep + extra_dll_dir
+                os.add_dll_directory(extra_dll_dir)
 
             """))
 
@@ -2481,7 +2471,7 @@ def get_build_architecture():
     return get_build_architecture()
 
 
-_cxx_ignore_flags = {'-Werror=implicit-function-declaration'}
+_cxx_ignore_flags = {'-Werror=implicit-function-declaration', '-std=c99'}
 
 
 def sanitize_cxx_flags(cxxflags):
@@ -2491,3 +2481,13 @@ def sanitize_cxx_flags(cxxflags):
     return [flag for flag in cxxflags if flag not in _cxx_ignore_flags]
 
 
+def exec_mod_from_location(modname, modfile):
+    '''
+    Use importlib machinery to import a module `modname` from the file
+    `modfile`. Depending on the `spec.loader`, the module may not be
+    registered in sys.modules.
+    '''
+    spec = importlib.util.spec_from_file_location(modname, modfile)
+    foo = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(foo)
+    return foo
diff --git a/numpy/distutils/msvccompiler.py b/numpy/distutils/msvccompiler.py
index 681a254b87ee..2b93221baac8 100644
--- a/numpy/distutils/msvccompiler.py
+++ b/numpy/distutils/msvccompiler.py
@@ -56,3 +56,21 @@ def initialize(self):
         if platform_bits == 32:
             self.compile_options += ['/arch:SSE2']
             self.compile_options_debug += ['/arch:SSE2']
+
+
+def lib_opts_if_msvc(build_cmd):
+    """ Add flags if we are using MSVC compiler
+
+    We can't see `build_cmd` in our scope, because we have not initialized
+    the distutils build command, so use this deferred calculation to run
+    when we are building the library.
+    """
+    if build_cmd.compiler.compiler_type != 'msvc':
+        return []
+    # Explicitly disable whole-program optimization.
+    flags = ['/GL-']
+    # Disable voltbl section for vc142 to allow link using mingw-w64; see:
+    # https://github.com/matthew-brett/dll_investigation/issues/1#issuecomment-1100468171
+    if build_cmd.compiler_opt.cc_test_flags(['-d2VolatileMetadata-']):
+        flags.append('-d2VolatileMetadata-')
+    return flags
diff --git a/numpy/distutils/system_info.py b/numpy/distutils/system_info.py
index 7f41bb07e06c..d5a1687da322 100644
--- a/numpy/distutils/system_info.py
+++ b/numpy/distutils/system_info.py
@@ -501,7 +501,11 @@ def get_info(name, notfound_action=0):
       1 - display warning message
       2 - raise error
     """
-    cl = {'atlas': atlas_info,  # use lapack_opt or blas_opt instead
+    cl = {'armpl': armpl_info,
+          'blas_armpl': blas_armpl_info,
+          'lapack_armpl': lapack_armpl_info,
+          'fftw3_armpl': fftw3_armpl_info,
+          'atlas': atlas_info,  # use lapack_opt or blas_opt instead
           'atlas_threads': atlas_threads_info,                # ditto
           'atlas_blas': atlas_blas_info,
           'atlas_blas_threads': atlas_blas_threads_info,
@@ -1152,6 +1156,16 @@ class fftw3_info(fftw_info):
                     'macros':[('SCIPY_FFTW3_H', None)]},
                   ]
 
+    
+class fftw3_armpl_info(fftw_info):
+    section = 'fftw3'
+    dir_env_var = 'ARMPL_DIR'
+    notfounderror = FFTWNotFoundError
+    ver_info = [{'name': 'fftw3',
+                    'libs': ['armpl_lp64_mp'],
+                    'includes': ['fftw3.h'],
+                    'macros': [('SCIPY_FFTW3_H', None)]}]
+
 
 class dfftw_info(fftw_info):
     section = 'fftw'
@@ -1311,6 +1325,31 @@ class blas_mkl_info(mkl_info):
     pass
 
 
+class armpl_info(system_info):
+    section = 'armpl'
+    dir_env_var = 'ARMPL_DIR'
+    _lib_armpl = ['armpl_lp64_mp']
+
+    def calc_info(self):
+        lib_dirs = self.get_lib_dirs()
+        incl_dirs = self.get_include_dirs()
+        armpl_libs = self.get_libs('armpl_libs', self._lib_armpl)
+        info = self.check_libs2(lib_dirs, armpl_libs)
+        if info is None:
+            return
+        dict_append(info,
+                    define_macros=[('SCIPY_MKL_H', None),
+                                   ('HAVE_CBLAS', None)],
+                    include_dirs=incl_dirs)
+        self.set_info(**info)
+
+class lapack_armpl_info(armpl_info):
+    pass
+
+class blas_armpl_info(armpl_info):
+    pass
+
+
 class atlas_info(system_info):
     section = 'atlas'
     dir_env_var = 'ATLAS'
@@ -1748,9 +1787,16 @@ class lapack_opt_info(system_info):
     notfounderror = LapackNotFoundError
 
     # List of all known LAPACK libraries, in the default order
-    lapack_order = ['mkl', 'openblas', 'flame',
+    lapack_order = ['armpl', 'mkl', 'openblas', 'flame',
                     'accelerate', 'atlas', 'lapack']
     order_env_var_name = 'NPY_LAPACK_ORDER'
+    
+    def _calc_info_armpl(self):
+        info = get_info('lapack_armpl')
+        if info:
+            self.set_info(**info)
+            return True
+        return False
 
     def _calc_info_mkl(self):
         info = get_info('lapack_mkl')
@@ -1925,9 +1971,16 @@ class blas_opt_info(system_info):
     notfounderror = BlasNotFoundError
     # List of all known BLAS libraries, in the default order
 
-    blas_order = ['mkl', 'blis', 'openblas',
+    blas_order = ['armpl', 'mkl', 'blis', 'openblas',
                   'accelerate', 'atlas', 'blas']
     order_env_var_name = 'NPY_BLAS_ORDER'
+    
+    def _calc_info_armpl(self):
+        info = get_info('blas_armpl')
+        if info:
+            self.set_info(**info)
+            return True
+        return False
 
     def _calc_info_mkl(self):
         info = get_info('blas_mkl')
diff --git a/numpy/distutils/tests/test_build_ext.py b/numpy/distutils/tests/test_build_ext.py
index c007159f520e..372100fc06c8 100644
--- a/numpy/distutils/tests/test_build_ext.py
+++ b/numpy/distutils/tests/test_build_ext.py
@@ -5,7 +5,9 @@
 import sys
 from textwrap import indent, dedent
 import pytest
+from numpy.testing import IS_WASM
 
+@pytest.mark.skipif(IS_WASM, reason="cannot start subprocess in wasm")
 @pytest.mark.slow
 def test_multi_fortran_libs_link(tmp_path):
     '''
diff --git a/numpy/distutils/tests/test_ccompiler_opt.py b/numpy/distutils/tests/test_ccompiler_opt.py
index 1b27ab07c393..657ebdb68512 100644
--- a/numpy/distutils/tests/test_ccompiler_opt.py
+++ b/numpy/distutils/tests/test_ccompiler_opt.py
@@ -32,6 +32,7 @@ def assert_(expr, msg=''):
     ppc64le = ("gcc", "clang"),
     armhf = ("gcc", "clang"),
     aarch64 = ("gcc", "clang"),
+    s390x = ("gcc", "clang"),
     noarch = ("gcc",)
 )
 
@@ -77,7 +78,7 @@ class _Test_CCompilerOpt:
     arch = None # x86_64
     cc   = None # gcc
 
-    def setup(self):
+    def setup_class(self):
         FakeCCompilerOpt.conf_nocache = True
         self._opt = None
 
@@ -382,18 +383,19 @@ def test_args_options(self):
             if o == "native" and self.cc_name() == "msvc":
                 continue
             self.expect(o,
-                trap_files=".*cpu_(sse|vsx|neon).c",
-                x86="", ppc64="", armhf=""
+                trap_files=".*cpu_(sse|vsx|neon|vx).c",
+                x86="", ppc64="", armhf="", s390x=""
             )
             self.expect(o,
-                trap_files=".*cpu_(sse3|vsx2|neon_vfpv4).c",
+                trap_files=".*cpu_(sse3|vsx2|neon_vfpv4|vxe).c",
                 x86="sse sse2", ppc64="vsx", armhf="neon neon_fp16",
-                aarch64="", ppc64le=""
+                aarch64="", ppc64le="", s390x="vx"
             )
             self.expect(o,
                 trap_files=".*cpu_(popcnt|vsx3).c",
                 x86="sse .* sse41", ppc64="vsx vsx2",
-                armhf="neon neon_fp16 .* asimd .*"
+                armhf="neon neon_fp16 .* asimd .*",
+                s390x="vx vxe vxe2"
             )
             self.expect(o,
                 x86_gcc=".* xop fma4 .* avx512f .* avx512_knl avx512_knm avx512_skx .*",
@@ -403,13 +405,14 @@ def test_args_options(self):
                 # in msvc, avx512_knl avx512_knm aren't supported
                 x86_msvc=".* xop fma4 .* avx512f .* avx512_skx .*",
                 armhf=".* asimd asimdhp asimddp .*",
-                ppc64="vsx vsx2 vsx3.*"
+                ppc64="vsx vsx2 vsx3 vsx4.*",
+                s390x="vx vxe vxe2.*"
             )
         # min
         self.expect("min",
             x86="sse sse2", x64="sse sse2 sse3",
             armhf="", aarch64="neon neon_fp16 .* asimd",
-            ppc64="", ppc64le="vsx vsx2"
+            ppc64="", ppc64le="vsx vsx2", s390x=""
         )
         self.expect(
             "min", trap_files=".*cpu_(sse2|vsx2).c",
@@ -420,7 +423,7 @@ def test_args_options(self):
         try:
             self.expect("native",
                 trap_flags=".*(-march=native|-xHost|/QxHost).*",
-                x86=".*", ppc64=".*", armhf=".*"
+                x86=".*", ppc64=".*", armhf=".*", s390x=".*"
             )
             if self.march() != "unknown":
                 raise AssertionError(
@@ -432,14 +435,15 @@ def test_args_options(self):
 
     def test_flags(self):
         self.expect_flags(
-            "sse sse2 vsx vsx2 neon neon_fp16",
+            "sse sse2 vsx vsx2 neon neon_fp16 vx vxe",
             x86_gcc="-msse -msse2", x86_icc="-msse -msse2",
             x86_iccw="/arch:SSE2",
             x86_msvc="/arch:SSE2" if self.march() == "x86" else "",
             ppc64_gcc= "-mcpu=power8",
             ppc64_clang="-maltivec -mvsx -mpower8-vector",
             armhf_gcc="-mfpu=neon-fp16 -mfp16-format=ieee",
-            aarch64=""
+            aarch64="",
+            s390x="-mzvector -march=arch12"
         )
         # testing normalize -march
         self.expect_flags(
@@ -463,6 +467,10 @@ def test_flags(self):
             "asimddp asimdhp asimdfhm",
             aarch64_gcc=r"-march=armv8.2-a\+dotprod\+fp16\+fp16fml"
         )
+        self.expect_flags(
+            "vx vxe vxe2",
+            s390x=r"-mzvector -march=arch13"
+        )
 
     def test_targets_exceptions(self):
         for targets in (
@@ -484,7 +492,7 @@ def test_targets_exceptions(self):
             try:
                 self.expect_targets(
                     targets,
-                    x86="", armhf="", ppc64=""
+                    x86="", armhf="", ppc64="", s390x=""
                 )
                 if self.march() != "unknown":
                     raise AssertionError(
@@ -496,26 +504,26 @@ def test_targets_exceptions(self):
 
     def test_targets_syntax(self):
         for targets in (
-            "/*@targets $keep_baseline sse vsx neon*/",
-            "/*@targets,$keep_baseline,sse,vsx,neon*/",
-            "/*@targets*$keep_baseline*sse*vsx*neon*/",
+            "/*@targets $keep_baseline sse vsx neon vx*/",
+            "/*@targets,$keep_baseline,sse,vsx,neon vx*/",
+            "/*@targets*$keep_baseline*sse*vsx*neon*vx*/",
             """
             /*
             ** @targets
-            ** $keep_baseline, sse vsx,neon
+            ** $keep_baseline, sse vsx,neon, vx
             */
             """,
             """
             /*
-            ************@targets*************
-            ** $keep_baseline, sse vsx, neon
-            *********************************
+            ************@targets****************
+            ** $keep_baseline, sse vsx, neon, vx
+            ************************************
             */
             """,
             """
             /*
             /////////////@targets/////////////////
-            //$keep_baseline//sse//vsx//neon
+            //$keep_baseline//sse//vsx//neon//vx
             /////////////////////////////////////
             */
             """,
@@ -523,11 +531,11 @@ def test_targets_syntax(self):
             /*
             @targets
             $keep_baseline
-            SSE VSX NEON*/
+            SSE VSX NEON VX*/
             """
         ) :
             self.expect_targets(targets,
-                x86="sse", ppc64="vsx", armhf="neon", unknown=""
+                x86="sse", ppc64="vsx", armhf="neon", s390x="vx", unknown=""
             )
 
     def test_targets(self):
@@ -536,37 +544,42 @@ def test_targets(self):
             """
             /*@targets
                 sse sse2 sse41 avx avx2 avx512f
-                vsx vsx2 vsx3
+                vsx vsx2 vsx3 vsx4
                 neon neon_fp16 asimdhp asimddp
+                vx vxe vxe2
             */
             """,
-            baseline="avx vsx2 asimd",
-            x86="avx512f avx2", armhf="asimddp asimdhp", ppc64="vsx3"
+            baseline="avx vsx2 asimd vx vxe",
+            x86="avx512f avx2", armhf="asimddp asimdhp", ppc64="vsx4 vsx3",
+            s390x="vxe2"
         )
         # test skipping non-dispatch features
         self.expect_targets(
             """
             /*@targets
                 sse41 avx avx2 avx512f
-                vsx2 vsx3
+                vsx2 vsx3 vsx4
                 asimd asimdhp asimddp
+                vx vxe vxe2
             */
             """,
-            baseline="", dispatch="sse41 avx2 vsx2 asimd asimddp",
-            x86="avx2 sse41", armhf="asimddp asimd", ppc64="vsx2"
+            baseline="", dispatch="sse41 avx2 vsx2 asimd asimddp vxe2",
+            x86="avx2 sse41", armhf="asimddp asimd", ppc64="vsx2", s390x="vxe2"
         )
         # test skipping features that not supported
         self.expect_targets(
             """
             /*@targets
                 sse2 sse41 avx2 avx512f
-                vsx2 vsx3
+                vsx2 vsx3 vsx4
                 neon asimdhp asimddp
+                vx vxe vxe2
             */
             """,
             baseline="",
-            trap_files=".*(avx2|avx512f|vsx3|asimddp).c",
-            x86="sse41 sse2", ppc64="vsx2", armhf="asimdhp neon"
+            trap_files=".*(avx2|avx512f|vsx3|vsx4|asimddp|vxe2).c",
+            x86="sse41 sse2", ppc64="vsx2", armhf="asimdhp neon",
+            s390x="vxe vx"
         )
         # test skipping features that implies each other
         self.expect_targets(
@@ -598,14 +611,16 @@ def test_targets_policies(self):
                 sse2 sse42 avx2 avx512f
                 vsx2 vsx3
                 neon neon_vfpv4 asimd asimddp
+                vx vxe vxe2
             */
             """,
-            baseline="sse41 avx2 vsx2 asimd vsx3",
+            baseline="sse41 avx2 vsx2 asimd vsx3 vxe",
             x86="avx512f avx2 sse42 sse2",
             ppc64="vsx3 vsx2",
             armhf="asimddp asimd neon_vfpv4 neon",
             # neon, neon_vfpv4, asimd implies each other
-            aarch64="asimddp asimd"
+            aarch64="asimddp asimd",
+            s390x="vxe2 vxe vx"
         )
         # 'keep_sort', leave the sort as-is
         self.expect_targets(
@@ -615,13 +630,15 @@ def test_targets_policies(self):
                 avx512f sse42 avx2 sse2
                 vsx2 vsx3
                 asimd neon neon_vfpv4 asimddp
+                vxe vxe2
             */
             """,
             x86="avx512f sse42 avx2 sse2",
             ppc64="vsx2 vsx3",
             armhf="asimd neon neon_vfpv4 asimddp",
             # neon, neon_vfpv4, asimd implies each other
-            aarch64="asimd asimddp"
+            aarch64="asimd asimddp",
+            s390x="vxe vxe2"
         )
         # 'autovec', skipping features that can't be
         # vectorized by the compiler
@@ -736,11 +753,13 @@ def test_targets_multi(self):
                 (sse41 avx sse42) (sse3 avx2 avx512f)
                 (vsx vsx3 vsx2)
                 (asimddp neon neon_vfpv4 asimd asimdhp)
+                (vx vxe vxe2)
             */
             """,
             x86="avx avx512f",
             ppc64="vsx3",
             armhf=r"\(asimdhp asimddp\)",
+            s390x="vxe2"
         )
         # test compiler variety and avoiding duplicating
         self.expect_targets(
@@ -761,7 +780,7 @@ class TestCCompilerOpt_{class_name}(_Test_CCompilerOpt, unittest.TestCase):
         cc   = '{cc}'
         def __init__(self, methodName="runTest"):
             unittest.TestCase.__init__(self, methodName)
-            self.setup()
+            self.setup_class()
     """).format(
         class_name=arch + '_' + cc, arch=arch, cc=cc
     )
diff --git a/numpy/distutils/tests/test_ccompiler_opt_conf.py b/numpy/distutils/tests/test_ccompiler_opt_conf.py
index 09c1fad40c54..d9e8b2b0a834 100644
--- a/numpy/distutils/tests/test_ccompiler_opt_conf.py
+++ b/numpy/distutils/tests/test_ccompiler_opt_conf.py
@@ -161,9 +161,9 @@ def test_extra_checks(self, error_msg, search_in, feature_name, feature_dict):
 class TestConfFeatures(unittest.TestCase):
     def __init__(self, methodName="runTest"):
         unittest.TestCase.__init__(self, methodName)
-        self.setup()
+        self._setup()
 
-    def setup(self):
+    def _setup(self):
         FakeCCompilerOpt.conf_nocache = True
 
     def test_features(self):
diff --git a/numpy/distutils/tests/test_exec_command.py b/numpy/distutils/tests/test_exec_command.py
index d6eb7d1c3f27..d1a20056a5a2 100644
--- a/numpy/distutils/tests/test_exec_command.py
+++ b/numpy/distutils/tests/test_exec_command.py
@@ -1,10 +1,12 @@
 import os
+import pytest
 import sys
 from tempfile import TemporaryFile
 
 from numpy.distutils import exec_command
 from numpy.distutils.exec_command import get_pythonexe
-from numpy.testing import tempdir, assert_, assert_warns
+from numpy.testing import tempdir, assert_, assert_warns, IS_WASM
+
 
 # In python 3 stdout, stderr are text (unicode compliant) devices, so to
 # emulate them import StringIO from the io module.
@@ -93,8 +95,9 @@ def test_exec_command_stderr():
                         exec_command.exec_command("cd '.'")
 
 
+@pytest.mark.skipif(IS_WASM, reason="Cannot start subprocess")
 class TestExecCommand:
-    def setup(self):
+    def setup_method(self):
         self.pyexe = get_pythonexe()
 
     def check_nt(self, **kws):
diff --git a/numpy/distutils/tests/test_log.py b/numpy/distutils/tests/test_log.py
index 36f49f592c39..72fddf37370f 100644
--- a/numpy/distutils/tests/test_log.py
+++ b/numpy/distutils/tests/test_log.py
@@ -8,7 +8,9 @@
 
 
 def setup_module():
-    log.set_verbosity(2, force=True)  # i.e. DEBUG
+    f = io.StringIO()  # changing verbosity also logs here, capture that
+    with redirect_stdout(f):
+        log.set_verbosity(2, force=True)  # i.e. DEBUG
 
 
 def teardown_module():
diff --git a/numpy/distutils/tests/test_shell_utils.py b/numpy/distutils/tests/test_shell_utils.py
index 32bd283e56b6..696d38ddd66a 100644
--- a/numpy/distutils/tests/test_shell_utils.py
+++ b/numpy/distutils/tests/test_shell_utils.py
@@ -4,6 +4,7 @@
 import sys
 
 from numpy.distutils import _shell_utils
+from numpy.testing import IS_WASM
 
 argv_cases = [
     [r'exe'],
@@ -49,6 +50,7 @@ def runner(Parser):
         raise NotImplementedError
 
 
+@pytest.mark.skipif(IS_WASM, reason="Cannot start subprocess")
 @pytest.mark.parametrize('argv', argv_cases)
 def test_join_matches_subprocess(Parser, runner, argv):
     """
@@ -64,6 +66,7 @@ def test_join_matches_subprocess(Parser, runner, argv):
     assert json.loads(json_out) == argv
 
 
+@pytest.mark.skipif(IS_WASM, reason="Cannot start subprocess")
 @pytest.mark.parametrize('argv', argv_cases)
 def test_roundtrip(Parser, argv):
     """
diff --git a/numpy/distutils/tests/test_system_info.py b/numpy/distutils/tests/test_system_info.py
index 8c26271af782..eb7235e04620 100644
--- a/numpy/distutils/tests/test_system_info.py
+++ b/numpy/distutils/tests/test_system_info.py
@@ -130,7 +130,7 @@ class DuplicateOptionInfo(_system_info):
 
 class TestSystemInfoReading:
 
-    def setup(self):
+    def setup_method(self):
         """ Create the libraries """
         # Create 2 sources and 2 libraries
         self._dir1 = mkdtemp()
@@ -171,8 +171,7 @@ def site_and_parse(c, site_cfg):
         self.c_dup_options = site_and_parse(get_class('duplicate_options'),
                                             self._sitecfg)
 
-
-    def teardown(self):
+    def teardown_method(self):
         # Do each removal separately
         try:
             shutil.rmtree(self._dir1)
diff --git a/numpy/doc/ufuncs.py b/numpy/doc/ufuncs.py
index eecc15083d53..c99e9abc99a5 100644
--- a/numpy/doc/ufuncs.py
+++ b/numpy/doc/ufuncs.py
@@ -75,7 +75,7 @@
  >>> np.add.reduce(np.arange(10).reshape(2,5),axis=1)
  array([10, 35])
 
-**.accumulate(arr)** applies the binary operator and generates an an
+**.accumulate(arr)** applies the binary operator and generates an
 equivalently shaped array that includes the accumulated amount for each
 element of the array. A couple examples: ::
 
diff --git a/numpy/f2py/__init__.py b/numpy/f2py/__init__.py
index f147f1b970a3..dbe3df27f6ec 100644
--- a/numpy/f2py/__init__.py
+++ b/numpy/f2py/__init__.py
@@ -47,11 +47,11 @@ def compile(source,
     source_fn : str, optional
         Name of the file where the fortran source is written.
         The default is to use a temporary file with the extension
-        provided by the `extension` parameter
-    extension : {'.f', '.f90'}, optional
+        provided by the ``extension`` parameter
+    extension : ``{'.f', '.f90'}``, optional
         Filename extension if `source_fn` is not provided.
         The extension tells which fortran standard is used.
-        The default is `.f`, which implies F77 standard.
+        The default is ``.f``, which implies F77 standard.
 
         .. versionadded:: 1.11.0
 
@@ -104,8 +104,7 @@ def compile(source,
              '-c',
              'import numpy.f2py as f2py2e;f2py2e.main()'] + args
         try:
-            cp = subprocess.run(c, stdout=subprocess.PIPE,
-                                   stderr=subprocess.PIPE)
+            cp = subprocess.run(c, capture_output=True)
         except OSError:
             # preserve historic status code used by exec_command()
             cp = subprocess.CompletedProcess(c, 127, stdout=b'', stderr=b'')
@@ -124,7 +123,7 @@ def compile(source,
 
 def get_include():
     """
-    Return the directory that contains the fortranobject.c and .h files.
+    Return the directory that contains the ``fortranobject.c`` and ``.h`` files.
 
     .. note::
 
@@ -145,21 +144,21 @@ def get_include():
 
     Notes
     -----
-    .. versionadded:: 1.22.0
+    .. versionadded:: 1.21.1
 
     Unless the build system you are using has specific support for f2py,
     building a Python extension using a ``.pyf`` signature file is a two-step
     process. For a module ``mymod``:
 
-        - Step 1: run ``python -m numpy.f2py mymod.pyf --quiet``. This
-          generates ``_mymodmodule.c`` and (if needed)
-          ``_fblas-f2pywrappers.f`` files next to ``mymod.pyf``.
-        - Step 2: build your Python extension module. This requires the
-          following source files:
+    * Step 1: run ``python -m numpy.f2py mymod.pyf --quiet``. This
+      generates ``_mymodmodule.c`` and (if needed)
+      ``_fblas-f2pywrappers.f`` files next to ``mymod.pyf``.
+    * Step 2: build your Python extension module. This requires the
+      following source files:
 
-              - ``_mymodmodule.c``
-              - ``_mymod-f2pywrappers.f`` (if it was generated in step 1)
-              - ``fortranobject.c``
+      * ``_mymodmodule.c``
+      * ``_mymod-f2pywrappers.f`` (if it was generated in Step 1)
+      * ``fortranobject.c``
 
     See Also
     --------
@@ -169,32 +168,19 @@ def get_include():
     return os.path.join(os.path.dirname(__file__), 'src')
 
 
-if sys.version_info[:2] >= (3, 7):
-    # module level getattr is only supported in 3.7 onwards
-    # https://www.python.org/dev/peps/pep-0562/
-    def __getattr__(attr):
+def __getattr__(attr):
 
-        # Avoid importing things that aren't needed for building
-        # which might import the main numpy module
-        if attr == "f2py_testing":
-            import numpy.f2py.f2py_testing as f2py_testing
-            return f2py_testing
+    # Avoid importing things that aren't needed for building
+    # which might import the main numpy module
+    if attr == "test":
+        from numpy._pytesttester import PytestTester
+        test = PytestTester(__name__)
+        return test
 
-        elif attr == "test":
-            from numpy._pytesttester import PytestTester
-            test = PytestTester(__name__)
-            return test
-
-        else:
-            raise AttributeError("module {!r} has no attribute "
-                                 "{!r}".format(__name__, attr))
-
-    def __dir__():
-        return list(globals().keys() | {"f2py_testing", "test"})
+    else:
+        raise AttributeError("module {!r} has no attribute "
+                              "{!r}".format(__name__, attr))
 
-else:
-    from . import f2py_testing
 
-    from numpy._pytesttester import PytestTester
-    test = PytestTester(__name__)
-    del PytestTester
+def __dir__():
+    return list(globals().keys() | {"test"})
diff --git a/numpy/f2py/__init__.pyi b/numpy/f2py/__init__.pyi
index e52e12bbd156..6e3a82cf8f44 100644
--- a/numpy/f2py/__init__.pyi
+++ b/numpy/f2py/__init__.pyi
@@ -1,28 +1,29 @@
 import os
 import subprocess
-from typing import Literal as L, Any, List, Iterable, Dict, overload, TypedDict
+from collections.abc import Iterable
+from typing import Literal as L, Any, overload, TypedDict
 
 from numpy._pytesttester import PytestTester
 
 class _F2PyDictBase(TypedDict):
-    csrc: List[str]
-    h: List[str]
+    csrc: list[str]
+    h: list[str]
 
 class _F2PyDict(_F2PyDictBase, total=False):
-    fsrc: List[str]
-    ltx: List[str]
+    fsrc: list[str]
+    ltx: list[str]
 
-__all__: List[str]
-__path__: List[str]
+__all__: list[str]
+__path__: list[str]
 test: PytestTester
 
-def run_main(comline_list: Iterable[str]) -> Dict[str, _F2PyDict]: ...
+def run_main(comline_list: Iterable[str]) -> dict[str, _F2PyDict]: ...
 
 @overload
 def compile(  # type: ignore[misc]
     source: str | bytes,
     modulename: str = ...,
-    extra_args: str | List[str] = ...,
+    extra_args: str | list[str] = ...,
     verbose: bool = ...,
     source_fn: None | str | bytes | os.PathLike[Any] = ...,
     extension: L[".f", ".f90"] = ...,
@@ -32,7 +33,7 @@ def compile(  # type: ignore[misc]
 def compile(
     source: str | bytes,
     modulename: str = ...,
-    extra_args: str | List[str] = ...,
+    extra_args: str | list[str] = ...,
     verbose: bool = ...,
     source_fn: None | str | bytes | os.PathLike[Any] = ...,
     extension: L[".f", ".f90"] = ...,
diff --git a/numpy/f2py/auxfuncs.py b/numpy/f2py/auxfuncs.py
index c8f2067c9351..3f9b0ceafa21 100644
--- a/numpy/f2py/auxfuncs.py
+++ b/numpy/f2py/auxfuncs.py
@@ -28,10 +28,12 @@
     'getfortranname', 'getpymethoddef', 'getrestdoc', 'getusercode',
     'getusercode1', 'hasbody', 'hascallstatement', 'hascommon',
     'hasexternals', 'hasinitvalue', 'hasnote', 'hasresultnote',
-    'isallocatable', 'isarray', 'isarrayofstrings', 'iscomplex',
+    'isallocatable', 'isarray', 'isarrayofstrings',
+    'ischaracter', 'ischaracterarray', 'ischaracter_or_characterarray',
+    'iscomplex',
     'iscomplexarray', 'iscomplexfunction', 'iscomplexfunction_warn',
     'isdouble', 'isdummyroutine', 'isexternal', 'isfunction',
-    'isfunction_wrap', 'isint1array', 'isinteger', 'isintent_aux',
+    'isfunction_wrap', 'isint1', 'isint1array', 'isinteger', 'isintent_aux',
     'isintent_c', 'isintent_callback', 'isintent_copy', 'isintent_dict',
     'isintent_hide', 'isintent_in', 'isintent_inout', 'isintent_inplace',
     'isintent_nothide', 'isintent_out', 'isintent_overwrite', 'islogical',
@@ -39,12 +41,13 @@
     'islong_doublefunction', 'islong_long', 'islong_longfunction',
     'ismodule', 'ismoduleroutine', 'isoptional', 'isprivate', 'isrequired',
     'isroutine', 'isscalar', 'issigned_long_longarray', 'isstring',
-    'isstringarray', 'isstringfunction', 'issubroutine',
+    'isstringarray', 'isstring_or_stringarray', 'isstringfunction',
+    'issubroutine',
     'issubroutine_wrap', 'isthreadsafe', 'isunsigned', 'isunsigned_char',
     'isunsigned_chararray', 'isunsigned_long_long',
     'isunsigned_long_longarray', 'isunsigned_short',
     'isunsigned_shortarray', 'l_and', 'l_not', 'l_or', 'outmess',
-    'replace', 'show', 'stripcomma', 'throw_error',
+    'replace', 'show', 'stripcomma', 'throw_error', 'isattr_value'
 ]
 
 
@@ -68,24 +71,41 @@ def debugcapi(var):
     return 'capi' in debugoptions
 
 
+def _ischaracter(var):
+    return 'typespec' in var and var['typespec'] == 'character' and \
+           not isexternal(var)
+
+
 def _isstring(var):
     return 'typespec' in var and var['typespec'] == 'character' and \
            not isexternal(var)
 
 
-def isstring(var):
-    return _isstring(var) and not isarray(var)
+def ischaracter_or_characterarray(var):
+    return _ischaracter(var) and 'charselector' not in var
 
 
 def ischaracter(var):
-    return isstring(var) and 'charselector' not in var
+    return ischaracter_or_characterarray(var) and not isarray(var)
+
+
+def ischaracterarray(var):
+    return ischaracter_or_characterarray(var) and isarray(var)
+
+
+def isstring_or_stringarray(var):
+    return _ischaracter(var) and 'charselector' in var
+
+
+def isstring(var):
+    return isstring_or_stringarray(var) and not isarray(var)
 
 
 def isstringarray(var):
-    return isarray(var) and _isstring(var)
+    return isstring_or_stringarray(var) and isarray(var)
 
 
-def isarrayofstrings(var):
+def isarrayofstrings(var):  # obsolete?
     # leaving out '*' for now so that `character*(*) a(m)` and `character
     # a(m,*)` are treated differently. Luckily `character**` is illegal.
     return isstringarray(var) and var['dimension'][-1] == '(*)'
@@ -126,6 +146,11 @@ def get_kind(var):
             pass
 
 
+def isint1(var):
+    return var.get('typespec') == 'integer' \
+        and get_kind(var) == '1' and not isarray(var)
+
+
 def islong_long(var):
     if not isscalar(var):
         return 0
@@ -273,6 +298,9 @@ def issubroutine_wrap(rout):
         return 0
     return issubroutine(rout) and hasassumedshape(rout)
 
+def isattr_value(var):
+    return 'value' in var.get('attrspec', [])
+
 
 def hasassumedshape(rout):
     if rout.get('hasassumedshape'):
@@ -426,6 +454,7 @@ def isintent_hide(var):
             ('out' in var['intent'] and 'in' not in var['intent'] and
                 (not l_or(isintent_inout, isintent_inplace)(var)))))
 
+
 def isintent_nothide(var):
     return not isintent_hide(var)
 
@@ -469,6 +498,7 @@ def isintent_aligned8(var):
 def isintent_aligned16(var):
     return 'aligned16' in var.get('intent', [])
 
+
 isintent_dict = {isintent_in: 'INTENT_IN', isintent_inout: 'INTENT_INOUT',
                  isintent_out: 'INTENT_OUT', isintent_hide: 'INTENT_HIDE',
                  isintent_cache: 'INTENT_CACHE',
@@ -566,19 +596,19 @@ def __call__(self, var):
 
 
 def l_and(*f):
-    l, l2 = 'lambda v', []
+    l1, l2 = 'lambda v', []
     for i in range(len(f)):
-        l = '%s,f%d=f[%d]' % (l, i, i)
+        l1 = '%s,f%d=f[%d]' % (l1, i, i)
         l2.append('f%d(v)' % (i))
-    return eval('%s:%s' % (l, ' and '.join(l2)))
+    return eval('%s:%s' % (l1, ' and '.join(l2)))
 
 
 def l_or(*f):
-    l, l2 = 'lambda v', []
+    l1, l2 = 'lambda v', []
     for i in range(len(f)):
-        l = '%s,f%d=f[%d]' % (l, i, i)
+        l1 = '%s,f%d=f[%d]' % (l1, i, i)
         l2.append('f%d(v)' % (i))
-    return eval('%s:%s' % (l, ' or '.join(l2)))
+    return eval('%s:%s' % (l1, ' or '.join(l2)))
 
 
 def l_not(f):
@@ -665,8 +695,11 @@ def getcallprotoargument(rout, cb_map={}):
             elif isstring(var):
                 pass
             else:
-                ctype = ctype + '*'
-            if isstring(var) or isarrayofstrings(var):
+                if not isattr_value(var):
+                    ctype = ctype + '*'
+            if ((isstring(var)
+                 or isarrayofstrings(var)  # obsolete?
+                 or isstringarray(var))):
                 arg_types2.append('size_t')
         arg_types.append(ctype)
 
@@ -731,14 +764,14 @@ def getrestdoc(rout):
 
 
 def gentitle(name):
-    l = (80 - len(name) - 6) // 2
-    return '/*%s %s %s*/' % (l * '*', name, l * '*')
+    ln = (80 - len(name) - 6) // 2
+    return '/*%s %s %s*/' % (ln * '*', name, ln * '*')
 
 
-def flatlist(l):
-    if isinstance(l, list):
-        return reduce(lambda x, y, f=flatlist: x + f(y), l, [])
-    return [l]
+def flatlist(lst):
+    if isinstance(lst, list):
+        return reduce(lambda x, y, f=flatlist: x + f(y), lst, [])
+    return [lst]
 
 
 def stripcomma(s):
diff --git a/numpy/f2py/capi_maps.py b/numpy/f2py/capi_maps.py
index 581f946e5a21..aaae3a8e0b15 100644
--- a/numpy/f2py/capi_maps.py
+++ b/numpy/f2py/capi_maps.py
@@ -56,6 +56,7 @@
             'complex_double': 'complex',
             'complex_long_double': 'complex',          # forced casting
             'string': 'string',
+            'character': 'bytes',
             }
 c2capi_map = {'double': 'NPY_DOUBLE',
               'float': 'NPY_FLOAT',
@@ -72,7 +73,8 @@
               'complex_float': 'NPY_CFLOAT',
               'complex_double': 'NPY_CDOUBLE',
               'complex_long_double': 'NPY_CDOUBLE',   # forced casting
-              'string': 'NPY_STRING'}
+              'string': 'NPY_STRING',
+              'character': 'NPY_CHAR'}
 
 # These new maps aren't used anywhere yet, but should be by default
 #  unless building numeric or numarray extensions.
@@ -94,8 +96,8 @@
                   'complex_float': 'NPY_CFLOAT',
                   'complex_double': 'NPY_CDOUBLE',
                   'complex_long_double': 'NPY_CDOUBLE',
-                  'string':'NPY_STRING'
-                  }
+                  'string': 'NPY_STRING',
+                  'character': 'NPY_STRING'}
 
 c2pycode_map = {'double': 'd',
                 'float': 'f',
@@ -112,7 +114,8 @@
                 'complex_float': 'F',
                 'complex_double': 'D',
                 'complex_long_double': 'D',               # forced casting
-                'string': 'c'
+                'string': 'c',
+                'character': 'c'
                 }
 
 if using_newcore:
@@ -133,8 +136,11 @@
                     'complex_float': 'F',
                     'complex_double': 'D',
                     'complex_long_double': 'G',
-                    'string': 'S'}
+                    'string': 'S',
+                    'character': 'c'}
 
+# https://docs.python.org/3/c-api/arg.html#building-values
+# c2buildvalue_map is NumPy agnostic, so no need to bother with using_newcore
 c2buildvalue_map = {'double': 'd',
                     'float': 'f',
                     'char': 'b',
@@ -146,7 +152,8 @@
                     'complex_float': 'N',
                     'complex_double': 'N',
                     'complex_long_double': 'N',
-                    'string': 'y'}
+                    'string': 'y',
+                    'character': 'c'}
 
 f2cmap_all = {'real': {'': 'float', '4': 'float', '8': 'double',
                        '12': 'long_double', '16': 'long_double'},
@@ -165,11 +172,11 @@
               'double complex': {'': 'complex_double'},
               'double precision': {'': 'double'},
               'byte': {'': 'char'},
-              'character': {'': 'string'}
               }
 
 f2cmap_default = copy.deepcopy(f2cmap_all)
 
+f2cmap_mapped = []
 
 def load_f2cmap_file(f2cmap_file):
     global f2cmap_all
@@ -190,7 +197,7 @@ def load_f2cmap_file(f2cmap_file):
     try:
         outmess('Reading f2cmap from {!r} ...\n'.format(f2cmap_file))
         with open(f2cmap_file, 'r') as f:
-            d = eval(f.read(), {}, {})
+            d = eval(f.read().lower(), {}, {})
         for k, d1 in d.items():
             for k1 in d1.keys():
                 d1[k1.lower()] = d1[k1]
@@ -206,6 +213,7 @@ def load_f2cmap_file(f2cmap_file):
                     f2cmap_all[k][k1] = d[k][k1]
                     outmess('\tMapping "%s(kind=%s)" to "%s"\n' %
                             (k, k1, d[k][k1]))
+                    f2cmap_mapped.append(d[k][k1])
                 else:
                     errmess("\tIgnoring map {'%s':{'%s':'%s'}}: '%s' must be in %s\n" % (
                         k, k1, d[k][k1], d[k][k1], list(c2py_map.keys())))
@@ -230,7 +238,8 @@ def load_f2cmap_file(f2cmap_file):
                'complex_float': '(%g,%g)',
                'complex_double': '(%g,%g)',
                'complex_long_double': '(%Lg,%Lg)',
-               'string': '%s',
+               'string': '\\"%s\\"',
+               'character': "'%c'",
                }
 
 # Auxiliary functions
@@ -252,6 +261,10 @@ def getctype(var):
             errmess('getctype: function %s has no return value?!\n' % a)
     elif issubroutine(var):
         return ctype
+    elif ischaracter_or_characterarray(var):
+        return 'character'
+    elif isstring_or_stringarray(var):
+        return 'string'
     elif 'typespec' in var and var['typespec'].lower() in f2cmap_all:
         typespec = var['typespec'].lower()
         f2cmap = f2cmap_all[typespec]
@@ -283,6 +296,21 @@ def getctype(var):
     return ctype
 
 
+def f2cexpr(expr):
+    """Rewrite Fortran expression as f2py supported C expression.
+
+    Due to the lack of a proper expression parser in f2py, this
+    function uses a heuristic approach that assumes that Fortran
+    arithmetic expressions are valid C arithmetic expressions when
+    mapping Fortran function calls to the corresponding C function/CPP
+    macros calls.
+
+    """
+    # TODO: support Fortran `len` function with optional kind parameter
+    expr = re.sub(r'\blen\b', 'f2py_slen', expr)
+    return expr
+
+
 def getstrlength(var):
     if isstringfunction(var):
         if 'result' in var:
@@ -302,7 +330,7 @@ def getstrlength(var):
         if '*' in a:
             len = a['*']
         elif 'len' in a:
-            len = a['len']
+            len = f2cexpr(a['len'])
     if re.match(r'\(\s*(\*|:)\s*\)', len) or re.match(r'(\*|:)', len):
         if isintent_hide(var):
             errmess('getstrlength:intent(hide): expected a string with defined length but got: %s\n' % (
@@ -314,9 +342,9 @@ def getstrlength(var):
 def getarrdims(a, var, verbose=0):
     ret = {}
     if isstring(var) and not isarray(var):
-        ret['dims'] = getstrlength(var)
-        ret['size'] = ret['dims']
-        ret['rank'] = '1'
+        ret['size'] = getstrlength(var)
+        ret['rank'] = '0'
+        ret['dims'] = ''
     elif isscalar(var):
         ret['size'] = '1'
         ret['rank'] = '0'
@@ -499,12 +527,27 @@ def getinit(a, var):
     return init, showinit
 
 
+def get_elsize(var):
+    if isstring(var) or isstringarray(var):
+        elsize = getstrlength(var)
+        # override with user-specified length when available:
+        elsize = var['charselector'].get('f2py_len', elsize)
+        return elsize
+    if ischaracter(var) or ischaracterarray(var):
+        return '1'
+    # for numerical types, PyArray_New* functions ignore specified
+    # elsize, so we just return 1 and let elsize be determined at
+    # runtime, see fortranobject.c
+    return '1'
+
+
 def sign2map(a, var):
     """
     varname,ctype,atype
     init,init.r,init.i,pytype
     vardebuginfo,vardebugshowvalue,varshowvalue
-    varrfromat
+    varrformat
+
     intent
     """
     out_a = a
@@ -552,6 +595,7 @@ def sign2map(a, var):
         dim = copy.copy(var['dimension'])
     if ret['ctype'] in c2capi_map:
         ret['atype'] = c2capi_map[ret['ctype']]
+        ret['elsize'] = get_elsize(var)
     # Debug info
     if debugcapi(var):
         il = [isintent_in, 'input', isintent_out, 'output',
@@ -719,6 +763,7 @@ def cb_sign2map(a, var, index=None):
     ret['ctype'] = getctype(var)
     if ret['ctype'] in c2capi_map:
         ret['atype'] = c2capi_map[ret['ctype']]
+        ret['elsize'] = get_elsize(var)
     if ret['ctype'] in cformat_map:
         ret['showvalueformat'] = '%s' % (cformat_map[ret['ctype']])
     if isarray(var):
@@ -818,6 +863,7 @@ def common_sign2map(a, var):  # obsolute
         ret['ctype'] = 'char'
     if ret['ctype'] in c2capi_map:
         ret['atype'] = c2capi_map[ret['ctype']]
+        ret['elsize'] = get_elsize(var)
     if ret['ctype'] in cformat_map:
         ret['showvalueformat'] = '%s' % (cformat_map[ret['ctype']])
     if isarray(var):
diff --git a/numpy/f2py/cb_rules.py b/numpy/f2py/cb_rules.py
index 4848233d43a5..761831e00449 100644
--- a/numpy/f2py/cb_rules.py
+++ b/numpy/f2py/cb_rules.py
@@ -230,12 +230,21 @@ def #argname#(#docsignature#): return #docreturn#\\n\\
         'latexdocstrcbs': '\\noindent Call-back functions:',
         'routnote': {hasnote: '--- #note#', l_not(hasnote): ''},
     }, {  # Function
-        'decl': '    #ctype# return_value;',
-        'frompyobj': [{debugcapi: '    CFUNCSMESS("cb:Getting return_value->");'},
-                      '    if (capi_j>capi_i)\n        GETSCALARFROMPYTUPLE(capi_return,capi_i++,&return_value,#ctype#,"#ctype#_from_pyobj failed in converting return_value of call-back function #name# to C #ctype#\\n");',
-                      {debugcapi:
-                       '    fprintf(stderr,"#showvalueformat#.\\n",return_value);'}
-                      ],
+        'decl': '    #ctype# return_value = 0;',
+        'frompyobj': [
+            {debugcapi: '    CFUNCSMESS("cb:Getting return_value->");'},
+            '''\
+    if (capi_j>capi_i) {
+        GETSCALARFROMPYTUPLE(capi_return,capi_i++,&return_value,#ctype#,
+          "#ctype#_from_pyobj failed in converting return_value of"
+          " call-back function #name# to C #ctype#\\n");
+    } else {
+        fprintf(stderr,"Warning: call-back function #name# did not provide"
+                       " return value (index=%d, type=#ctype#)\\n",capi_i);
+    }''',
+            {debugcapi:
+             '    fprintf(stderr,"#showvalueformat#.\\n",return_value);'}
+        ],
         'need': ['#ctype#_from_pyobj', {debugcapi: 'CFUNCSMESS'}, 'GETSCALARFROMPYTUPLE'],
         'return': '    return return_value;',
         '_check': l_and(isfunction, l_not(isstringfunction), l_not(iscomplexfunction))
@@ -245,12 +254,18 @@ def #argname#(#docsignature#): return #docreturn#\\n\\
         'args': '#ctype# return_value,int return_value_len',
         'args_nm': 'return_value,&return_value_len',
         'args_td': '#ctype# ,int',
-        'frompyobj': [{debugcapi: '    CFUNCSMESS("cb:Getting return_value->\\"");'},
-                      """    if (capi_j>capi_i)
-        GETSTRFROMPYTUPLE(capi_return,capi_i++,return_value,return_value_len);""",
-                      {debugcapi:
-                       '    fprintf(stderr,"#showvalueformat#\\".\\n",return_value);'}
-                      ],
+        'frompyobj': [
+            {debugcapi: '    CFUNCSMESS("cb:Getting return_value->\\"");'},
+            """\
+    if (capi_j>capi_i) {
+        GETSTRFROMPYTUPLE(capi_return,capi_i++,return_value,return_value_len);
+    } else {
+        fprintf(stderr,"Warning: call-back function #name# did not provide"
+                       " return value (index=%d, type=#ctype#)\\n",capi_i);
+    }""",
+            {debugcapi:
+             '    fprintf(stderr,"#showvalueformat#\\".\\n",return_value);'}
+        ],
         'need': ['#ctype#_from_pyobj', {debugcapi: 'CFUNCSMESS'},
                  'string.h', 'GETSTRFROMPYTUPLE'],
         'return': 'return;',
@@ -274,27 +289,35 @@ def #argname#(#docsignature#): return #docreturn#\\n\\
 """,
         'decl': """
 #ifdef F2PY_CB_RETURNCOMPLEX
-    #ctype# return_value;
+    #ctype# return_value = {0, 0};
 #endif
 """,
-        'frompyobj': [{debugcapi: '    CFUNCSMESS("cb:Getting return_value->");'},
-                      """\
-    if (capi_j>capi_i)
+        'frompyobj': [
+            {debugcapi: '    CFUNCSMESS("cb:Getting return_value->");'},
+            """\
+    if (capi_j>capi_i) {
 #ifdef F2PY_CB_RETURNCOMPLEX
-        GETSCALARFROMPYTUPLE(capi_return,capi_i++,&return_value,#ctype#,\"#ctype#_from_pyobj failed in converting return_value of call-back function #name# to C #ctype#\\n\");
+        GETSCALARFROMPYTUPLE(capi_return,capi_i++,&return_value,#ctype#,
+          \"#ctype#_from_pyobj failed in converting return_value of call-back\"
+          \" function #name# to C #ctype#\\n\");
 #else
-        GETSCALARFROMPYTUPLE(capi_return,capi_i++,return_value,#ctype#,\"#ctype#_from_pyobj failed in converting return_value of call-back function #name# to C #ctype#\\n\");
+        GETSCALARFROMPYTUPLE(capi_return,capi_i++,return_value,#ctype#,
+          \"#ctype#_from_pyobj failed in converting return_value of call-back\"
+          \" function #name# to C #ctype#\\n\");
 #endif
-""",
-                      {debugcapi: """
+    } else {
+        fprintf(stderr,
+                \"Warning: call-back function #name# did not provide\"
+                \" return value (index=%d, type=#ctype#)\\n\",capi_i);
+    }""",
+            {debugcapi: """\
 #ifdef F2PY_CB_RETURNCOMPLEX
     fprintf(stderr,\"#showvalueformat#.\\n\",(return_value).r,(return_value).i);
 #else
     fprintf(stderr,\"#showvalueformat#.\\n\",(*return_value).r,(*return_value).i);
 #endif
-
 """}
-                      ],
+        ],
         'return': """
 #ifdef F2PY_CB_RETURNCOMPLEX
     return return_value;
@@ -401,8 +424,11 @@ def #argname#(#docsignature#): return #docreturn#\\n\\
                  {debugcapi: 'CFUNCSMESS'}, 'string.h'],
         '_check': l_and(isstring, isintent_out)
     }, {
-        'pyobjfrom': [{debugcapi: '    fprintf(stderr,"debug-capi:cb:#varname#=\\"#showvalueformat#\\":%d:\\n",#varname_i#,#varname_i#_cb_len);'},
-                      {isintent_in: """\
+        'pyobjfrom': [
+            {debugcapi:
+             ('    fprintf(stderr,"debug-capi:cb:#varname#=#showvalueformat#:'
+              '%d:\\n",#varname_i#,#varname_i#_cb_len);')},
+            {isintent_in: """\
     if (cb->nofargs>capi_i)
         if (CAPI_ARGLIST_SETITEM(capi_i++,pyobj_from_#ctype#1size(#varname_i#,#varname_i#_cb_len)))
             goto capi_fail;"""},
@@ -428,15 +454,21 @@ def #argname#(#docsignature#): return #docreturn#\\n\\
         'pyobjfrom': [{debugcapi: '    fprintf(stderr,"debug-capi:cb:#varname#\\n");'},
                       {isintent_c: """\
     if (cb->nofargs>capi_i) {
-        int itemsize_ = #atype# == NPY_STRING ? 1 : 0;
-        /*XXX: Hmm, what will destroy this array??? */
-        PyArrayObject *tmp_arr = (PyArrayObject *)PyArray_New(&PyArray_Type,#rank#,#varname_i#_Dims,#atype#,NULL,(char*)#varname_i#,itemsize_,NPY_ARRAY_CARRAY,NULL);
+        /* tmp_arr will be inserted to capi_arglist_list that will be
+           destroyed when leaving callback function wrapper together
+           with tmp_arr. */
+        PyArrayObject *tmp_arr = (PyArrayObject *)PyArray_New(&PyArray_Type,
+          #rank#,#varname_i#_Dims,#atype#,NULL,(char*)#varname_i#,#elsize#,
+          NPY_ARRAY_CARRAY,NULL);
 """,
                        l_not(isintent_c): """\
     if (cb->nofargs>capi_i) {
-        int itemsize_ = #atype# == NPY_STRING ? 1 : 0;
-        /*XXX: Hmm, what will destroy this array??? */
-        PyArrayObject *tmp_arr = (PyArrayObject *)PyArray_New(&PyArray_Type,#rank#,#varname_i#_Dims,#atype#,NULL,(char*)#varname_i#,itemsize_,NPY_ARRAY_FARRAY,NULL);
+        /* tmp_arr will be inserted to capi_arglist_list that will be
+           destroyed when leaving callback function wrapper together
+           with tmp_arr. */
+        PyArrayObject *tmp_arr = (PyArrayObject *)PyArray_New(&PyArray_Type,
+          #rank#,#varname_i#_Dims,#atype#,NULL,(char*)#varname_i#,#elsize#,
+          NPY_ARRAY_FARRAY,NULL);
 """,
                        },
                       """
diff --git a/numpy/f2py/cfuncs.py b/numpy/f2py/cfuncs.py
index 1d9236dcd764..7416925624ee 100644
--- a/numpy/f2py/cfuncs.py
+++ b/numpy/f2py/cfuncs.py
@@ -51,8 +51,6 @@
 includes0['string.h'] = '#include '
 includes0['setjmp.h'] = '#include '
 
-includes['Python.h'] = '#include '
-needs['arrayobject.h'] = ['Python.h']
 includes['arrayobject.h'] = '''#define PY_ARRAY_UNIQUE_SYMBOL PyArray_API
 #include "arrayobject.h"'''
 
@@ -66,7 +64,7 @@
 typedefs['unsigned_long'] = 'typedef unsigned long unsigned_long;'
 typedefs['signed_char'] = 'typedef signed char signed_char;'
 typedefs['long_long'] = """\
-#ifdef _WIN32
+#if defined(NPY_OS_WIN32)
 typedef __int64 long_long;
 #else
 typedef long long long_long;
@@ -74,7 +72,7 @@
 #endif
 """
 typedefs['unsigned_long_long'] = """\
-#ifdef _WIN32
+#if defined(NPY_OS_WIN32)
 typedef __uint64 long_long;
 #else
 typedef unsigned long long unsigned_long_long;
@@ -90,6 +88,7 @@
 typedefs['complex_float'] = 'typedef struct {float r,i;} complex_float;'
 typedefs['complex_double'] = 'typedef struct {double r,i;} complex_double;'
 typedefs['string'] = """typedef char * string;"""
+typedefs['character'] = """typedef char character;"""
 
 
 ############### CPP macros ####################
@@ -244,47 +243,16 @@
 #define MIN(a,b) ((a < b) ? (a) : (b))
 #endif
 """
-needs['len..'] = ['f2py_size']
 cppmacros['len..'] = """\
-#define rank(var) var ## _Rank
-#define shape(var,dim) var ## _Dims[dim]
-#define old_rank(var) (PyArray_NDIM((PyArrayObject *)(capi_ ## var ## _tmp)))
-#define old_shape(var,dim) PyArray_DIM(((PyArrayObject *)(capi_ ## var ## _tmp)),dim)
-#define fshape(var,dim) shape(var,rank(var)-dim-1)
-#define len(var) shape(var,0)
-#define flen(var) fshape(var,0)
-#define old_size(var) PyArray_SIZE((PyArrayObject *)(capi_ ## var ## _tmp))
-/* #define index(i) capi_i ## i */
-#define slen(var) capi_ ## var ## _len
-#define size(var, ...) f2py_size((PyArrayObject *)(capi_ ## var ## _tmp), ## __VA_ARGS__, -1)
+/* See fortranobject.h for definitions. The macros here are provided for BC. */
+#define rank f2py_rank
+#define shape f2py_shape
+#define fshape f2py_shape
+#define len f2py_len
+#define flen f2py_flen
+#define slen f2py_slen
+#define size f2py_size
 """
-needs['f2py_size'] = ['stdarg.h']
-cfuncs['f2py_size'] = """\
-static int f2py_size(PyArrayObject* var, ...)
-{
-  npy_int sz = 0;
-  npy_int dim;
-  npy_int rank;
-  va_list argp;
-  va_start(argp, var);
-  dim = va_arg(argp, npy_int);
-  if (dim==-1)
-    {
-      sz = PyArray_SIZE(var);
-    }
-  else
-    {
-      rank = PyArray_NDIM(var);
-      if (dim>=1 && dim<=rank)
-        sz = PyArray_DIM(var, dim-1);
-      else
-        fprintf(stderr, \"f2py_size: 2nd argument value=%d fails to satisfy 1<=value<=%d. Result will be 0.\\n\", dim, rank);
-    }
-  va_end(argp);
-  return sz;
-}
-"""
-
 cppmacros[
     'pyobj_from_char1'] = '#define pyobj_from_char1(v) (PyLong_FromLong(v))'
 cppmacros[
@@ -572,18 +540,20 @@
 """
 cppmacros["F2PY_THREAD_LOCAL_DECL"] = """\
 #ifndef F2PY_THREAD_LOCAL_DECL
-#if defined(_MSC_VER) \\
-      || defined(_WIN32) || defined(_WIN64) \\
-      || defined(__MINGW32__) || defined(__MINGW64__)
+#if defined(_MSC_VER)
 #define F2PY_THREAD_LOCAL_DECL __declspec(thread)
+#elif defined(NPY_OS_MINGW)
+#define F2PY_THREAD_LOCAL_DECL __thread
 #elif defined(__STDC_VERSION__) \\
       && (__STDC_VERSION__ >= 201112L) \\
       && !defined(__STDC_NO_THREADS__) \\
-      && (!defined(__GLIBC__) || __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 12))
+      && (!defined(__GLIBC__) || __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 12)) \\
+      && !defined(NPY_OS_OPENBSD) && !defined(NPY_OS_HAIKU)
 /* __STDC_NO_THREADS__ was first defined in a maintenance release of glibc 2.12,
    see https://lists.gnu.org/archive/html/commit-hurd/2012-07/msg00180.html,
    so `!defined(__STDC_NO_THREADS__)` may give false positive for the existence
-   of `threads.h` when using an older release of glibc 2.12 */
+   of `threads.h` when using an older release of glibc 2.12
+   See gh-19437 for details on OpenBSD */
 #include 
 #define F2PY_THREAD_LOCAL_DECL thread_local
 #elif defined(__GNUC__) \\
@@ -785,6 +755,66 @@
 }
 """
 
+cfuncs['character_from_pyobj'] = """\
+static int
+character_from_pyobj(character* v, PyObject *obj, const char *errmess) {
+    if (PyBytes_Check(obj)) {
+        /* empty bytes has trailing null, so dereferencing is always safe */
+        *v = PyBytes_AS_STRING(obj)[0];
+        return 1;
+    } else if (PyUnicode_Check(obj)) {
+        PyObject* tmp = PyUnicode_AsASCIIString(obj);
+        if (tmp != NULL) {
+            *v = PyBytes_AS_STRING(tmp)[0];
+            Py_DECREF(tmp);
+            return 1;
+        }
+    } else if (PyArray_Check(obj)) {
+        PyArrayObject* arr = (PyArrayObject*)obj;
+        if (F2PY_ARRAY_IS_CHARACTER_COMPATIBLE(arr)) {
+            *v = PyArray_BYTES(arr)[0];
+            return 1;
+        } else if (F2PY_IS_UNICODE_ARRAY(arr)) {
+            // TODO: update when numpy will support 1-byte and
+            // 2-byte unicode dtypes
+            PyObject* tmp = PyUnicode_FromKindAndData(
+                              PyUnicode_4BYTE_KIND,
+                              PyArray_BYTES(arr),
+                              (PyArray_NBYTES(arr)>0?1:0));
+            if (tmp != NULL) {
+                if (character_from_pyobj(v, tmp, errmess)) {
+                    Py_DECREF(tmp);
+                    return 1;
+                }
+                Py_DECREF(tmp);
+            }
+        }
+    } else if (PySequence_Check(obj)) {
+        PyObject* tmp = PySequence_GetItem(obj,0);
+        if (tmp != NULL) {
+            if (character_from_pyobj(v, tmp, errmess)) {
+                Py_DECREF(tmp);
+                return 1;
+            }
+            Py_DECREF(tmp);
+        }
+    }
+    {
+        char mess[F2PY_MESSAGE_BUFFER_SIZE];
+        strcpy(mess, errmess);
+        PyObject* err = PyErr_Occurred();
+        if (err == NULL) {
+            err = PyExc_TypeError;
+        }
+        sprintf(mess + strlen(mess),
+                " -- expected str|bytes|sequence-of-str-or-bytes, got ");
+        f2py_describe(obj, mess + strlen(mess));
+        PyErr_SetString(err, mess);
+    }
+    return 0;
+}
+"""
+
 needs['char_from_pyobj'] = ['int_from_pyobj']
 cfuncs['char_from_pyobj'] = """\
 static int
@@ -845,20 +875,26 @@
         return !(*v == -1 && PyErr_Occurred());
     }
 
-    if (PyComplex_Check(obj))
+    if (PyComplex_Check(obj)) {
+        PyErr_Clear();
         tmp = PyObject_GetAttrString(obj,\"real\");
-    else if (PyBytes_Check(obj) || PyUnicode_Check(obj))
+    }
+    else if (PyBytes_Check(obj) || PyUnicode_Check(obj)) {
         /*pass*/;
-    else if (PySequence_Check(obj))
+    }
+    else if (PySequence_Check(obj)) {
+        PyErr_Clear();
         tmp = PySequence_GetItem(obj, 0);
+    }
+
     if (tmp) {
-        PyErr_Clear();
         if (int_from_pyobj(v, tmp, errmess)) {
             Py_DECREF(tmp);
             return 1;
         }
         Py_DECREF(tmp);
     }
+
     {
         PyObject* err = PyErr_Occurred();
         if (err == NULL) {
@@ -888,15 +924,19 @@
         return !(*v == -1 && PyErr_Occurred());
     }
 
-    if (PyComplex_Check(obj))
+    if (PyComplex_Check(obj)) {
+        PyErr_Clear();
         tmp = PyObject_GetAttrString(obj,\"real\");
-    else if (PyBytes_Check(obj) || PyUnicode_Check(obj))
+    }
+    else if (PyBytes_Check(obj) || PyUnicode_Check(obj)) {
         /*pass*/;
-    else if (PySequence_Check(obj))
-        tmp = PySequence_GetItem(obj,0);
+    }
+    else if (PySequence_Check(obj)) {
+        PyErr_Clear();
+        tmp = PySequence_GetItem(obj, 0);
+    }
 
     if (tmp) {
-        PyErr_Clear();
         if (long_from_pyobj(v, tmp, errmess)) {
             Py_DECREF(tmp);
             return 1;
@@ -934,14 +974,19 @@
         return !(*v == -1 && PyErr_Occurred());
     }
 
-    if (PyComplex_Check(obj))
+    if (PyComplex_Check(obj)) {
+        PyErr_Clear();
         tmp = PyObject_GetAttrString(obj,\"real\");
-    else if (PyBytes_Check(obj) || PyUnicode_Check(obj))
+    }
+    else if (PyBytes_Check(obj) || PyUnicode_Check(obj)) {
         /*pass*/;
-    else if (PySequence_Check(obj))
-        tmp = PySequence_GetItem(obj,0);
-    if (tmp) {
+    }
+    else if (PySequence_Check(obj)) {
         PyErr_Clear();
+        tmp = PySequence_GetItem(obj, 0);
+    }
+
+    if (tmp) {
         if (long_long_from_pyobj(v, tmp, errmess)) {
             Py_DECREF(tmp);
             return 1;
@@ -1001,14 +1046,20 @@
         Py_DECREF(tmp);
         return !(*v == -1.0 && PyErr_Occurred());
     }
-    if (PyComplex_Check(obj))
+
+    if (PyComplex_Check(obj)) {
+        PyErr_Clear();
         tmp = PyObject_GetAttrString(obj,\"real\");
-    else if (PyBytes_Check(obj) || PyUnicode_Check(obj))
+    }
+    else if (PyBytes_Check(obj) || PyUnicode_Check(obj)) {
         /*pass*/;
-    else if (PySequence_Check(obj))
-        tmp = PySequence_GetItem(obj,0);
-    if (tmp) {
+    }
+    else if (PySequence_Check(obj)) {
         PyErr_Clear();
+        tmp = PySequence_GetItem(obj, 0);
+    }
+
+    if (tmp) {
         if (double_from_pyobj(v,tmp,errmess)) {Py_DECREF(tmp); return 1;}
         Py_DECREF(tmp);
     }
@@ -1095,12 +1146,12 @@
         return 1;
     }
     if (PyArray_CheckScalar(obj)) { /* 0-dim array or still array scalar */
-        PyObject *arr;
+        PyArrayObject *arr;
         if (PyArray_Check(obj)) {
-            arr = PyArray_Cast((PyArrayObject *)obj, NPY_CDOUBLE);
+            arr = (PyArrayObject *)PyArray_Cast((PyArrayObject *)obj, NPY_CDOUBLE);
         }
         else {
-            arr = PyArray_FromScalar(obj, PyArray_DescrFromType(NPY_CDOUBLE));
+            arr = (PyArrayObject *)PyArray_FromScalar(obj, PyArray_DescrFromType(NPY_CDOUBLE));
         }
         if (arr == NULL) {
             return 0;
@@ -1158,6 +1209,31 @@
 """
 
 
+cfuncs['try_pyarr_from_character'] = """\
+static int try_pyarr_from_character(PyObject* obj, character* v) {
+    PyArrayObject *arr = (PyArrayObject*)obj;
+    if (!obj) return -2;
+    if (PyArray_Check(obj)) {
+        if (F2PY_ARRAY_IS_CHARACTER_COMPATIBLE(arr))  {
+            *(character *)(PyArray_DATA(arr)) = *v;
+            return 1;
+        }
+    }
+    {
+        char mess[F2PY_MESSAGE_BUFFER_SIZE];
+        PyObject* err = PyErr_Occurred();
+        if (err == NULL) {
+            err = PyExc_ValueError;
+            strcpy(mess, "try_pyarr_from_character failed"
+                         " -- expected bytes array-scalar|array, got ");
+            f2py_describe(obj, mess + strlen(mess));
+        }
+        PyErr_SetString(err, mess);
+    }
+    return 0;
+}
+"""
+
 needs['try_pyarr_from_char'] = ['pyobj_from_char1', 'TRYPYARRAYTEMPLATE']
 cfuncs[
     'try_pyarr_from_char'] = 'static int try_pyarr_from_char(PyObject* obj,char* v) {\n    TRYPYARRAYTEMPLATE(char,\'c\');\n}\n'
@@ -1248,7 +1324,7 @@
             if (xa != NULL)
                 ext = PyTuple_Size((PyObject *)xa);
             if(ext>0) {
-                fprintf(stderr,\"extra arguments tuple cannot be used with CObject call-back\\n\");
+                fprintf(stderr,\"extra arguments tuple cannot be used with PyCapsule call-back\\n\");
                 goto capi_fail;
             }
             tmp_fun = fun;
diff --git a/numpy/f2py/common_rules.py b/numpy/f2py/common_rules.py
index 937d8bc723bd..5a488bf5a5a4 100644
--- a/numpy/f2py/common_rules.py
+++ b/numpy/f2py/common_rules.py
@@ -91,6 +91,7 @@ def dadd(line, s=doc):
         idims = []
         for n in inames:
             ct = capi_maps.getctype(vars[n])
+            elsize = capi_maps.get_elsize(vars[n])
             at = capi_maps.c2capi_map[ct]
             dm = capi_maps.getarrdims(n, vars[n])
             if dm['dims']:
@@ -100,7 +101,8 @@ def dadd(line, s=doc):
             dms = dm['dims'].strip()
             if not dms:
                 dms = '-1'
-            cadd('\t{\"%s\",%s,{{%s}},%s},' % (n, dm['rank'], dms, at))
+            cadd('\t{\"%s\",%s,{{%s}},%s, %s},'
+                 % (n, dm['rank'], dms, at, elsize))
         cadd('\t{NULL}\n};')
         inames1 = rmbadname(inames)
         inames1_tps = ','.join(['char *' + s for s in inames1])
@@ -121,7 +123,9 @@ def dadd(line, s=doc):
              % (F_FUNC, lower_name, name.upper(), name))
         cadd('}\n')
         iadd('\ttmp = PyFortranObject_New(f2py_%s_def,f2py_init_%s);' % (name, name))
-        iadd('\tF2PyDict_SetItemString(d, \"%s\", tmp);' % name)
+        iadd('\tif (tmp == NULL) return NULL;')
+        iadd('\tif (F2PyDict_SetItemString(d, \"%s\", tmp) == -1) return NULL;'
+             % name)
         iadd('\tPy_DECREF(tmp);')
         tname = name.replace('_', '\\_')
         dadd('\\subsection{Common block \\texttt{%s}}\n' % (tname))
diff --git a/numpy/f2py/crackfortran.py b/numpy/f2py/crackfortran.py
index b02eb68b7fb3..63597cef1573 100755
--- a/numpy/f2py/crackfortran.py
+++ b/numpy/f2py/crackfortran.py
@@ -84,7 +84,7 @@
                        'optional','required', etc)
      K = D['kindselector'] = {['*','kind']} (only if D['typespec'] =
                          'complex' | 'integer' | 'logical' | 'real' )
-     C = D['charselector'] = {['*','len','kind']}
+     C = D['charselector'] = {['*','len','kind','f2py_len']}
                              (only if D['typespec']=='character')
      D['='] --- initialization expression string
      D['typename'] --- name of the type if D['typespec']=='type'
@@ -97,7 +97,7 @@
      D['typespec>']*K['*']
      D['typespec'](kind=K['kind'])
      character*C['*']
-     character(len=C['len'],kind=C['kind'])
+     character(len=C['len'],kind=C['kind'], f2py_len=C['f2py_len'])
      (see also fortran type declaration statement formats below)
 
 Fortran 90 type declaration statement format (F77 is subset of F90)
@@ -146,6 +146,11 @@
 import os
 import copy
 import platform
+import codecs
+try:
+    import charset_normalizer
+except ImportError:
+    charset_normalizer = None
 
 from . import __version__
 
@@ -301,12 +306,43 @@ def getextension(name):
 _free_f90_start = re.compile(r'[^c*]\s*[^\s\d\t]', re.I).match
 
 
+def openhook(filename, mode):
+    """Ensures that filename is opened with correct encoding parameter.
+
+    This function uses charset_normalizer package, when available, for
+    determining the encoding of the file to be opened. When charset_normalizer
+    is not available, the function detects only UTF encodings, otherwise, ASCII
+    encoding is used as fallback.
+    """
+    # Reads in the entire file. Robust detection of encoding.
+    # Correctly handles comments or late stage unicode characters
+    # gh-22871
+    if charset_normalizer is not None:
+        encoding = charset_normalizer.from_path(filename).best().encoding
+    else:
+        # hint: install charset_normalizer for correct encoding handling
+        # No need to read the whole file for trying with startswith
+        nbytes = min(32, os.path.getsize(filename))
+        with open(filename, 'rb') as fhandle:
+            raw = fhandle.read(nbytes)
+            if raw.startswith(codecs.BOM_UTF8):
+                encoding = 'UTF-8-SIG'
+            elif raw.startswith((codecs.BOM_UTF32_LE, codecs.BOM_UTF32_BE)):
+                encoding = 'UTF-32'
+            elif raw.startswith((codecs.BOM_LE, codecs.BOM_BE)):
+                encoding = 'UTF-16'
+            else:
+                # Fallback, without charset_normalizer
+                encoding = 'ascii'
+    return open(filename, mode, encoding=encoding)
+
+
 def is_free_format(file):
     """Check if file is in free format Fortran."""
     # f90 allows both fixed and free format, assuming fixed unless
     # signs of free format are detected.
     result = 0
-    with open(file, 'r') as f:
+    with openhook(file, 'r') as f:
         line = f.readline()
         n = 15  # the number of non-comment lines to scan for hints
         if _has_f_header(line):
@@ -356,9 +392,16 @@ def readfortrancode(ffile, dowithline=show, istop=1):
     ll, l1 = '', ''
     spacedigits = [' '] + [str(_m) for _m in range(10)]
     filepositiontext = ''
-    fin = fileinput.FileInput(ffile)
+    fin = fileinput.FileInput(ffile, openhook=openhook)
     while True:
-        l = fin.readline()
+        try:
+            l = fin.readline()
+        except UnicodeDecodeError as msg:
+            raise Exception(
+                f'readfortrancode: reading {fin.filename()}#{fin.lineno()}'
+                f' failed with\n{msg}.\nIt is likely that installing charset_normalizer'
+                ' package will help f2py determine the input file encoding'
+                ' correctly.')
         if not l:
             break
         if fin.isfirstline():
@@ -574,11 +617,16 @@ def readfortrancode(ffile, dowithline=show, istop=1):
 groupends = (r'end|endprogram|endblockdata|endmodule|endpythonmodule|'
              r'endinterface|endsubroutine|endfunction')
 endpattern = re.compile(
-    beforethisafter % ('', groupends, groupends, r'[\w\s]*'), re.I), 'end'
-endifs = r'(end\s*(if|do|where|select|while|forall|associate|block|critical|enum|team))|(module\s*procedure)'
+    beforethisafter % ('', groupends, groupends, r'.*'), re.I), 'end'
+endifs = r'end\s*(if|do|where|select|while|forall|associate|block|' + \
+         r'critical|enum|team)'
 endifpattern = re.compile(
     beforethisafter % (r'[\w]*?', endifs, endifs, r'[\w\s]*'), re.I), 'endif'
 #
+moduleprocedures = r'module\s*procedure'
+moduleprocedurepattern = re.compile(
+    beforethisafter % ('', moduleprocedures, moduleprocedures, r'.*'), re.I), \
+    'moduleprocedure'
 implicitpattern = re.compile(
     beforethisafter % ('', 'implicit', 'implicit', '.*'), re.I), 'implicit'
 dimensionpattern = re.compile(beforethisafter % (
@@ -727,7 +775,8 @@ def crackline(line, reset=0):
                 callpattern, usepattern, containspattern,
                 entrypattern,
                 f2pyenhancementspattern,
-                multilinepattern
+                multilinepattern,
+                moduleprocedurepattern
                 ]:
         m = pat[0].match(line)
         if m:
@@ -797,6 +846,8 @@ def crackline(line, reset=0):
         expectbegin = 0
     elif pat[1] == 'endif':
         pass
+    elif pat[1] == 'moduleprocedure':
+        analyzeline(m, pat[1], line)
     elif pat[1] == 'contains':
         if ignorecontains:
             return
@@ -884,8 +935,14 @@ def appenddecl(decl, decl2, force=1):
 
 selectpattern = re.compile(
     r'\s*(?P(@\(@.*?@\)@|\*[\d*]+|\*\s*@\(@.*?@\)@|))(?P.*)\Z', re.I)
+typedefpattern = re.compile(
+    r'(?:,(?P[\w(),]+))?(::)?(?P\b[a-z$_][\w$]*\b)'
+    r'(?:\((?P[\w,]*)\))?\Z', re.I)
 nameargspattern = re.compile(
     r'\s*(?P\b[\w$]+\b)\s*(@\(@\s*(?P[\w\s,]*)\s*@\)@|)\s*((result(\s*@\(@\s*(?P\b[\w$]+\b)\s*@\)@|))|(bind\s*@\(@\s*(?P.*)\s*@\)@))*\s*\Z', re.I)
+operatorpattern = re.compile(
+    r'\s*(?P(operator|assignment))'
+    r'@\(@\s*(?P[^)]+)\s*@\)@\s*\Z', re.I)
 callnameargspattern = re.compile(
     r'\s*(?P\b[\w$]+\b)\s*@\(@\s*(?P.*)\s*@\)@\s*\Z', re.I)
 real16pattern = re.compile(
@@ -903,11 +960,26 @@ def _is_intent_callback(vdecl):
     return 0
 
 
+def _resolvetypedefpattern(line):
+    line = ''.join(line.split())  # removes whitespace
+    m1 = typedefpattern.match(line)
+    print(line, m1)
+    if m1:
+        attrs = m1.group('attributes')
+        attrs = [a.lower() for a in attrs.split(',')] if attrs else []
+        return m1.group('name'), attrs, m1.group('params')
+    return None, [], None
+
+
 def _resolvenameargspattern(line):
     line = markouterparen(line)
     m1 = nameargspattern.match(line)
     if m1:
         return m1.group('name'), m1.group('args'), m1.group('result'), m1.group('bind')
+    m1 = operatorpattern.match(line)
+    if m1:
+        name = m1.group('scheme') + '(' + m1.group('name') + ')'
+        return name, [], None, None
     m1 = callnameargspattern.match(line)
     if m1:
         return m1.group('name'), m1.group('args'), None, None
@@ -947,7 +1019,13 @@ def analyzeline(m, case, line):
             block = 'python module'
         elif re.match(r'abstract\s*interface', block, re.I):
             block = 'abstract interface'
-        name, args, result, bind = _resolvenameargspattern(m.group('after'))
+        if block == 'type':
+            name, attrs, _ = _resolvetypedefpattern(m.group('after'))
+            groupcache[groupcounter]['vars'][name] = dict(attrspec = attrs)
+            args = []
+            result = None
+        else:
+            name, args, result, _ = _resolvenameargspattern(m.group('after'))
         if name is None:
             if block == 'block data':
                 name = '_BLOCK_DATA_'
@@ -1151,6 +1229,9 @@ def analyzeline(m, case, line):
                     continue
             else:
                 k = rmbadname1(m1.group('name'))
+            if case in ['public', 'private'] and \
+               (k == 'operator' or k == 'assignment'):
+                k += m1.group('after')
             if k not in edecl:
                 edecl[k] = {}
             if case == 'dimension':
@@ -1193,6 +1274,9 @@ def analyzeline(m, case, line):
         groupcache[groupcounter]['vars'] = edecl
         if last_name is not None:
             previous_context = ('variable', last_name, groupcounter)
+    elif case == 'moduleprocedure':
+        groupcache[groupcounter]['implementedby'] = \
+            [x.strip() for x in m.group('after').split(',')]
     elif case == 'parameter':
         edecl = groupcache[groupcounter]['vars']
         ll = m.group('after').strip()[1:-1]
@@ -1505,7 +1589,9 @@ def cracktypespec0(typespec, ll):
 charselector = re.compile(
     r'\s*(\((?P.*)\)|\*\s*(?P.*))\s*\Z', re.I)
 lenkindpattern = re.compile(
-    r'\s*(kind\s*=\s*(?P.*?)\s*(@,@\s*len\s*=\s*(?P.*)|)|(len\s*=\s*|)(?P.*?)\s*(@,@\s*(kind\s*=\s*|)(?P.*)|))\s*\Z', re.I)
+    r'\s*(kind\s*=\s*(?P.*?)\s*(@,@\s*len\s*=\s*(?P.*)|)'
+    r'|(len\s*=\s*|)(?P.*?)\s*(@,@\s*(kind\s*=\s*|)(?P.*)'
+    r'|(f2py_len\s*=\s*(?P.*))|))\s*\Z', re.I)
 lenarraypattern = re.compile(
     r'\s*(@\(@\s*(?!/)\s*(?P.*?)\s*@\)@\s*\*\s*(?P.*?)|(\*\s*(?P.*?)|)\s*(@\(@\s*(?!/)\s*(?P.*?)\s*@\)@|))\s*(=\s*(?P.*?)|(@\(@|)/\s*(?P.*?)\s*/(@\)@|)|)\s*\Z', re.I)
 
@@ -1658,6 +1744,28 @@ def updatevars(typespec, selector, attrspec, entitydecl):
                         d1[k] = unmarkouterparen(d1[k])
                     else:
                         del d1[k]
+
+                if 'len' in d1:
+                    if typespec in ['complex', 'integer', 'logical', 'real']:
+                        if ('kindselector' not in edecl) or (not edecl['kindselector']):
+                            edecl['kindselector'] = {}
+                        edecl['kindselector']['*'] = d1['len']
+                        del d1['len']
+                    elif typespec == 'character':
+                        if ('charselector' not in edecl) or (not edecl['charselector']):
+                            edecl['charselector'] = {}
+                        if 'len' in edecl['charselector']:
+                            del edecl['charselector']['len']
+                        edecl['charselector']['*'] = d1['len']
+                        del d1['len']
+
+                if 'init' in d1:
+                    if '=' in edecl and (not edecl['='] == d1['init']):
+                        outmess('updatevars: attempt to change the init expression of "%s" ("%s") to "%s". Ignoring.\n' % (
+                            ename, edecl['='], d1['init']))
+                    else:
+                        edecl['='] = d1['init']
+
                 if 'len' in d1 and 'array' in d1:
                     if d1['len'] == '':
                         d1['len'] = d1['array']
@@ -1667,6 +1775,7 @@ def updatevars(typespec, selector, attrspec, entitydecl):
                         del d1['len']
                         errmess('updatevars: "%s %s" is mapped to "%s %s(%s)"\n' % (
                             typespec, e, typespec, ename, d1['array']))
+
                 if 'array' in d1:
                     dm = 'dimension(%s)' % d1['array']
                     if 'attrspec' not in edecl or (not edecl['attrspec']):
@@ -1680,23 +1789,6 @@ def updatevars(typespec, selector, attrspec, entitydecl):
                                         % (ename, dm1, dm))
                                 break
 
-                if 'len' in d1:
-                    if typespec in ['complex', 'integer', 'logical', 'real']:
-                        if ('kindselector' not in edecl) or (not edecl['kindselector']):
-                            edecl['kindselector'] = {}
-                        edecl['kindselector']['*'] = d1['len']
-                    elif typespec == 'character':
-                        if ('charselector' not in edecl) or (not edecl['charselector']):
-                            edecl['charselector'] = {}
-                        if 'len' in edecl['charselector']:
-                            del edecl['charselector']['len']
-                        edecl['charselector']['*'] = d1['len']
-                if 'init' in d1:
-                    if '=' in edecl and (not edecl['='] == d1['init']):
-                        outmess('updatevars: attempt to change the init expression of "%s" ("%s") to "%s". Ignoring.\n' % (
-                            ename, edecl['='], d1['init']))
-                    else:
-                        edecl['='] = d1['init']
             else:
                 outmess('updatevars: could not crack entity declaration "%s". Ignoring.\n' % (
                     ename + m.group('after')))
@@ -1747,6 +1839,9 @@ def cracktypespec(typespec, selector):
                         lenkind[lk] = lenkind[lk + '2']
                     charselect[lk] = lenkind[lk]
                     del lenkind[lk + '2']
+                if lenkind['f2py_len'] is not None:
+                    # used to specify the length of assumed length strings
+                    charselect['f2py_len'] = lenkind['f2py_len']
             del charselect['lenkind']
             for k in list(charselect.keys()):
                 if not charselect[k]:
@@ -1816,6 +1911,7 @@ def setcharselector(decl, sel, force=0):
     if 'charselector' not in decl:
         decl['charselector'] = sel
         return decl
+
     for k in list(sel.keys()):
         if force or k not in decl['charselector']:
             decl['charselector'][k] = sel[k]
@@ -2105,7 +2201,8 @@ def analyzebody(block, args, tab=''):
         else:
             as_ = args
         b = postcrack(b, as_, tab=tab + '\t')
-        if b['block'] in ['interface', 'abstract interface'] and not b['body']:
+        if b['block'] in ['interface', 'abstract interface'] and \
+           not b['body'] and not b.get('implementedby'):
             if 'f2pyenhancements' not in b:
                 continue
         if b['block'].replace(' ', '') == 'pythonmodule':
@@ -2387,8 +2484,15 @@ def get_parameters(vars, global_params={}):
                 outmess(f'get_parameters[TODO]: '
                         f'implement evaluation of complex expression {v}\n')
 
+            # Handle _dp for gh-6624
+            # Also fixes gh-20460
+            if real16pattern.search(v):
+                v = 8
+            elif real8pattern.search(v):
+                v = 4
             try:
                 params[n] = eval(v, g_params, params)
+
             except Exception as msg:
                 params[n] = v
                 outmess('get_parameters: got "%s" on %s\n' % (msg, repr(v)))
@@ -2416,6 +2520,7 @@ def _eval_scalar(value, params):
     if _is_kind_number(value):
         value = value.split('_')[0]
     try:
+        # TODO: use symbolic from PR #19805
         value = eval(value, {}, params)
         value = (repr if isinstance(value, str) else str)(value)
     except (NameError, SyntaxError, TypeError):
@@ -2439,10 +2544,10 @@ def analyzevars(block):
         del vars['']
         if 'attrspec' in block['vars']['']:
             gen = block['vars']['']['attrspec']
-            for n in list(vars.keys()):
+            for n in set(vars) | set(b['name'] for b in block['body']):
                 for k in ['public', 'private']:
                     if k in gen:
-                        vars[n] = setattrspec(vars[n], k)
+                        vars[n] = setattrspec(vars.get(n, {}), k)
     svars = []
     args = block['args']
     for a in args:
@@ -2485,7 +2590,6 @@ def analyzevars(block):
                 elif n in block['args']:
                     outmess('analyzevars: typespec of variable %s is not defined in routine %s.\n' % (
                         repr(n), block['name']))
-
         if 'charselector' in vars[n]:
             if 'len' in vars[n]['charselector']:
                 l = vars[n]['charselector']['len']
@@ -2591,7 +2695,10 @@ def analyzevars(block):
                             if dsize.contains(s):
                                 try:
                                     a, b = dsize.linear_solve(s)
-                                    solve_v = lambda s: (s - b) / a
+
+                                    def solve_v(s, a=a, b=b):
+                                        return (s - b) / a
+
                                     all_symbols = set(a.symbols())
                                     all_symbols.update(b.symbols())
                                 except RuntimeError as msg:
@@ -2615,26 +2722,6 @@ def analyzevars(block):
                         dimension_exprs[d] = solver_and_deps
                     vars[n]['dimension'].append(d)
 
-        if 'dimension' in vars[n]:
-            if isstringarray(vars[n]):
-                if 'charselector' in vars[n]:
-                    d = vars[n]['charselector']
-                    if '*' in d:
-                        d = d['*']
-                        errmess('analyzevars: character array "character*%s %s(%s)" is considered as "character %s(%s)"; "intent(c)" is forced.\n'
-                                % (d, n,
-                                   ','.join(vars[n]['dimension']),
-                                   n, ','.join(vars[n]['dimension'] + [d])))
-                        vars[n]['dimension'].append(d)
-                        del vars[n]['charselector']
-                        if 'intent' not in vars[n]:
-                            vars[n]['intent'] = []
-                        if 'c' not in vars[n]['intent']:
-                            vars[n]['intent'].append('c')
-                    else:
-                        errmess(
-                            "analyzevars: charselector=%r unhandled.\n" % (d))
-
         if 'check' not in vars[n] and 'args' in block and n in block['args']:
             # n is an argument that has no checks defined. Here we
             # generate some consistency checks for n, and when n is an
@@ -2644,7 +2731,7 @@ def analyzevars(block):
             n_checks = []
             n_is_input = l_or(isintent_in, isintent_inout,
                               isintent_inplace)(vars[n])
-            if 'dimension' in vars[n]:  # n is array
+            if isarray(vars[n]):  # n is array
                 for i, d in enumerate(vars[n]['dimension']):
                     coeffs_and_deps = dimension_exprs.get(d)
                     if coeffs_and_deps is None:
@@ -2655,15 +2742,22 @@ def analyzevars(block):
                         # may define variables used in dimension
                         # specifications.
                         for v, (solver, deps) in coeffs_and_deps.items():
+                            def compute_deps(v, deps):
+                                for v1 in coeffs_and_deps.get(v, [None, []])[1]:
+                                    if v1 not in deps:
+                                        deps.add(v1)
+                                        compute_deps(v1, deps)
+                            all_deps = set()
+                            compute_deps(v, all_deps)
                             if ((v in n_deps
                                  or '=' in vars[v]
                                  or 'depend' in vars[v])):
                                 # Skip a variable that
                                 # - n depends on
                                 # - has user-defined initialization expression
-                                # - has user-defined dependecies
+                                # - has user-defined dependencies
                                 continue
-                            if solver is not None:
+                            if solver is not None and v not in all_deps:
                                 # v can be solved from d, hence, we
                                 # make it an optional argument with
                                 # initialization expression:
@@ -3161,6 +3255,13 @@ def vars2fortran(block, vars, args, tab='', as_interface=False):
         if 'attrspec' in vars[a]:
             attr = [l for l in vars[a]['attrspec']
                     if l not in ['external']]
+            if as_interface and 'intent(in)' in attr and 'intent(out)' in attr:
+                # In Fortran, intent(in, out) are conflicting while
+                # intent(in, out) can be specified only via
+                # `!f2py intent(out) ..`.
+                # So, for the Fortran interface, we'll drop
+                # intent(out) to resolve the conflict.
+                attr.remove('intent(out)')
             if attr:
                 vardef = '%s, %s' % (vardef, ','.join(attr))
                 c = ','
@@ -3196,14 +3297,23 @@ def vars2fortran(block, vars, args, tab='', as_interface=False):
 ######
 
 
+# We expose post_processing_hooks as global variable so that
+# user-libraries could register their own hooks to f2py.
+post_processing_hooks = []
+
+
 def crackfortran(files):
-    global usermodules
+    global usermodules, post_processing_hooks
 
     outmess('Reading fortran codes...\n', 0)
     readfortrancode(files, crackline)
     outmess('Post-processing...\n', 0)
     usermodules = []
     postlist = postcrack(grouplist[0])
+    outmess('Applying post-processing hooks...\n', 0)
+    for hook in post_processing_hooks:
+        outmess(f'  {hook.__name__}\n', 0)
+        postlist = traverse(postlist, hook)
     outmess('Post-processing (stage 2)...\n', 0)
     postlist = postcrack2(postlist)
     return usermodules + postlist
@@ -3223,6 +3333,142 @@ def crack2fortran(block):
 """ % (f2py_version)
     return header + pyf + footer
 
+
+def _is_visit_pair(obj):
+    return (isinstance(obj, tuple)
+            and len(obj) == 2
+            and isinstance(obj[0], (int, str)))
+
+
+def traverse(obj, visit, parents=[], result=None, *args, **kwargs):
+    '''Traverse f2py data structure with the following visit function:
+
+    def visit(item, parents, result, *args, **kwargs):
+        """
+
+        parents is a list of key-"f2py data structure" pairs from which
+        items are taken from.
+
+        result is a f2py data structure that is filled with the
+        return value of the visit function.
+
+        item is 2-tuple (index, value) if parents[-1][1] is a list
+        item is 2-tuple (key, value) if parents[-1][1] is a dict
+
+        The return value of visit must be None, or of the same kind as
+        item, that is, if parents[-1] is a list, the return value must
+        be 2-tuple (new_index, new_value), or if parents[-1] is a
+        dict, the return value must be 2-tuple (new_key, new_value).
+
+        If new_index or new_value is None, the return value of visit
+        is ignored, that is, it will not be added to the result.
+
+        If the return value is None, the content of obj will be
+        traversed, otherwise not.
+        """
+    '''
+
+    if _is_visit_pair(obj):
+        if obj[0] == 'parent_block':
+            # avoid infinite recursion
+            return obj
+        new_result = visit(obj, parents, result, *args, **kwargs)
+        if new_result is not None:
+            assert _is_visit_pair(new_result)
+            return new_result
+        parent = obj
+        result_key, obj = obj
+    else:
+        parent = (None, obj)
+        result_key = None
+
+    if isinstance(obj, list):
+        new_result = []
+        for index, value in enumerate(obj):
+            new_index, new_item = traverse((index, value), visit,
+                                           parents=parents + [parent],
+                                           result=result, *args, **kwargs)
+            if new_index is not None:
+                new_result.append(new_item)
+    elif isinstance(obj, dict):
+        new_result = dict()
+        for key, value in obj.items():
+            new_key, new_value = traverse((key, value), visit,
+                                          parents=parents + [parent],
+                                          result=result, *args, **kwargs)
+            if new_key is not None:
+                new_result[new_key] = new_value
+    else:
+        new_result = obj
+
+    if result_key is None:
+        return new_result
+    return result_key, new_result
+
+
+def character_backward_compatibility_hook(item, parents, result,
+                                          *args, **kwargs):
+    """Previously, Fortran character was incorrectly treated as
+    character*1. This hook fixes the usage of the corresponding
+    variables in `check`, `dimension`, `=`, and `callstatement`
+    expressions.
+
+    The usage of `char*` in `callprotoargument` expression can be left
+    unchanged because C `character` is C typedef of `char`, although,
+    new implementations should use `character*` in the corresponding
+    expressions.
+
+    See https://github.com/numpy/numpy/pull/19388 for more information.
+
+    """
+    parent_key, parent_value = parents[-1]
+    key, value = item
+
+    def fix_usage(varname, value):
+        value = re.sub(r'[*]\s*\b' + varname + r'\b', varname, value)
+        value = re.sub(r'\b' + varname + r'\b\s*[\[]\s*0\s*[\]]',
+                       varname, value)
+        return value
+
+    if parent_key in ['dimension', 'check']:
+        assert parents[-3][0] == 'vars'
+        vars_dict = parents[-3][1]
+    elif key == '=':
+        assert parents[-2][0] == 'vars'
+        vars_dict = parents[-2][1]
+    else:
+        vars_dict = None
+
+    new_value = None
+    if vars_dict is not None:
+        new_value = value
+        for varname, vd in vars_dict.items():
+            if ischaracter(vd):
+                new_value = fix_usage(varname, new_value)
+    elif key == 'callstatement':
+        vars_dict = parents[-2][1]['vars']
+        new_value = value
+        for varname, vd in vars_dict.items():
+            if ischaracter(vd):
+                # replace all occurrences of `` with
+                # `&` in argument passing
+                new_value = re.sub(
+                    r'(? `{new_value}`\n', 1)
+        return (key, new_value)
+
+
+post_processing_hooks.append(character_backward_compatibility_hook)
+
+
 if __name__ == "__main__":
     files = []
     funcs = []
@@ -3282,17 +3528,18 @@ def crack2fortran(block):
             funcs.append(l)
     if not strictf77 and f77modulename and not skipemptyends:
         outmess("""\
-  Warning: You have specified module name for non Fortran 77 code
-  that should not need one (expect if you are scanning F90 code
-  for non module blocks but then you should use flag -skipemptyends
-  and also be sure that the files do not contain programs without program statement).
+  Warning: You have specified module name for non Fortran 77 code that
+  should not need one (expect if you are scanning F90 code for non
+  module blocks but then you should use flag -skipemptyends and also
+  be sure that the files do not contain programs without program
+  statement).
 """, 0)
 
     postlist = crackfortran(files)
     if pyffilename:
         outmess('Writing fortran code to file %s\n' % repr(pyffilename), 0)
         pyf = crack2fortran(postlist)
-        with open(pyffilename, 'w') as f: 
+        with open(pyffilename, 'w') as f:
             f.write(pyf)
     if showblocklist:
         show(postlist)
diff --git a/numpy/f2py/f2py2e.py b/numpy/f2py/f2py2e.py
index 4d79c304ae91..10508488dc04 100755
--- a/numpy/f2py/f2py2e.py
+++ b/numpy/f2py/f2py2e.py
@@ -18,6 +18,7 @@
 import os
 import pprint
 import re
+from pathlib import Path
 
 from . import crackfortran
 from . import rules
@@ -82,6 +83,9 @@
                    file module.c or extension module .
                    Default is 'untitled'.
 
+  '-include
'  Writes additional headers in the C wrapper, can be passed
+                      multiple times, generates #include 
 each time.
+
   --[no-]lower     Do [not] lower the cases in . By default,
                    --lower is assumed with -h key, and --no-lower without -h key.
 
@@ -118,6 +122,7 @@
 
   --quiet          Run quietly.
   --verbose        Run with extra verbosity.
+  --skip-empty-wrappers   Only generate wrapper files when needed.
   -v               Print f2py version ID and exit.
 
 
@@ -175,6 +180,7 @@ def scaninputline(inputline):
     files, skipfuncs, onlyfuncs, debug = [], [], [], []
     f, f2, f3, f5, f6, f7, f8, f9, f10 = 1, 0, 0, 0, 0, 0, 0, 0, 0
     verbose = 1
+    emptygen = True
     dolc = -1
     dolatexdoc = 0
     dorestdoc = 0
@@ -246,6 +252,8 @@ def scaninputline(inputline):
             f7 = 1
         elif l[:15] in '--include-paths':
             f7 = 1
+        elif l == '--skip-empty-wrappers':
+            emptygen = False
         elif l[0] == '-':
             errmess('Unknown option %s\n' % repr(l))
             sys.exit()
@@ -295,6 +303,7 @@ def scaninputline(inputline):
             'Signature file "%s" exists!!! Use --overwrite-signature to overwrite.\n' % (signsfile))
         sys.exit()
 
+    options['emptygen'] = emptygen
     options['debug'] = debug
     options['verbose'] = verbose
     if dolc == -1 and not signsfile:
@@ -408,14 +417,16 @@ def run_main(comline_list):
     where ``=string.join(,' ')``, but in Python.  Unless
     ``-h`` is used, this function returns a dictionary containing
     information on generated modules and their dependencies on source
-    files.  For example, the command ``f2py -m scalar scalar.f`` can be
-    executed from Python as follows
+    files.
 
     You cannot build extension modules with this function, that is,
-    using ``-c`` is not allowed. Use ``compile`` command instead
+    using ``-c`` is not allowed. Use the ``compile`` command instead.
 
     Examples
     --------
+    The command ``f2py -m scalar scalar.f`` can be executed from Python as
+    follows.
+
     .. literalinclude:: ../../source/f2py/code/results/run_main_session.dat
         :language: python
 
@@ -456,7 +467,7 @@ def run_main(comline_list):
                 errmess(
                     'Tip: If your original code is Fortran source then you must use -m option.\n')
             raise TypeError('All blocks must be python module blocks but got %s' % (
-                repr(postlist[i]['block'])))
+                repr(plist['block'])))
     auxfuncs.debugoptions = options['debug']
     f90mod_rules.options = options
     auxfuncs.wrapfuncs = options['wrapfuncs']
@@ -520,7 +531,7 @@ def run_compile():
         sysinfo_flags = [f[7:] for f in sysinfo_flags]
 
     _reg2 = re.compile(
-        r'--((no-|)(wrap-functions|lower)|debug-capi|quiet)|-include')
+        r'--((no-|)(wrap-functions|lower)|debug-capi|quiet|skip-empty-wrappers)|-include')
     f2py_flags = [_m for _m in sys.argv[1:] if _reg2.match(_m)]
     sys.argv = [_m for _m in sys.argv if _m not in f2py_flags]
     f2py_flags2 = []
diff --git a/numpy/f2py/f2py_testing.py b/numpy/f2py/f2py_testing.py
deleted file mode 100644
index 1f109e67a5e2..000000000000
--- a/numpy/f2py/f2py_testing.py
+++ /dev/null
@@ -1,46 +0,0 @@
-import sys
-import re
-
-from numpy.testing import jiffies, memusage
-
-
-def cmdline():
-    m = re.compile(r'\A\d+\Z')
-    args = []
-    repeat = 1
-    for a in sys.argv[1:]:
-        if m.match(a):
-            repeat = eval(a)
-        else:
-            args.append(a)
-    f2py_opts = ' '.join(args)
-    return repeat, f2py_opts
-
-
-def run(runtest, test_functions, repeat=1):
-    l = [(t, repr(t.__doc__.split('\n')[1].strip())) for t in test_functions]
-    start_memusage = memusage()
-    diff_memusage = None
-    start_jiffies = jiffies()
-    i = 0
-    while i < repeat:
-        i += 1
-        for t, fname in l:
-            runtest(t)
-            if start_memusage is None:
-                continue
-            if diff_memusage is None:
-                diff_memusage = memusage() - start_memusage
-            else:
-                diff_memusage2 = memusage() - start_memusage
-                if diff_memusage2 != diff_memusage:
-                    print('memory usage change at step %i:' % i,
-                          diff_memusage2 - diff_memusage,
-                          fname)
-                    diff_memusage = diff_memusage2
-    current_memusage = memusage()
-    print('run', repeat * len(test_functions), 'tests',
-          'in %.2f seconds' % ((jiffies() - start_jiffies) / 100.0))
-    if start_memusage:
-        print('initial virtual memory size:', start_memusage, 'bytes')
-        print('current virtual memory size:', current_memusage, 'bytes')
diff --git a/numpy/f2py/f90mod_rules.py b/numpy/f2py/f90mod_rules.py
index 3e1c9674f8e2..a3bb6a212a65 100644
--- a/numpy/f2py/f90mod_rules.py
+++ b/numpy/f2py/f90mod_rules.py
@@ -147,17 +147,9 @@ def iadd(line, s=ihooks):
             if not dms:
                 dms = '-1'
             use_fgetdims2 = fgetdims2
-            if isstringarray(var):
-                if 'charselector' in var and 'len' in var['charselector']:
-                    cadd('\t{"%s",%s,{{%s,%s}},%s},'
-                         % (undo_rmbadname1(n), dm['rank'], dms, var['charselector']['len'], at))
-                    use_fgetdims2 = fgetdims2_sa
-                else:
-                    cadd('\t{"%s",%s,{{%s}},%s},' %
-                         (undo_rmbadname1(n), dm['rank'], dms, at))
-            else:
-                cadd('\t{"%s",%s,{{%s}},%s},' %
-                     (undo_rmbadname1(n), dm['rank'], dms, at))
+            cadd('\t{"%s",%s,{{%s}},%s, %s},' %
+                 (undo_rmbadname1(n), dm['rank'], dms, at,
+                  capi_maps.get_elsize(var)))
             dadd('\\item[]{{}\\verb@%s@{}}' %
                  (capi_maps.getarrdocsign(n, var)))
             if hasnote(var):
@@ -216,8 +208,10 @@ def iadd(line, s=ihooks):
                 ar['docs'] = []
                 ar['docshort'] = []
                 ret = dictappend(ret, ar)
-                cadd('\t{"%s",-1,{{-1}},0,NULL,(void *)f2py_rout_#modulename#_%s_%s,doc_f2py_rout_#modulename#_%s_%s},' %
-                     (b['name'], m['name'], b['name'], m['name'], b['name']))
+                cadd(('\t{"%s",-1,{{-1}},0,0,NULL,(void *)'
+                      'f2py_rout_#modulename#_%s_%s,'
+                      'doc_f2py_rout_#modulename#_%s_%s},')
+                     % (b['name'], m['name'], b['name'], m['name'], b['name']))
                 sargs.append('char *%s' % (b['name']))
                 sargsp.append('char *')
                 iadd('\tf2py_%s_def[i_f2py++].data = %s;' %
diff --git a/numpy/f2py/func2subr.py b/numpy/f2py/func2subr.py
index 21d4c009cc26..2a05f065b625 100644
--- a/numpy/f2py/func2subr.py
+++ b/numpy/f2py/func2subr.py
@@ -13,10 +13,6 @@
 Pearu Peterson
 
 """
-__version__ = "$Revision: 1.16 $"[10:-1]
-
-f2py_version = 'See `f2py -v`'
-
 import copy
 
 from .auxfuncs import (
@@ -108,15 +104,19 @@ def add(line, ret=ret):
     else:
         args = [newname] + rout['args']
 
-    l = var2fixfortran(vars, name, newname, f90mode)
-    if l[:13] == 'character*(*)':
+    l_tmpl = var2fixfortran(vars, name, '@@@NAME@@@', f90mode)
+    if l_tmpl[:13] == 'character*(*)':
         if f90mode:
-            l = 'character(len=10)' + l[13:]
+            l_tmpl = 'character(len=10)' + l_tmpl[13:]
         else:
-            l = 'character*10' + l[13:]
+            l_tmpl = 'character*10' + l_tmpl[13:]
         charselect = vars[name]['charselector']
         if charselect.get('*', '') == '(*)':
             charselect['*'] = '10'
+
+    l1 = l_tmpl.replace('@@@NAME@@@', newname)
+    rl = None
+
     sargs = ', '.join(args)
     if f90mode:
         add('subroutine f2pywrap_%s_%s (%s)' %
@@ -127,7 +127,8 @@ def add(line, ret=ret):
         add('subroutine f2pywrap%s (%s)' % (name, sargs))
         if not need_interface:
             add('external %s' % (fortranname))
-            l = l + ', ' + fortranname
+            rl = l_tmpl.replace('@@@NAME@@@', '') + ' ' + fortranname
+
     if need_interface:
         for line in rout['saved_interface'].split('\n'):
             if line.lstrip().startswith('use ') and '__user__' not in line:
@@ -156,7 +157,9 @@ def add(line, ret=ret):
             continue
         add(var2fixfortran(vars, a, f90mode=f90mode))
 
-    add(l)
+    add(l1)
+    if rl is not None:
+        add(rl)
 
     if need_interface:
         if f90mode:
@@ -293,8 +296,8 @@ def assubr(rout):
     if issubroutine_wrap(rout):
         fortranname = getfortranname(rout)
         name = rout['name']
-        outmess('\t\tCreating wrapper for Fortran subroutine "%s"("%s")...\n' % (
-            name, fortranname))
+        outmess('\t\tCreating wrapper for Fortran subroutine "%s"("%s")...\n'
+                % (name, fortranname))
         rout = copy.copy(rout)
         return rout, createsubrwrapper(rout)
     return rout, ''
diff --git a/numpy/f2py/rules.py b/numpy/f2py/rules.py
index 78810a0a74a9..1bac871024d8 100755
--- a/numpy/f2py/rules.py
+++ b/numpy/f2py/rules.py
@@ -50,28 +50,30 @@
 Pearu Peterson
 
 """
-import os
+import os, sys
 import time
 import copy
+from pathlib import Path
 
 # __version__.version is now the same as the NumPy version
 from . import __version__
-f2py_version = __version__.version
-numpy_version = __version__.version
 
 from .auxfuncs import (
     applyrules, debugcapi, dictappend, errmess, gentitle, getargs2,
-    hascallstatement, hasexternals, hasinitvalue, hasnote, hasresultnote,
-    isarray, isarrayofstrings, iscomplex, iscomplexarray,
-    iscomplexfunction, iscomplexfunction_warn, isdummyroutine, isexternal,
-    isfunction, isfunction_wrap, isint1array, isintent_aux, isintent_c,
-    isintent_callback, isintent_copy, isintent_hide, isintent_inout,
-    isintent_nothide, isintent_out, isintent_overwrite, islogical,
-    islong_complex, islong_double, islong_doublefunction, islong_long,
-    islong_longfunction, ismoduleroutine, isoptional, isrequired, isscalar,
-    issigned_long_longarray, isstring, isstringarray, isstringfunction,
-    issubroutine, issubroutine_wrap, isthreadsafe, isunsigned,
-    isunsigned_char, isunsigned_chararray, isunsigned_long_long,
+    hascallstatement, hasexternals, hasinitvalue, hasnote,
+    hasresultnote, isarray, isarrayofstrings, ischaracter,
+    ischaracterarray, ischaracter_or_characterarray, iscomplex,
+    iscomplexarray, iscomplexfunction, iscomplexfunction_warn,
+    isdummyroutine, isexternal, isfunction, isfunction_wrap, isint1,
+    isint1array, isintent_aux, isintent_c, isintent_callback,
+    isintent_copy, isintent_hide, isintent_inout, isintent_nothide,
+    isintent_out, isintent_overwrite, islogical, islong_complex,
+    islong_double, islong_doublefunction, islong_long,
+    islong_longfunction, ismoduleroutine, isoptional, isrequired,
+    isscalar, issigned_long_longarray, isstring, isstringarray,
+    isstringfunction, issubroutine, isattr_value,
+    issubroutine_wrap, isthreadsafe, isunsigned, isunsigned_char,
+    isunsigned_chararray, isunsigned_long_long,
     isunsigned_long_longarray, isunsigned_short, isunsigned_shortarray,
     l_and, l_not, l_or, outmess, replace, stripcomma, requiresf90wrapper
 )
@@ -83,9 +85,12 @@
 from . import f90mod_rules
 from . import func2subr
 
+f2py_version = __version__.version
+numpy_version = __version__.version
+
 options = {}
 sepdict = {}
-#for k in ['need_cfuncs']: sepdict[k]=','
+# for k in ['need_cfuncs']: sepdict[k]=','
 for k in ['decl',
           'frompyobj',
           'cleanupfrompyobj',
@@ -124,6 +129,10 @@
 #define PY_SSIZE_T_CLEAN
 #endif /* PY_SSIZE_T_CLEAN */
 
+/* Unconditionally included */
+#include 
+#include 
+
 """ + gentitle("See f2py2e/cfuncs.py: includes") + """
 #includes#
 #includes0#
@@ -400,10 +409,18 @@
                                ismoduleroutine: '',
                                isdummyroutine: ''
                                },
-        'routine_def': {l_not(l_or(ismoduleroutine, isintent_c, isdummyroutine)): '    {\"#name#\",-1,{{-1}},0,(char *)#F_FUNC#(#fortranname#,#FORTRANNAME#),(f2py_init_func)#apiname#,doc_#apiname#},',
-                        l_and(l_not(ismoduleroutine), isintent_c, l_not(isdummyroutine)): '    {\"#name#\",-1,{{-1}},0,(char *)#fortranname#,(f2py_init_func)#apiname#,doc_#apiname#},',
-                        l_and(l_not(ismoduleroutine), isdummyroutine): '    {\"#name#\",-1,{{-1}},0,NULL,(f2py_init_func)#apiname#,doc_#apiname#},',
-                        },
+        'routine_def': {
+            l_not(l_or(ismoduleroutine, isintent_c, isdummyroutine)):
+            '    {\"#name#\",-1,{{-1}},0,0,(char *)'
+            '  #F_FUNC#(#fortranname#,#FORTRANNAME#),'
+            '  (f2py_init_func)#apiname#,doc_#apiname#},',
+            l_and(l_not(ismoduleroutine), isintent_c, l_not(isdummyroutine)):
+            '    {\"#name#\",-1,{{-1}},0,0,(char *)#fortranname#,'
+            '  (f2py_init_func)#apiname#,doc_#apiname#},',
+            l_and(l_not(ismoduleroutine), isdummyroutine):
+            '    {\"#name#\",-1,{{-1}},0,0,NULL,'
+            '  (f2py_init_func)#apiname#,doc_#apiname#},',
+        },
         'need': {l_and(l_not(l_or(ismoduleroutine, isintent_c)), l_not(isdummyroutine)): 'F_FUNC'},
         'callfortranroutine': [
             {debugcapi: [
@@ -427,9 +444,15 @@
                                isdummyroutine: '',
                                },
 
-        'routine_def': {l_not(l_or(ismoduleroutine, isdummyroutine)): '    {\"#name#\",-1,{{-1}},0,(char *)#F_WRAPPEDFUNC#(#name_lower#,#NAME#),(f2py_init_func)#apiname#,doc_#apiname#},',
-                        isdummyroutine: '    {\"#name#\",-1,{{-1}},0,NULL,(f2py_init_func)#apiname#,doc_#apiname#},',
-                        },
+        'routine_def': {
+            l_not(l_or(ismoduleroutine, isdummyroutine)):
+            '    {\"#name#\",-1,{{-1}},0,0,(char *)'
+            '  #F_WRAPPEDFUNC#(#name_lower#,#NAME#),'
+            '  (f2py_init_func)#apiname#,doc_#apiname#},',
+            isdummyroutine:
+            '    {\"#name#\",-1,{{-1}},0,0,NULL,'
+            '  (f2py_init_func)#apiname#,doc_#apiname#},',
+        },
         'initf2pywraphook': {l_not(l_or(ismoduleroutine, isdummyroutine)): '''
     {
       extern #ctype# #F_FUNC#(#name_lower#,#NAME#)(void);
@@ -465,9 +488,15 @@
                                isdummyroutine: '',
                                },
 
-        'routine_def': {l_not(l_or(ismoduleroutine, isdummyroutine)): '    {\"#name#\",-1,{{-1}},0,(char *)#F_WRAPPEDFUNC#(#name_lower#,#NAME#),(f2py_init_func)#apiname#,doc_#apiname#},',
-                        isdummyroutine: '    {\"#name#\",-1,{{-1}},0,NULL,(f2py_init_func)#apiname#,doc_#apiname#},',
-                        },
+        'routine_def': {
+            l_not(l_or(ismoduleroutine, isdummyroutine)):
+            '    {\"#name#\",-1,{{-1}},0,0,(char *)'
+            '  #F_WRAPPEDFUNC#(#name_lower#,#NAME#),'
+            '  (f2py_init_func)#apiname#,doc_#apiname#},',
+            isdummyroutine:
+            '    {\"#name#\",-1,{{-1}},0,0,NULL,'
+            '  (f2py_init_func)#apiname#,doc_#apiname#},',
+        },
         'initf2pywraphook': {l_not(l_or(ismoduleroutine, isdummyroutine)): '''
     {
       extern void #F_FUNC#(#name_lower#,#NAME#)(void);
@@ -520,10 +549,19 @@
                                l_and(l_not(ismoduleroutine), isintent_c, l_not(isdummyroutine)): 'extern #ctype# #fortranname#(#callprotoargument#);',
                                isdummyroutine: ''
                                },
-        'routine_def': {l_and(l_not(l_or(ismoduleroutine, isintent_c)), l_not(isdummyroutine)): '    {\"#name#\",-1,{{-1}},0,(char *)#F_FUNC#(#fortranname#,#FORTRANNAME#),(f2py_init_func)#apiname#,doc_#apiname#},',
-                        l_and(l_not(ismoduleroutine), isintent_c, l_not(isdummyroutine)): '    {\"#name#\",-1,{{-1}},0,(char *)#fortranname#,(f2py_init_func)#apiname#,doc_#apiname#},',
-                        isdummyroutine: '    {\"#name#\",-1,{{-1}},0,NULL,(f2py_init_func)#apiname#,doc_#apiname#},',
-                        },
+        'routine_def': {
+            l_and(l_not(l_or(ismoduleroutine, isintent_c)),
+                  l_not(isdummyroutine)):
+            ('    {\"#name#\",-1,{{-1}},0,0,(char *)'
+             '  #F_FUNC#(#fortranname#,#FORTRANNAME#),'
+             '  (f2py_init_func)#apiname#,doc_#apiname#},'),
+            l_and(l_not(ismoduleroutine), isintent_c, l_not(isdummyroutine)):
+            ('    {\"#name#\",-1,{{-1}},0,0,(char *)#fortranname#,'
+             '  (f2py_init_func)#apiname#,doc_#apiname#},'),
+            isdummyroutine:
+            '    {\"#name#\",-1,{{-1}},0,0,NULL,'
+            '(f2py_init_func)#apiname#,doc_#apiname#},',
+        },
         'decl': [{iscomplexfunction_warn: '    #ctype# #name#_return_value={0,0};',
                   l_not(iscomplexfunction): '    #ctype# #name#_return_value=0;'},
                  {iscomplexfunction:
@@ -557,9 +595,9 @@
     }, {  # String function # in use for --no-wrap
         'declfortranroutine': 'extern void #F_FUNC#(#fortranname#,#FORTRANNAME#)(#callprotoargument#);',
         'routine_def': {l_not(l_or(ismoduleroutine, isintent_c)):
-                        '    {\"#name#\",-1,{{-1}},0,(char *)#F_FUNC#(#fortranname#,#FORTRANNAME#),(f2py_init_func)#apiname#,doc_#apiname#},',
+                        '    {\"#name#\",-1,{{-1}},0,0,(char *)#F_FUNC#(#fortranname#,#FORTRANNAME#),(f2py_init_func)#apiname#,doc_#apiname#},',
                         l_and(l_not(ismoduleroutine), isintent_c):
-                        '    {\"#name#\",-1,{{-1}},0,(char *)#fortranname#,(f2py_init_func)#apiname#,doc_#apiname#},'
+                        '    {\"#name#\",-1,{{-1}},0,0,(char *)#fortranname#,(f2py_init_func)#apiname#,doc_#apiname#},'
                         },
         'decl': ['    #ctype# #name#_return_value = NULL;',
                  '    int #name#_return_value_len = 0;'],
@@ -618,6 +656,8 @@
                      isunsigned_shortarray: 'unsigned_short',
                      isunsigned_long_longarray: 'unsigned_long_long',
                      issigned_long_longarray: 'long_long',
+                     isint1: 'signed_char',
+                     ischaracter_or_characterarray: 'character',
                      }
 
 aux_rules = [
@@ -680,7 +720,7 @@
      },
     # Integer*-1 array
     {'need': '#ctype#',
-     '_check': isunsigned_chararray,
+     '_check': l_or(isunsigned_chararray, isunsigned_char),
      '_depend': ''
      },
     # Integer*-2 array
@@ -834,7 +874,7 @@
     {  # Common
         'decl': '    #ctype# #varname# = 0;',
         'pyobjfrom': {debugcapi: '    fprintf(stderr,"#vardebugshowvalue#\\n",#varname#);'},
-        'callfortran': {isintent_c: '#varname#,', l_not(isintent_c): '&#varname#,'},
+        'callfortran': {l_or(isintent_c, isattr_value): '#varname#,', l_not(l_or(isintent_c, isattr_value)): '&#varname#,'},
         'return': {isintent_out: ',#varname#'},
         '_check': l_and(isscalar, l_not(iscomplex))
     }, {
@@ -851,7 +891,8 @@
     if (f2py_success) {"""},
         'closepyobjfrom': {isintent_inout: "    } /*if (f2py_success) of #varname# pyobjfrom*/"},
         'need': {isintent_inout: 'try_pyarr_from_#ctype#'},
-        '_check': l_and(isscalar, l_not(iscomplex), isintent_nothide)
+        '_check': l_and(isscalar, l_not(iscomplex), l_not(isstring),
+                        isintent_nothide)
     }, {
         'frompyobj': [
             # hasinitvalue...
@@ -958,11 +999,11 @@
         'return': {isintent_out: ',#varname#'},
         'need': ['len..',
                  {l_and(isintent_out, l_not(isintent_c)): 'STRINGPADN'}],
-        '_check':isstring
+        '_check': isstring
     }, {  # Common
         'frompyobj': [
             """\
-    slen(#varname#) = #length#;
+    slen(#varname#) = #elsize#;
     f2py_success = #ctype#_from_pyobj(&#varname#,&slen(#varname#),#init#,"""
 """#varname#_capi,\"#ctype#_from_pyobj failed in converting #nth#"""
 """`#varname#\' of #pyname# to C #ctype#\");
@@ -1006,11 +1047,13 @@
         'decl': ['    #ctype# *#varname# = NULL;',
                  '    npy_intp #varname#_Dims[#rank#] = {#rank*[-1]#};',
                  '    const int #varname#_Rank = #rank#;',
-                 '    PyArrayObject *capi_#varname#_tmp = NULL;',
+                 '    PyArrayObject *capi_#varname#_as_array = NULL;',
                  '    int capi_#varname#_intent = 0;',
+                 {isstringarray: '    int slen(#varname#) = 0;'},
                  ],
         'callfortran':'#varname#,',
-        'return':{isintent_out: ',capi_#varname#_tmp'},
+        'callfortranappend': {isstringarray: 'slen(#varname#),'},
+        'return': {isintent_out: ',capi_#varname#_as_array'},
         'need': 'len..',
         '_check': isarray
     }, {  # intent(overwrite) array
@@ -1052,36 +1095,48 @@
         'keys_capi': {isoptional: ',&#varname#_capi'},
         '_check': l_and(isarray, isintent_nothide)
     }, {
-        'frompyobj': ['    #setdims#;',
-                      '    capi_#varname#_intent |= #intent#;',
-                      {isintent_hide:
-                       '    capi_#varname#_tmp = array_from_pyobj(#atype#,#varname#_Dims,#varname#_Rank,capi_#varname#_intent,Py_None);'},
-                      {isintent_nothide:
-                       '    capi_#varname#_tmp = array_from_pyobj(#atype#,#varname#_Dims,#varname#_Rank,capi_#varname#_intent,#varname#_capi);'},
-                      """\
-    if (capi_#varname#_tmp == NULL) {
-        PyObject *exc, *val, *tb;
-        PyErr_Fetch(&exc, &val, &tb);
-        PyErr_SetString(exc ? exc : #modulename#_error,\"failed in converting #nth# `#varname#\' of #pyname# to C/Fortran array\" );
-        npy_PyErr_ChainExceptionsCause(exc, val, tb);
+        'frompyobj': [
+            '    #setdims#;',
+            '    capi_#varname#_intent |= #intent#;',
+            ('    const char * capi_errmess = "#modulename#.#pyname#:'
+             ' failed to create array from the #nth# `#varname#`";'),
+            {isintent_hide:
+             '    capi_#varname#_as_array = ndarray_from_pyobj('
+             '  #atype#,#elsize#,#varname#_Dims,#varname#_Rank,'
+             '  capi_#varname#_intent,Py_None,capi_errmess);'},
+            {isintent_nothide:
+             '    capi_#varname#_as_array = ndarray_from_pyobj('
+             '  #atype#,#elsize#,#varname#_Dims,#varname#_Rank,'
+             '  capi_#varname#_intent,#varname#_capi,capi_errmess);'},
+            """\
+    if (capi_#varname#_as_array == NULL) {
+        PyObject* capi_err = PyErr_Occurred();
+        if (capi_err == NULL) {
+            capi_err = #modulename#_error;
+            PyErr_SetString(capi_err, capi_errmess);
+        }
     } else {
-        #varname# = (#ctype# *)(PyArray_DATA(capi_#varname#_tmp));
+        #varname# = (#ctype# *)(PyArray_DATA(capi_#varname#_as_array));
 """,
-                      {hasinitvalue: [
-                          {isintent_nothide:
-                              '    if (#varname#_capi == Py_None) {'},
-                          {isintent_hide: '    {'},
-                          {iscomplexarray: '        #ctype# capi_c;'},
-                          """\
+            {isstringarray:
+             '    slen(#varname#) = f2py_itemsize(#varname#);'},
+            {hasinitvalue: [
+                {isintent_nothide:
+                 '    if (#varname#_capi == Py_None) {'},
+                {isintent_hide: '    {'},
+                {iscomplexarray: '        #ctype# capi_c;'},
+                """\
         int *_i,capi_i=0;
         CFUNCSMESS(\"#name#: Initializing #varname#=#init#\\n\");
-        if (initforcomb(PyArray_DIMS(capi_#varname#_tmp),PyArray_NDIM(capi_#varname#_tmp),1)) {
+        if (initforcomb(PyArray_DIMS(capi_#varname#_as_array),
+                        PyArray_NDIM(capi_#varname#_as_array),1)) {
             while ((_i = nextforcomb()))
                 #varname#[capi_i++] = #init#; /* fortran way */
         } else {
             PyObject *exc, *val, *tb;
             PyErr_Fetch(&exc, &val, &tb);
-            PyErr_SetString(exc ? exc : #modulename#_error,\"Initialization of #nth# #varname# failed (initforcomb).\");
+            PyErr_SetString(exc ? exc : #modulename#_error,
+                \"Initialization of #nth# #varname# failed (initforcomb).\");
             npy_PyErr_ChainExceptionsCause(exc, val, tb);
             f2py_success = 0;
         }
@@ -1089,12 +1144,13 @@
     if (f2py_success) {"""]},
                       ],
         'cleanupfrompyobj': [  # note that this list will be reversed
-            '    }  /*if (capi_#varname#_tmp == NULL) ... else of #varname#*/',
+            '    }  '
+            '/* if (capi_#varname#_as_array == NULL) ... else of #varname# */',
             {l_not(l_or(isintent_out, isintent_hide)): """\
-    if((PyObject *)capi_#varname#_tmp!=#varname#_capi) {
-        Py_XDECREF(capi_#varname#_tmp); }"""},
+    if((PyObject *)capi_#varname#_as_array!=#varname#_capi) {
+        Py_XDECREF(capi_#varname#_as_array); }"""},
             {l_and(isintent_hide, l_not(isintent_out))
-                   : """        Py_XDECREF(capi_#varname#_tmp);"""},
+                   : """        Py_XDECREF(capi_#varname#_as_array);"""},
             {hasinitvalue: '    }  /*if (f2py_success) of #varname# init*/'},
         ],
         '_check': isarray,
@@ -1131,6 +1187,16 @@
      '_check': iscomplexarray,
      '_depend': ''
      },
+    # Character
+    {
+        'need': 'string',
+        '_check': ischaracter,
+    },
+    # Character array
+    {
+        'need': 'string',
+        '_check': ischaracterarray,
+    },
     # Stringarray
     {
         'callfortranappend': {isarrayofstrings: 'flen(#varname#),'},
@@ -1198,8 +1264,8 @@ def buildmodule(m, um):
                     break
 
         if not nb:
-            errmess(
-                'buildmodule: Could not found the body of interfaced routine "%s". Skipping.\n' % (n))
+            print(
+                'buildmodule: Could not find the body of interfaced routine "%s". Skipping.\n' % (n), file=sys.stderr)
             continue
         nb_list = [nb]
         if 'entry' in nb:
@@ -1213,6 +1279,22 @@ def buildmodule(m, um):
             # requiresf90wrapper must be called before buildapi as it
             # rewrites assumed shape arrays as automatic arrays.
             isf90 = requiresf90wrapper(nb)
+            # options is in scope here
+            if options['emptygen']:
+                b_path = options['buildpath']
+                m_name = vrd['modulename']
+                outmess('    Generating possibly empty wrappers"\n')
+                Path(f"{b_path}/{vrd['coutput']}").touch()
+                if isf90:
+                    # f77 + f90 wrappers
+                    outmess(f'    Maybe empty "{m_name}-f2pywrappers2.f90"\n')
+                    Path(f'{b_path}/{m_name}-f2pywrappers2.f90').touch()
+                    outmess(f'    Maybe empty "{m_name}-f2pywrappers.f"\n')
+                    Path(f'{b_path}/{m_name}-f2pywrappers.f').touch()
+                else:
+                    # only f77 wrappers
+                    outmess(f'    Maybe empty "{m_name}-f2pywrappers.f"\n')
+                    Path(f'{b_path}/{m_name}-f2pywrappers.f').touch()
             api, wrap = buildapi(nb)
             if wrap:
                 if isf90:
@@ -1241,6 +1323,9 @@ def buildmodule(m, um):
         rd = dictappend(rd, ar)
 
     needs = cfuncs.get_needs()
+    # Add mapped definitions
+    needs['typedefs'] += [cvar for cvar in capi_maps.f2cmap_mapped #
+                          if cvar in typedef_need_dict.values()]
     code = {}
     for n in needs.keys():
         code[n] = []
diff --git a/numpy/f2py/src/fortranobject.c b/numpy/f2py/src/fortranobject.c
index 0b32137efde6..add6e8b6ef29 100644
--- a/numpy/f2py/src/fortranobject.c
+++ b/numpy/f2py/src/fortranobject.c
@@ -5,6 +5,7 @@
 extern "C" {
 #endif
 
+#include 
 #include 
 #include 
 
@@ -101,6 +102,20 @@ F2PyGetThreadLocalCallbackPtr(char *key)
     return prev;
 }
 
+static PyArray_Descr *
+get_descr_from_type_and_elsize(const int type_num, const int elsize)  {
+  PyArray_Descr * descr = PyArray_DescrFromType(type_num);
+  if (type_num == NPY_STRING) {
+    // PyArray_DescrFromType returns descr with elsize = 0.
+    PyArray_DESCR_REPLACE(descr);
+    if (descr == NULL) {
+      return NULL;
+    }
+    descr->elsize = elsize;
+  }
+  return descr;
+}
+
 /************************* FortranObject *******************************/
 
 typedef PyObject *(*fortranfunc)(PyObject *, PyObject *, PyObject *, void *);
@@ -141,18 +156,17 @@ PyFortranObject_New(FortranDataDef *defs, f2py_void_func init)
         }
         else if ((fp->defs[i].data) !=
                  NULL) { /* Is Fortran variable or array (not allocatable) */
-            if (fp->defs[i].type == NPY_STRING) {
-                npy_intp n = fp->defs[i].rank - 1;
-                v = PyArray_New(&PyArray_Type, n, fp->defs[i].dims.d,
-                                NPY_STRING, NULL, fp->defs[i].data,
-                                fp->defs[i].dims.d[n], NPY_ARRAY_FARRAY, NULL);
-            }
-            else {
-                v = PyArray_New(&PyArray_Type, fp->defs[i].rank,
-                                fp->defs[i].dims.d, fp->defs[i].type, NULL,
-                                fp->defs[i].data, 0, NPY_ARRAY_FARRAY, NULL);
+            PyArray_Descr *
+            descr = get_descr_from_type_and_elsize(fp->defs[i].type,
+                                                   fp->defs[i].elsize);
+            if (descr == NULL) {
+                goto fail;
             }
+            v = PyArray_NewFromDescr(&PyArray_Type, descr, fp->defs[i].rank,
+                                     fp->defs[i].dims.d, NULL, fp->defs[i].data,
+                                     NPY_ARRAY_FARRAY, NULL);
             if (v == NULL) {
+                Py_DECREF(descr);
                 goto fail;
             }
             PyDict_SetItemString(fp->dict, fp->defs[i].name, v);
@@ -178,6 +192,13 @@ PyFortranObject_NewAsAttr(FortranDataDef *defs)
     }
     fp->len = 1;
     fp->defs = defs;
+    if (defs->rank == -1) {
+      PyDict_SetItemString(fp->dict, "__name__", PyUnicode_FromFormat("function %s", defs->name));
+    } else if (defs->rank == 0) {
+      PyDict_SetItemString(fp->dict, "__name__", PyUnicode_FromFormat("scalar %s", defs->name));
+    } else {
+      PyDict_SetItemString(fp->dict, "__name__", PyUnicode_FromFormat("array %s", defs->name));
+    }
     return (PyObject *)fp;
 }
 
@@ -697,20 +718,20 @@ f2py_report_on_array_copy_fromany(void)
  * $Id: fortranobject.c,v 1.52 2005/07/11 07:44:20 pearu Exp $
  */
 
-static int
-check_and_fix_dimensions(const PyArrayObject *arr, const int rank,
-                         npy_intp *dims);
+static int check_and_fix_dimensions(const PyArrayObject* arr,
+                                    const int rank,
+                                    npy_intp *dims,
+                                    const char *errmess);
 
 static int
-count_negative_dimensions(const int rank, const npy_intp *dims)
+find_first_negative_dimension(const int rank, const npy_intp *dims)
 {
-    int i = 0, r = 0;
-    while (i < rank) {
-        if (dims[i] < 0)
-            ++r;
-        ++i;
+    for (int i = 0; i < rank; ++i) {
+        if (dims[i] < 0) {
+            return i;
+        }
     }
-    return r;
+    return -1;
 }
 
 #ifdef DEBUG_COPY_ND_ARRAY
@@ -763,83 +784,176 @@ swap_arrays(PyArrayObject *obj1, PyArrayObject *obj2)
     return 0;
 }
 
-#define ARRAY_ISCOMPATIBLE(arr, type_num)                         \
-    ((PyArray_ISINTEGER(arr) && PyTypeNum_ISINTEGER(type_num)) || \
-     (PyArray_ISFLOAT(arr) && PyTypeNum_ISFLOAT(type_num)) ||     \
-     (PyArray_ISCOMPLEX(arr) && PyTypeNum_ISCOMPLEX(type_num)) || \
-     (PyArray_ISBOOL(arr) && PyTypeNum_ISBOOL(type_num)))
+#define ARRAY_ISCOMPATIBLE(arr,type_num)                                \
+    ((PyArray_ISINTEGER(arr) && PyTypeNum_ISINTEGER(type_num)) ||     \
+     (PyArray_ISFLOAT(arr) && PyTypeNum_ISFLOAT(type_num)) ||         \
+     (PyArray_ISCOMPLEX(arr) && PyTypeNum_ISCOMPLEX(type_num)) ||     \
+     (PyArray_ISBOOL(arr) && PyTypeNum_ISBOOL(type_num)) ||           \
+     (PyArray_ISSTRING(arr) && PyTypeNum_ISSTRING(type_num)))
+
+static int
+get_elsize(PyObject *obj) {
+  /*
+    get_elsize determines array itemsize from a Python object.  Returns
+    elsize if successful, -1 otherwise.
+
+    Supported types of the input are: numpy.ndarray, bytes, str, tuple,
+    list.
+  */
+
+  if (PyArray_Check(obj)) {
+    return PyArray_DESCR((PyArrayObject *)obj)->elsize;
+  } else if (PyBytes_Check(obj)) {
+    return PyBytes_GET_SIZE(obj);
+  } else if (PyUnicode_Check(obj)) {
+    return PyUnicode_GET_LENGTH(obj);
+  } else if (PySequence_Check(obj)) {
+    PyObject* fast = PySequence_Fast(obj, "f2py:fortranobject.c:get_elsize");
+    if (fast != NULL) {
+      Py_ssize_t i, n = PySequence_Fast_GET_SIZE(fast);
+      int sz, elsize = 0;
+      for (i=0; i elsize) {
+          elsize = sz;
+        }
+      }
+      Py_DECREF(fast);
+      return elsize;
+    }
+  }
+  return -1;
+}
 
 extern PyArrayObject *
-array_from_pyobj(const int type_num, npy_intp *dims, const int rank,
-                 const int intent, PyObject *obj)
-{
+ndarray_from_pyobj(const int type_num,
+                   const int elsize_,
+                   npy_intp *dims,
+                   const int rank,
+                   const int intent,
+                   PyObject *obj,
+                   const char *errmess) {
     /*
+     * Return an array with given element type and shape from a Python
+     * object while taking into account the usage intent of the array.
+     *
+     * - element type is defined by type_num and elsize
+     * - shape is defined by dims and rank
+     *
+     * ndarray_from_pyobj is used to convert Python object arguments
+     * to numpy ndarrays with given type and shape that data is passed
+     * to interfaced Fortran or C functions.
+     *
+     * errmess (if not NULL), contains a prefix of an error message
+     * for an exception to be triggered within this function.
+     *
+     * Negative elsize value means that elsize is to be determined
+     * from the Python object in runtime.
+     *
+     * Note on strings
+     * ---------------
+     *
+     * String type (type_num == NPY_STRING) does not have fixed
+     * element size and, by default, the type object sets it to
+     * 0. Therefore, for string types, one has to use elsize
+     * argument. For other types, elsize value is ignored.
+     *
+     * NumPy defines the type of a fixed-width string as
+     * dtype('S'). In addition, there is also dtype('c'), that
+     * appears as dtype('S1') (these have the same type_num value),
+     * but is actually different (.char attribute is either 'S' or
+     * 'c', respecitely).
+     *
+     * In Fortran, character arrays and strings are different
+     * concepts.  The relation between Fortran types, NumPy dtypes,
+     * and type_num-elsize pairs, is defined as follows:
+     *
+     * character*5 foo     | dtype('S5')  | elsize=5, shape=()
+     * character(5) foo    | dtype('S1')  | elsize=1, shape=(5)
+     * character*5 foo(n)  | dtype('S5')  | elsize=5, shape=(n,)
+     * character(5) foo(n) | dtype('S1')  | elsize=1, shape=(5, n)
+     * character*(*) foo   | dtype('S')   | elsize=-1, shape=()
+     *
      * Note about reference counting
-     *  -----------------------------
+     * -----------------------------
+     *
      * If the caller returns the array to Python, it must be done with
-     * Py_BuildValue("N",arr).
-     * Otherwise, if obj!=arr then the caller must call Py_DECREF(arr).
+     * Py_BuildValue("N",arr).  Otherwise, if obj!=arr then the caller
+     * must call Py_DECREF(arr).
      *
      * Note on intent(cache,out,..)
-     * ---------------------
+     * ----------------------------
      * Don't expect correct data when returning intent(cache) array.
      *
      */
-    char mess[200];
+    char mess[F2PY_MESSAGE_BUFFER_SIZE];
     PyArrayObject *arr = NULL;
-    PyArray_Descr *descr;
-    char typechar;
-    int elsize;
-
-    if ((intent & F2PY_INTENT_HIDE) ||
-        ((intent & F2PY_INTENT_CACHE) && (obj == Py_None)) ||
-        ((intent & F2PY_OPTIONAL) && (obj == Py_None))) {
+    int elsize = (elsize_ < 0 ? get_elsize(obj) : elsize_);
+    if (elsize < 0) {
+      if (errmess != NULL) {
+        strcpy(mess, errmess);
+      }
+      sprintf(mess + strlen(mess),
+              " -- failed to determine element size from %s",
+              Py_TYPE(obj)->tp_name);
+      PyErr_SetString(PyExc_SystemError, mess);
+      return NULL;
+    }
+    PyArray_Descr * descr = get_descr_from_type_and_elsize(type_num, elsize);  // new reference
+    if (descr == NULL) {
+      return NULL;
+    }
+    elsize = descr->elsize;
+    if ((intent & F2PY_INTENT_HIDE)
+        || ((intent & F2PY_INTENT_CACHE) && (obj == Py_None))
+        || ((intent & F2PY_OPTIONAL) && (obj == Py_None))
+        ) {
         /* intent(cache), optional, intent(hide) */
-        if (count_negative_dimensions(rank, dims) > 0) {
+        int ineg = find_first_negative_dimension(rank, dims);
+        if (ineg >= 0) {
             int i;
-            strcpy(mess,
-                   "failed to create intent(cache|hide)|optional array"
+            strcpy(mess, "failed to create intent(cache|hide)|optional array"
                    "-- must have defined dimensions but got (");
-            for (i = 0; i < rank; ++i)
+            for(i = 0; i < rank; ++i)
                 sprintf(mess + strlen(mess), "%" NPY_INTP_FMT ",", dims[i]);
             strcat(mess, ")");
             PyErr_SetString(PyExc_ValueError, mess);
+            Py_DECREF(descr);
             return NULL;
         }
-        arr = (PyArrayObject *)PyArray_New(&PyArray_Type, rank, dims, type_num,
-                                           NULL, NULL, 1,
-                                           !(intent & F2PY_INTENT_C), NULL);
-        if (arr == NULL)
-            return NULL;
-        if (!(intent & F2PY_INTENT_CACHE))
-            PyArray_FILLWBYTE(arr, 0);
+        arr = (PyArrayObject *)                                      \
+          PyArray_NewFromDescr(&PyArray_Type, descr, rank, dims,
+                               NULL, NULL, !(intent & F2PY_INTENT_C), NULL);
+        if (arr == NULL) {
+          Py_DECREF(descr);
+          return NULL;
+        }
+        if (PyArray_ITEMSIZE(arr) != elsize) {
+          strcpy(mess, "failed to create intent(cache|hide)|optional array");
+          sprintf(mess+strlen(mess)," -- expected elsize=%d got %" NPY_INTP_FMT, elsize, (npy_intp)PyArray_ITEMSIZE(arr));
+          PyErr_SetString(PyExc_ValueError,mess);
+          Py_DECREF(arr);
+          return NULL;
+        }
+        if (!(intent & F2PY_INTENT_CACHE)) {
+          PyArray_FILLWBYTE(arr, 0);
+        }
         return arr;
     }
 
-    descr = PyArray_DescrFromType(type_num);
-    /* compatibility with NPY_CHAR */
-    if (type_num == NPY_STRING) {
-        PyArray_DESCR_REPLACE(descr);
-        if (descr == NULL) {
-            return NULL;
-        }
-        descr->elsize = 1;
-        descr->type = NPY_CHARLTR;
-    }
-    elsize = descr->elsize;
-    typechar = descr->type;
-    Py_DECREF(descr);
     if (PyArray_Check(obj)) {
         arr = (PyArrayObject *)obj;
-
         if (intent & F2PY_INTENT_CACHE) {
             /* intent(cache) */
-            if (PyArray_ISONESEGMENT(arr) && PyArray_ITEMSIZE(arr) >= elsize) {
-                if (check_and_fix_dimensions(arr, rank, dims)) {
-                    return NULL;
+            if (PyArray_ISONESEGMENT(arr)
+                && PyArray_ITEMSIZE(arr) >= elsize) {
+                if (check_and_fix_dimensions(arr, rank, dims, errmess)) {
+                  Py_DECREF(descr);
+                  return NULL;
                 }
                 if (intent & F2PY_INTENT_OUT)
-                    Py_INCREF(arr);
+                  Py_INCREF(arr);
+                Py_DECREF(descr);
                 return arr;
             }
             strcpy(mess, "failed to initialize intent(cache) array");
@@ -851,14 +965,16 @@ array_from_pyobj(const int type_num, npy_intp *dims, const int rank,
                         "%" NPY_INTP_FMT,
                         elsize, (npy_intp)PyArray_ITEMSIZE(arr));
             PyErr_SetString(PyExc_ValueError, mess);
+            Py_DECREF(descr);
             return NULL;
         }
 
         /* here we have always intent(in) or intent(inout) or intent(inplace)
          */
 
-        if (check_and_fix_dimensions(arr, rank, dims)) {
-            return NULL;
+        if (check_and_fix_dimensions(arr, rank, dims, errmess)) {
+          Py_DECREF(descr);
+          return NULL;
         }
         /*
         printf("intent alignment=%d\n", F2PY_GET_ALIGNMENT(intent));
@@ -867,16 +983,18 @@ array_from_pyobj(const int type_num, npy_intp *dims, const int rank,
         for (i=1;i<=16;i++)
           printf("i=%d isaligned=%d\n", i, ARRAY_ISALIGNED(arr, i));
         */
-        if ((!(intent & F2PY_INTENT_COPY)) &&
+        if ((! (intent & F2PY_INTENT_COPY)) &&
             PyArray_ITEMSIZE(arr) == elsize &&
-            ARRAY_ISCOMPATIBLE(arr, type_num) &&
+            ARRAY_ISCOMPATIBLE(arr,type_num) &&
             F2PY_CHECK_ALIGNMENT(arr, intent)) {
-            if ((intent & F2PY_INTENT_C) ? PyArray_ISCARRAY_RO(arr)
-                                         : PyArray_ISFARRAY_RO(arr)) {
+            if ((intent & F2PY_INTENT_INOUT || intent & F2PY_INTENT_INPLACE)
+              ? ((intent & F2PY_INTENT_C) ? PyArray_ISCARRAY(arr) : PyArray_ISFARRAY(arr))
+              : ((intent & F2PY_INTENT_C) ? PyArray_ISCARRAY_RO(arr) : PyArray_ISFARRAY_RO(arr))) {
                 if ((intent & F2PY_INTENT_OUT)) {
                     Py_INCREF(arr);
                 }
                 /* Returning input array */
+                Py_DECREF(descr);
                 return arr;
             }
         }
@@ -891,42 +1009,48 @@ array_from_pyobj(const int type_num, npy_intp *dims, const int rank,
             if (PyArray_ITEMSIZE(arr) != elsize)
                 sprintf(mess + strlen(mess),
                         " -- expected elsize=%d but got %" NPY_INTP_FMT,
-                        elsize, (npy_intp)PyArray_ITEMSIZE(arr));
-            if (!(ARRAY_ISCOMPATIBLE(arr, type_num)))
+                        elsize,
+                        (npy_intp)PyArray_ITEMSIZE(arr)
+                        );
+            if (!(ARRAY_ISCOMPATIBLE(arr, type_num))) {
                 sprintf(mess + strlen(mess),
                         " -- input '%c' not compatible to '%c'",
-                        PyArray_DESCR(arr)->type, typechar);
+                        PyArray_DESCR(arr)->type, descr->type);
+            }
             if (!(F2PY_CHECK_ALIGNMENT(arr, intent)))
                 sprintf(mess + strlen(mess), " -- input not %d-aligned",
                         F2PY_GET_ALIGNMENT(intent));
             PyErr_SetString(PyExc_ValueError, mess);
+            Py_DECREF(descr);
             return NULL;
         }
 
         /* here we have always intent(in) or intent(inplace) */
 
         {
-            PyArrayObject *retarr;
-            retarr = (PyArrayObject *)PyArray_New(
-                    &PyArray_Type, PyArray_NDIM(arr), PyArray_DIMS(arr),
-                    type_num, NULL, NULL, 1, !(intent & F2PY_INTENT_C), NULL);
-            if (retarr == NULL)
-                return NULL;
-            F2PY_REPORT_ON_ARRAY_COPY_FROMARR;
-            if (PyArray_CopyInto(retarr, arr)) {
-                Py_DECREF(retarr);
-                return NULL;
-            }
-            if (intent & F2PY_INTENT_INPLACE) {
-                if (swap_arrays(arr, retarr))
-                    return NULL; /* XXX: set exception */
-                Py_XDECREF(retarr);
-                if (intent & F2PY_INTENT_OUT)
-                    Py_INCREF(arr);
-            }
-            else {
-                arr = retarr;
+          PyArrayObject * retarr = (PyArrayObject *)                    \
+            PyArray_NewFromDescr(&PyArray_Type, descr, PyArray_NDIM(arr), PyArray_DIMS(arr),
+                                 NULL, NULL, !(intent & F2PY_INTENT_C), NULL);
+          if (retarr==NULL) {
+            Py_DECREF(descr);
+            return NULL;
+          }
+          F2PY_REPORT_ON_ARRAY_COPY_FROMARR;
+          if (PyArray_CopyInto(retarr, arr)) {
+            Py_DECREF(retarr);
+            return NULL;
+          }
+          if (intent & F2PY_INTENT_INPLACE) {
+            if (swap_arrays(arr,retarr)) {
+              Py_DECREF(retarr);
+              return NULL; /* XXX: set exception */
             }
+            Py_XDECREF(retarr);
+            if (intent & F2PY_INTENT_OUT)
+              Py_INCREF(arr);
+          } else {
+            arr = retarr;
+          }
         }
         return arr;
     }
@@ -937,20 +1061,11 @@ array_from_pyobj(const int type_num, npy_intp *dims, const int rank,
                      "failed to initialize intent(inout|inplace|cache) "
                      "array, input '%s' object is not an array",
                      Py_TYPE(obj)->tp_name);
+        Py_DECREF(descr);
         return NULL;
     }
 
     {
-        PyArray_Descr *descr = PyArray_DescrFromType(type_num);
-        /* compatibility with NPY_CHAR */
-        if (type_num == NPY_STRING) {
-            PyArray_DESCR_REPLACE(descr);
-            if (descr == NULL) {
-                return NULL;
-            }
-            descr->elsize = 1;
-            descr->type = NPY_CHARLTR;
-        }
         F2PY_REPORT_ON_ARRAY_COPY_FROMANY;
         arr = (PyArrayObject *)PyArray_FromAny(
                 obj, descr, 0, 0,
@@ -958,22 +1073,54 @@ array_from_pyobj(const int type_num, npy_intp *dims, const int rank,
                                           : NPY_ARRAY_FARRAY) |
                         NPY_ARRAY_FORCECAST,
                 NULL);
-        if (arr == NULL)
-            return NULL;
-        if (check_and_fix_dimensions(arr, rank, dims)) {
-            return NULL;
+        // Warning: in the case of NPY_STRING, PyArray_FromAny may
+        // reset descr->elsize, e.g. dtype('S0') becomes dtype('S1').
+        if (arr == NULL) {
+          Py_DECREF(descr);
+          return NULL;
+        }
+        if (type_num != NPY_STRING && PyArray_ITEMSIZE(arr) != elsize) {
+          // This is internal sanity tests: elsize has been set to
+          // descr->elsize in the beginning of this function.
+          strcpy(mess, "failed to initialize intent(in) array");
+          sprintf(mess + strlen(mess),
+                  " -- expected elsize=%d got %" NPY_INTP_FMT, elsize,
+                  (npy_intp)PyArray_ITEMSIZE(arr));
+          PyErr_SetString(PyExc_ValueError, mess);
+          Py_DECREF(arr);
+          return NULL;
+        }
+        if (check_and_fix_dimensions(arr, rank, dims, errmess)) {
+          Py_DECREF(arr);
+          return NULL;
         }
         return arr;
     }
 }
 
+extern PyArrayObject *
+array_from_pyobj(const int type_num,
+                                npy_intp *dims,
+                                const int rank,
+                                const int intent,
+                                PyObject *obj) {
+  /*
+    Same as ndarray_from_pyobj but with elsize determined from type,
+    if possible. Provided for backward compatibility.
+   */
+  PyArray_Descr* descr = PyArray_DescrFromType(type_num);
+  int elsize = descr->elsize;
+  Py_DECREF(descr);
+  return ndarray_from_pyobj(type_num, elsize, dims, rank, intent, obj, NULL);
+}
+
 /*****************************************/
 /* Helper functions for array_from_pyobj */
 /*****************************************/
 
 static int
-check_and_fix_dimensions(const PyArrayObject *arr, const int rank,
-                         npy_intp *dims)
+check_and_fix_dimensions(const PyArrayObject* arr, const int rank,
+                         npy_intp *dims, const char *errmess)
 {
     /*
      * This function fills in blanks (that are -1's) in dims list using
@@ -985,6 +1132,7 @@ check_and_fix_dimensions(const PyArrayObject *arr, const int rank,
      * If an error condition is detected, an exception is set and 1 is
      * returned.
      */
+    char mess[F2PY_MESSAGE_BUFFER_SIZE];
     const npy_intp arr_size =
             (PyArray_NDIM(arr)) ? PyArray_Size((PyObject *)arr) : 1;
 #ifdef DEBUG_COPY_ND_ARRAY
@@ -1050,11 +1198,14 @@ check_and_fix_dimensions(const PyArrayObject *arr, const int rank,
             d = PyArray_DIM(arr, i);
             if (dims[i] >= 0) {
                 if (d > 1 && d != dims[i]) {
-                    PyErr_Format(
-                            PyExc_ValueError,
-                            "%d-th dimension must be fixed to %" NPY_INTP_FMT
-                            " but got %" NPY_INTP_FMT "\n",
+                    if (errmess != NULL) {
+                        strcpy(mess, errmess);
+                    }
+                    sprintf(mess + strlen(mess),
+                            " -- %d-th dimension must be fixed to %"
+                            NPY_INTP_FMT " but got %" NPY_INTP_FMT,
                             i, dims[i], d);
+                    PyErr_SetString(PyExc_ValueError, mess);
                     return 1;
                 }
                 if (!dims[i])
@@ -1097,11 +1248,15 @@ check_and_fix_dimensions(const PyArrayObject *arr, const int rank,
                 d = PyArray_DIM(arr, j++);
             if (dims[i] >= 0) {
                 if (d > 1 && d != dims[i]) {
-                    PyErr_Format(
-                            PyExc_ValueError,
-                            "%d-th dimension must be fixed to %" NPY_INTP_FMT
-                            " but got %" NPY_INTP_FMT " (real index=%d)\n",
-                            i, dims[i], d, j - 1);
+                    if (errmess != NULL) {
+                        strcpy(mess, errmess);
+                    }
+                    sprintf(mess + strlen(mess),
+                            " -- %d-th dimension must be fixed to %"
+                            NPY_INTP_FMT " but got %" NPY_INTP_FMT
+                            " (real index=%d)\n",
+                            i, dims[i], d, j-1);
+                    PyErr_SetString(PyExc_ValueError, mess);
                     return 1;
                 }
                 if (!dims[i])
@@ -1165,6 +1320,72 @@ copy_ND_array(const PyArrayObject *arr, PyArrayObject *out)
     return PyArray_CopyInto(out, (PyArrayObject *)arr);
 }
 
+/********************* Various utility functions ***********************/
+
+extern int
+f2py_describe(PyObject *obj, char *buf) {
+  /*
+    Write the description of a Python object to buf. The caller must
+    provide buffer with size sufficient to write the description.
+
+    Return 1 on success.
+  */
+  char localbuf[F2PY_MESSAGE_BUFFER_SIZE];
+  if (PyBytes_Check(obj)) {
+    sprintf(localbuf, "%d-%s", (npy_int)PyBytes_GET_SIZE(obj), Py_TYPE(obj)->tp_name);
+  } else if (PyUnicode_Check(obj)) {
+    sprintf(localbuf, "%d-%s", (npy_int)PyUnicode_GET_LENGTH(obj), Py_TYPE(obj)->tp_name);
+  } else if (PyArray_CheckScalar(obj)) {
+    PyArrayObject* arr = (PyArrayObject*)obj;
+    sprintf(localbuf, "%c%" NPY_INTP_FMT "-%s-scalar", PyArray_DESCR(arr)->kind, PyArray_ITEMSIZE(arr), Py_TYPE(obj)->tp_name);
+  } else if (PyArray_Check(obj)) {
+    int i;
+    PyArrayObject* arr = (PyArrayObject*)obj;
+    strcpy(localbuf, "(");
+    for (i=0; ikind, PyArray_ITEMSIZE(arr), Py_TYPE(obj)->tp_name);
+  } else if (PySequence_Check(obj)) {
+    sprintf(localbuf, "%d-%s", (npy_int)PySequence_Length(obj), Py_TYPE(obj)->tp_name);
+  } else {
+    sprintf(localbuf, "%s instance", Py_TYPE(obj)->tp_name);
+  }
+  // TODO: detect the size of buf and make sure that size(buf) >= size(localbuf).
+  strcpy(buf, localbuf);
+  return 1;
+}
+
+extern npy_intp
+f2py_size_impl(PyArrayObject* var, ...)
+{
+  npy_intp sz = 0;
+  npy_intp dim;
+  npy_intp rank;
+  va_list argp;
+  va_start(argp, var);
+  dim = va_arg(argp, npy_int);
+  if (dim==-1)
+    {
+      sz = PyArray_SIZE(var);
+    }
+  else
+    {
+      rank = PyArray_NDIM(var);
+      if (dim>=1 && dim<=rank)
+        sz = PyArray_DIM(var, dim-1);
+      else
+        fprintf(stderr, "f2py_size: 2nd argument value=%" NPY_INTP_FMT
+                " fails to satisfy 1<=value<=%" NPY_INTP_FMT
+                ". Result will be 0.\n", dim, rank);
+    }
+  va_end(argp);
+  return sz;
+}
+
 /*********************************************/
 /* Compatibility functions for Python >= 3.0 */
 /*********************************************/
diff --git a/numpy/f2py/src/fortranobject.h b/numpy/f2py/src/fortranobject.h
index a1e9fdbdfbac..abd699c2fe86 100644
--- a/numpy/f2py/src/fortranobject.h
+++ b/numpy/f2py/src/fortranobject.h
@@ -6,6 +6,9 @@ extern "C" {
 
 #include 
 
+#ifndef NPY_NO_DEPRECATED_API
+#define NPY_NO_DEPRECATED_API NPY_API_VERSION
+#endif
 #ifdef FORTRANOBJECT_C
 #define NO_IMPORT_ARRAY
 #endif
@@ -44,6 +47,7 @@ Author: Pearu Peterson 
 */
 
 #define F2PY_MAX_DIMS 40
+#define F2PY_MESSAGE_BUFFER_SIZE 300  // Increase on "stack smashing detected"
 
 typedef void (*f2py_set_data_func)(char *, npy_intp *);
 typedef void (*f2py_void_func)(void);
@@ -61,6 +65,7 @@ typedef struct {
         npy_intp d[F2PY_MAX_DIMS];
     } dims;              /* dimensions of the array, || not used */
     int type;            /* PyArray_ || not used */
+    int elsize;                /* Element size || not used */
     char *data;          /* pointer to array || Fortran routine */
     f2py_init_func func; /* initialization function for
                             allocatable arrays:
@@ -125,6 +130,14 @@ F2PyGetThreadLocalCallbackPtr(char *key);
              : (F2PY_ALIGN8(intent) ? 8 : (F2PY_ALIGN16(intent) ? 16 : 1)))
 #define F2PY_CHECK_ALIGNMENT(arr, intent) \
     ARRAY_ISALIGNED(arr, F2PY_GET_ALIGNMENT(intent))
+#define F2PY_ARRAY_IS_CHARACTER_COMPATIBLE(arr) ((PyArray_DESCR(arr)->type_num == NPY_STRING && PyArray_DESCR(arr)->elsize >= 1) \
+                                                 || PyArray_DESCR(arr)->type_num == NPY_UINT8)
+#define F2PY_IS_UNICODE_ARRAY(arr) (PyArray_DESCR(arr)->type_num == NPY_UNICODE)
+
+extern PyArrayObject *
+ndarray_from_pyobj(const int type_num, const int elsize_, npy_intp *dims,
+                   const int rank, const int intent, PyObject *obj,
+                   const char *errmess);
 
 extern PyArrayObject *
 array_from_pyobj(const int type_num, npy_intp *dims, const int rank,
@@ -137,6 +150,23 @@ extern void
 dump_attrs(const PyArrayObject *arr);
 #endif
 
+  extern int f2py_describe(PyObject *obj, char *buf);
+
+  /* Utility CPP macros and functions that can be used in signature file
+     expressions. See signature-file.rst for documentation.
+  */
+
+#define f2py_itemsize(var) (PyArray_DESCR((capi_ ## var ## _as_array))->elsize)
+#define f2py_size(var, ...) f2py_size_impl((PyArrayObject *)(capi_ ## var ## _as_array), ## __VA_ARGS__, -1)
+#define f2py_rank(var) var ## _Rank
+#define f2py_shape(var,dim) var ## _Dims[dim]
+#define f2py_len(var) f2py_shape(var,0)
+#define f2py_fshape(var,dim) f2py_shape(var,rank(var)-dim-1)
+#define f2py_flen(var) f2py_fshape(var,0)
+#define f2py_slen(var) capi_ ## var ## _len
+
+  extern npy_intp f2py_size_impl(PyArrayObject* var, ...);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/numpy/f2py/symbolic.py b/numpy/f2py/symbolic.py
index 1b7b354583a3..c2ab0f14000f 100644
--- a/numpy/f2py/symbolic.py
+++ b/numpy/f2py/symbolic.py
@@ -381,7 +381,7 @@ def tostring(self, parent_precedence=Precedence.NONE,
                                              language=language)
                                   for a in self.data]
             if language is Language.C:
-                r = f'({cond} ? {expr1} : {expr2})'
+                r = f'({cond}?{expr1}:{expr2})'
             elif language is Language.Python:
                 r = f'({expr1} if {cond} else {expr2})'
             elif language is Language.Fortran:
diff --git a/numpy/f2py/tests/src/abstract_interface/foo.f90 b/numpy/f2py/tests/src/abstract_interface/foo.f90
new file mode 100644
index 000000000000..76d16aae2b57
--- /dev/null
+++ b/numpy/f2py/tests/src/abstract_interface/foo.f90
@@ -0,0 +1,34 @@
+module ops_module
+
+  abstract interface
+    subroutine op(x, y, z)
+      integer, intent(in) :: x, y
+      integer, intent(out) :: z
+    end subroutine
+  end interface
+
+contains
+
+  subroutine foo(x, y, r1, r2)
+    integer, intent(in) :: x, y
+    integer, intent(out) :: r1, r2
+    procedure (op) add1, add2
+    procedure (op), pointer::p
+    p=>add1
+    call p(x, y, r1)
+    p=>add2
+    call p(x, y, r2)
+  end subroutine
+end module
+
+subroutine add1(x, y, z)
+  integer, intent(in) :: x, y
+  integer, intent(out) :: z
+  z = x + y
+end subroutine
+
+subroutine add2(x, y, z)
+  integer, intent(in) :: x, y
+  integer, intent(out) :: z
+  z = x + 2 * y
+end subroutine
diff --git a/numpy/f2py/tests/src/abstract_interface/gh18403_mod.f90 b/numpy/f2py/tests/src/abstract_interface/gh18403_mod.f90
new file mode 100644
index 000000000000..36791e469f5a
--- /dev/null
+++ b/numpy/f2py/tests/src/abstract_interface/gh18403_mod.f90
@@ -0,0 +1,6 @@
+module test
+  abstract interface
+    subroutine foo()
+    end subroutine
+  end interface
+end module test
diff --git a/numpy/f2py/tests/src/array_from_pyobj/wrapmodule.c b/numpy/f2py/tests/src/array_from_pyobj/wrapmodule.c
index ea47e05558b7..9a8b4a752ab2 100644
--- a/numpy/f2py/tests/src/array_from_pyobj/wrapmodule.c
+++ b/numpy/f2py/tests/src/array_from_pyobj/wrapmodule.c
@@ -33,6 +33,7 @@ static PyObject *f2py_rout_wrap_call(PyObject *capi_self,
                                      PyObject *capi_args) {
   PyObject * volatile capi_buildvalue = NULL;
   int type_num = 0;
+  int elsize = 0;
   npy_intp *dims = NULL;
   PyObject *dims_capi = Py_None;
   int rank = 0;
@@ -41,8 +42,8 @@ static PyObject *f2py_rout_wrap_call(PyObject *capi_self,
   PyObject *arr_capi = Py_None;
   int i;
 
-  if (!PyArg_ParseTuple(capi_args,"iOiO|:wrap.call",\
-                        &type_num,&dims_capi,&intent,&arr_capi))
+  if (!PyArg_ParseTuple(capi_args,"iiOiO|:wrap.call",\
+                        &type_num,&elsize,&dims_capi,&intent,&arr_capi))
     return NULL;
   rank = PySequence_Length(dims_capi);
   dims = malloc(rank*sizeof(npy_intp));
@@ -58,7 +59,7 @@ static PyObject *f2py_rout_wrap_call(PyObject *capi_self,
         goto fail;
     }
   }
-  capi_arr_tmp = array_from_pyobj(type_num,dims,rank,intent|F2PY_INTENT_OUT,arr_capi);
+  capi_arr_tmp = ndarray_from_pyobj(type_num,elsize,dims,rank,intent|F2PY_INTENT_OUT,arr_capi,"wrap.call failed");
   if (capi_arr_tmp == NULL) {
     free(dims);
     return NULL;
@@ -202,7 +203,6 @@ PyMODINIT_FUNC PyInit_test_array_from_pyobj_ext(void) {
   ADDCONST("ENSUREARRAY", NPY_ARRAY_ENSUREARRAY);
   ADDCONST("ALIGNED", NPY_ARRAY_ALIGNED);
   ADDCONST("WRITEABLE", NPY_ARRAY_WRITEABLE);
-  ADDCONST("UPDATEIFCOPY", NPY_ARRAY_UPDATEIFCOPY);
   ADDCONST("WRITEBACKIFCOPY", NPY_ARRAY_WRITEBACKIFCOPY);
 
   ADDCONST("BEHAVED", NPY_ARRAY_BEHAVED);
diff --git a/numpy/f2py/tests/src/block_docstring/foo.f b/numpy/f2py/tests/src/block_docstring/foo.f
new file mode 100644
index 000000000000..c8315f12ce0f
--- /dev/null
+++ b/numpy/f2py/tests/src/block_docstring/foo.f
@@ -0,0 +1,6 @@
+      SUBROUTINE FOO()
+      INTEGER BAR(2, 3)
+
+      COMMON  /BLOCK/ BAR
+      RETURN
+      END
diff --git a/numpy/f2py/tests/src/callback/foo.f b/numpy/f2py/tests/src/callback/foo.f
new file mode 100644
index 000000000000..ba397bb38133
--- /dev/null
+++ b/numpy/f2py/tests/src/callback/foo.f
@@ -0,0 +1,62 @@
+       subroutine t(fun,a)
+       integer a
+cf2py  intent(out) a
+       external fun
+       call fun(a)
+       end
+
+       subroutine func(a)
+cf2py  intent(in,out) a
+       integer a
+       a = a + 11
+       end
+
+       subroutine func0(a)
+cf2py  intent(out) a
+       integer a
+       a = 11
+       end
+
+       subroutine t2(a)
+cf2py  intent(callback) fun
+       integer a
+cf2py  intent(out) a
+       external fun
+       call fun(a)
+       end
+
+       subroutine string_callback(callback, a)
+       external callback
+       double precision callback
+       double precision a
+       character*1 r
+cf2py  intent(out) a
+       r = 'r'
+       a = callback(r)
+       end
+
+       subroutine string_callback_array(callback, cu, lencu, a)
+       external callback
+       integer callback
+       integer lencu
+       character*8 cu(lencu)
+       integer a
+cf2py  intent(out) a
+
+       a = callback(cu, lencu)
+       end
+
+       subroutine hidden_callback(a, r)
+       external global_f
+cf2py  intent(callback, hide) global_f
+       integer a, r, global_f
+cf2py  intent(out) r
+       r = global_f(a)
+       end
+
+       subroutine hidden_callback2(a, r)
+       external global_f
+       integer a, r, global_f
+cf2py  intent(out) r
+       r = global_f(a)
+       end
diff --git a/numpy/f2py/tests/src/callback/gh17797.f90 b/numpy/f2py/tests/src/callback/gh17797.f90
new file mode 100644
index 000000000000..49853afd766a
--- /dev/null
+++ b/numpy/f2py/tests/src/callback/gh17797.f90
@@ -0,0 +1,7 @@
+function gh17797(f, y) result(r)
+  external f
+  integer(8) :: r, f
+  integer(8), dimension(:) :: y
+  r = f(0)
+  r = r + sum(y)
+end function gh17797
diff --git a/numpy/f2py/tests/src/callback/gh18335.f90 b/numpy/f2py/tests/src/callback/gh18335.f90
new file mode 100644
index 000000000000..92b6d7540c82
--- /dev/null
+++ b/numpy/f2py/tests/src/callback/gh18335.f90
@@ -0,0 +1,17 @@
+        ! When gh18335_workaround is defined as an extension,
+        ! the issue cannot be reproduced.
+        !subroutine gh18335_workaround(f, y)
+        !  implicit none
+        !  external f
+        !  integer(kind=1) :: y(1)
+        !  call f(y)
+        !end subroutine gh18335_workaround
+
+        function gh18335(f) result (r)
+          implicit none
+          external f
+          integer(kind=1) :: y(1), r
+          y(1) = 123
+          call f(y)
+          r = y(1)
+        end function gh18335
diff --git a/numpy/f2py/tests/src/cli/hi77.f b/numpy/f2py/tests/src/cli/hi77.f
new file mode 100644
index 000000000000..8b916ebe0459
--- /dev/null
+++ b/numpy/f2py/tests/src/cli/hi77.f
@@ -0,0 +1,3 @@
+      SUBROUTINE HI
+        PRINT*, "HELLO WORLD"
+      END SUBROUTINE
diff --git a/numpy/f2py/tests/src/cli/hiworld.f90 b/numpy/f2py/tests/src/cli/hiworld.f90
new file mode 100644
index 000000000000..981f877547a4
--- /dev/null
+++ b/numpy/f2py/tests/src/cli/hiworld.f90
@@ -0,0 +1,3 @@
+function hi()
+  print*, "Hello World"
+end function
diff --git a/numpy/f2py/tests/src/crackfortran/accesstype.f90 b/numpy/f2py/tests/src/crackfortran/accesstype.f90
new file mode 100644
index 000000000000..e2cbd445daf5
--- /dev/null
+++ b/numpy/f2py/tests/src/crackfortran/accesstype.f90
@@ -0,0 +1,13 @@
+module foo
+  public
+  type, private, bind(c) :: a
+     integer :: i
+  end type a
+  type, bind(c) :: b_
+     integer :: j
+  end type b_
+  public :: b_
+  type :: c
+     integer :: k
+  end type c
+end module foo
diff --git a/numpy/f2py/tests/src/crackfortran/foo_deps.f90 b/numpy/f2py/tests/src/crackfortran/foo_deps.f90
new file mode 100644
index 000000000000..e327b25c8198
--- /dev/null
+++ b/numpy/f2py/tests/src/crackfortran/foo_deps.f90
@@ -0,0 +1,6 @@
+module foo
+  type bar
+    character(len = 4) :: text
+  end type bar
+  type(bar), parameter :: abar = bar('abar')
+end module foo
diff --git a/numpy/f2py/tests/src/crackfortran/gh15035.f b/numpy/f2py/tests/src/crackfortran/gh15035.f
new file mode 100644
index 000000000000..1bb2e6745952
--- /dev/null
+++ b/numpy/f2py/tests/src/crackfortran/gh15035.f
@@ -0,0 +1,16 @@
+        subroutine subb(k)
+          real(8), intent(inout) :: k(:)
+          k=k+1
+        endsubroutine
+
+        subroutine subc(w,k)
+          real(8), intent(in) :: w(:)
+          real(8), intent(out) :: k(size(w))
+          k=w+1
+        endsubroutine
+
+        function t0(value)
+          character value
+          character t0
+          t0 = value
+        endfunction
diff --git a/numpy/f2py/tests/src/crackfortran/gh17859.f b/numpy/f2py/tests/src/crackfortran/gh17859.f
new file mode 100644
index 000000000000..995953845c5e
--- /dev/null
+++ b/numpy/f2py/tests/src/crackfortran/gh17859.f
@@ -0,0 +1,12 @@
+        integer(8) function external_as_statement(fcn)
+        implicit none
+        external fcn
+        integer(8) :: fcn
+        external_as_statement = fcn(0)
+        end
+
+        integer(8) function external_as_attribute(fcn)
+        implicit none
+        integer(8), external :: fcn
+        external_as_attribute = fcn(0)
+        end
diff --git a/numpy/f2py/tests/src/crackfortran/gh2848.f90 b/numpy/f2py/tests/src/crackfortran/gh2848.f90
new file mode 100644
index 000000000000..31ea9327a4d9
--- /dev/null
+++ b/numpy/f2py/tests/src/crackfortran/gh2848.f90
@@ -0,0 +1,13 @@
+      subroutine gh2848( &
+        ! first 2 parameters
+        par1, par2,&
+        ! last 2 parameters
+        par3, par4)
+
+        integer, intent(in)  :: par1, par2
+        integer, intent(out) :: par3, par4
+
+        par3 = par1
+        par4 = par2
+
+      end subroutine gh2848
diff --git a/numpy/f2py/tests/src/crackfortran/operators.f90 b/numpy/f2py/tests/src/crackfortran/operators.f90
new file mode 100644
index 000000000000..1d060a3d2bd5
--- /dev/null
+++ b/numpy/f2py/tests/src/crackfortran/operators.f90
@@ -0,0 +1,49 @@
+module foo
+  type bar
+     character(len = 32) :: item
+  end type bar
+  interface operator(.item.)
+     module procedure item_int, item_real
+  end interface operator(.item.)
+  interface operator(==)
+     module procedure items_are_equal
+  end interface operator(==)
+  interface assignment(=)
+     module procedure get_int, get_real
+  end interface assignment(=)
+contains
+  function item_int(val) result(elem)
+    integer, intent(in) :: val
+    type(bar) :: elem
+
+    write(elem%item, "(I32)") val
+  end function item_int
+
+  function item_real(val) result(elem)
+    real, intent(in) :: val
+    type(bar) :: elem
+
+    write(elem%item, "(1PE32.12)") val
+  end function item_real
+
+  function items_are_equal(val1, val2) result(equal)
+    type(bar), intent(in) :: val1, val2
+    logical :: equal
+
+    equal = (val1%item == val2%item)
+  end function items_are_equal
+
+  subroutine get_real(rval, item)
+    real, intent(out) :: rval
+    type(bar), intent(in) :: item
+
+    read(item%item, *) rval
+  end subroutine get_real
+
+  subroutine get_int(rval, item)
+    integer, intent(out) :: rval
+    type(bar), intent(in) :: item
+
+    read(item%item, *) rval
+  end subroutine get_int
+end module foo
diff --git a/numpy/f2py/tests/src/crackfortran/privatemod.f90 b/numpy/f2py/tests/src/crackfortran/privatemod.f90
new file mode 100644
index 000000000000..2674c214767b
--- /dev/null
+++ b/numpy/f2py/tests/src/crackfortran/privatemod.f90
@@ -0,0 +1,11 @@
+module foo
+  private
+  integer :: a
+  public :: setA
+  integer :: b
+contains
+  subroutine setA(v)
+    integer, intent(in) :: v
+    a = v
+  end subroutine setA
+end module foo
diff --git a/numpy/f2py/tests/src/crackfortran/publicmod.f90 b/numpy/f2py/tests/src/crackfortran/publicmod.f90
new file mode 100644
index 000000000000..1db76e3fe068
--- /dev/null
+++ b/numpy/f2py/tests/src/crackfortran/publicmod.f90
@@ -0,0 +1,10 @@
+module foo
+  public
+  integer, private :: a
+  public :: setA
+contains
+  subroutine setA(v)
+    integer, intent(in) :: v
+    a = v
+  end subroutine setA
+end module foo
diff --git a/numpy/f2py/tests/src/crackfortran/pubprivmod.f90 b/numpy/f2py/tests/src/crackfortran/pubprivmod.f90
new file mode 100644
index 000000000000..46bef7cb9112
--- /dev/null
+++ b/numpy/f2py/tests/src/crackfortran/pubprivmod.f90
@@ -0,0 +1,10 @@
+module foo
+  public
+  integer, private :: a
+  integer :: b
+contains
+  subroutine setA(v)
+    integer, intent(in) :: v
+    a = v
+  end subroutine setA
+end module foo
diff --git a/numpy/f2py/tests/src/crackfortran/unicode_comment.f90 b/numpy/f2py/tests/src/crackfortran/unicode_comment.f90
new file mode 100644
index 000000000000..13515ce98c50
--- /dev/null
+++ b/numpy/f2py/tests/src/crackfortran/unicode_comment.f90
@@ -0,0 +1,4 @@
+subroutine foo(x)
+  real(8), intent(in) :: x
+  ! Écrit à l'écran la valeur de x
+end subroutine
diff --git a/numpy/f2py/tests/src/f2cmap/.f2py_f2cmap b/numpy/f2py/tests/src/f2cmap/.f2py_f2cmap
new file mode 100644
index 000000000000..a4425f8876f5
--- /dev/null
+++ b/numpy/f2py/tests/src/f2cmap/.f2py_f2cmap
@@ -0,0 +1 @@
+dict(real=dict(real32='float', real64='double'), integer=dict(int64='long_long'))
diff --git a/numpy/f2py/tests/src/f2cmap/isoFortranEnvMap.f90 b/numpy/f2py/tests/src/f2cmap/isoFortranEnvMap.f90
new file mode 100644
index 000000000000..3f0e12c76833
--- /dev/null
+++ b/numpy/f2py/tests/src/f2cmap/isoFortranEnvMap.f90
@@ -0,0 +1,9 @@
+      subroutine func1(n, x, res)
+        use, intrinsic :: iso_fortran_env, only: int64, real64
+        implicit none
+        integer(int64), intent(in) :: n
+        real(real64), intent(in) :: x(n)
+        real(real64), intent(out) :: res
+Cf2py   intent(hide) :: n
+        res = sum(x)
+      end
diff --git a/numpy/f2py/tests/src/negative_bounds/issue_20853.f90 b/numpy/f2py/tests/src/negative_bounds/issue_20853.f90
new file mode 100644
index 000000000000..bf1fa9285331
--- /dev/null
+++ b/numpy/f2py/tests/src/negative_bounds/issue_20853.f90
@@ -0,0 +1,7 @@
+subroutine foo(is_, ie_, arr, tout)
+ implicit none
+ integer :: is_,ie_
+ real, intent(in) :: arr(is_:ie_)
+ real, intent(out) :: tout(is_:ie_)
+ tout = arr
+end
diff --git a/numpy/f2py/tests/src/quoted_character/foo.f b/numpy/f2py/tests/src/quoted_character/foo.f
new file mode 100644
index 000000000000..9dc1cfa4446d
--- /dev/null
+++ b/numpy/f2py/tests/src/quoted_character/foo.f
@@ -0,0 +1,14 @@
+      SUBROUTINE FOO(OUT1, OUT2, OUT3, OUT4, OUT5, OUT6)
+      CHARACTER SINGLE, DOUBLE, SEMICOL, EXCLA, OPENPAR, CLOSEPAR
+      PARAMETER (SINGLE="'", DOUBLE='"', SEMICOL=';', EXCLA="!",
+     1           OPENPAR="(", CLOSEPAR=")")
+      CHARACTER OUT1, OUT2, OUT3, OUT4, OUT5, OUT6
+Cf2py intent(out) OUT1, OUT2, OUT3, OUT4, OUT5, OUT6
+      OUT1 = SINGLE
+      OUT2 = DOUBLE
+      OUT3 = SEMICOL
+      OUT4 = EXCLA
+      OUT5 = OPENPAR
+      OUT6 = CLOSEPAR
+      RETURN
+      END
diff --git a/numpy/f2py/tests/src/return_character/foo77.f b/numpy/f2py/tests/src/return_character/foo77.f
new file mode 100644
index 000000000000..facae1016a39
--- /dev/null
+++ b/numpy/f2py/tests/src/return_character/foo77.f
@@ -0,0 +1,45 @@
+       function t0(value)
+         character value
+         character t0
+         t0 = value
+       end
+       function t1(value)
+         character*1 value
+         character*1 t1
+         t1 = value
+       end
+       function t5(value)
+         character*5 value
+         character*5 t5
+         t5 = value
+       end
+       function ts(value)
+         character*(*) value
+         character*(*) ts
+         ts = value
+       end
+
+       subroutine s0(t0,value)
+         character value
+         character t0
+cf2py    intent(out) t0
+         t0 = value
+       end
+       subroutine s1(t1,value)
+         character*1 value
+         character*1 t1
+cf2py    intent(out) t1
+         t1 = value
+       end
+       subroutine s5(t5,value)
+         character*5 value
+         character*5 t5
+cf2py    intent(out) t5
+         t5 = value
+       end
+       subroutine ss(ts,value)
+         character*(*) value
+         character*10 ts
+cf2py    intent(out) ts
+         ts = value
+       end
diff --git a/numpy/f2py/tests/src/return_character/foo90.f90 b/numpy/f2py/tests/src/return_character/foo90.f90
new file mode 100644
index 000000000000..36182bcf2dd7
--- /dev/null
+++ b/numpy/f2py/tests/src/return_character/foo90.f90
@@ -0,0 +1,48 @@
+module f90_return_char
+  contains
+       function t0(value)
+         character :: value
+         character :: t0
+         t0 = value
+       end function t0
+       function t1(value)
+         character(len=1) :: value
+         character(len=1) :: t1
+         t1 = value
+       end function t1
+       function t5(value)
+         character(len=5) :: value
+         character(len=5) :: t5
+         t5 = value
+       end function t5
+       function ts(value)
+         character(len=*) :: value
+         character(len=10) :: ts
+         ts = value
+       end function ts
+
+       subroutine s0(t0,value)
+         character :: value
+         character :: t0
+!f2py    intent(out) t0
+         t0 = value
+       end subroutine s0
+       subroutine s1(t1,value)
+         character(len=1) :: value
+         character(len=1) :: t1
+!f2py    intent(out) t1
+         t1 = value
+       end subroutine s1
+       subroutine s5(t5,value)
+         character(len=5) :: value
+         character(len=5) :: t5
+!f2py    intent(out) t5
+         t5 = value
+       end subroutine s5
+       subroutine ss(ts,value)
+         character(len=*) :: value
+         character(len=10) :: ts
+!f2py    intent(out) ts
+         ts = value
+       end subroutine ss
+end module f90_return_char
diff --git a/numpy/f2py/tests/src/return_complex/foo77.f b/numpy/f2py/tests/src/return_complex/foo77.f
new file mode 100644
index 000000000000..37a1ec845eca
--- /dev/null
+++ b/numpy/f2py/tests/src/return_complex/foo77.f
@@ -0,0 +1,45 @@
+       function t0(value)
+         complex value
+         complex t0
+         t0 = value
+       end
+       function t8(value)
+         complex*8 value
+         complex*8 t8
+         t8 = value
+       end
+       function t16(value)
+         complex*16 value
+         complex*16 t16
+         t16 = value
+       end
+       function td(value)
+         double complex value
+         double complex td
+         td = value
+       end
+
+       subroutine s0(t0,value)
+         complex value
+         complex t0
+cf2py    intent(out) t0
+         t0 = value
+       end
+       subroutine s8(t8,value)
+         complex*8 value
+         complex*8 t8
+cf2py    intent(out) t8
+         t8 = value
+       end
+       subroutine s16(t16,value)
+         complex*16 value
+         complex*16 t16
+cf2py    intent(out) t16
+         t16 = value
+       end
+       subroutine sd(td,value)
+         double complex value
+         double complex td
+cf2py    intent(out) td
+         td = value
+       end
diff --git a/numpy/f2py/tests/src/return_complex/foo90.f90 b/numpy/f2py/tests/src/return_complex/foo90.f90
new file mode 100644
index 000000000000..adc27b470538
--- /dev/null
+++ b/numpy/f2py/tests/src/return_complex/foo90.f90
@@ -0,0 +1,48 @@
+module f90_return_complex
+  contains
+       function t0(value)
+         complex :: value
+         complex :: t0
+         t0 = value
+       end function t0
+       function t8(value)
+         complex(kind=4) :: value
+         complex(kind=4) :: t8
+         t8 = value
+       end function t8
+       function t16(value)
+         complex(kind=8) :: value
+         complex(kind=8) :: t16
+         t16 = value
+       end function t16
+       function td(value)
+         double complex :: value
+         double complex :: td
+         td = value
+       end function td
+
+       subroutine s0(t0,value)
+         complex :: value
+         complex :: t0
+!f2py    intent(out) t0
+         t0 = value
+       end subroutine s0
+       subroutine s8(t8,value)
+         complex(kind=4) :: value
+         complex(kind=4) :: t8
+!f2py    intent(out) t8
+         t8 = value
+       end subroutine s8
+       subroutine s16(t16,value)
+         complex(kind=8) :: value
+         complex(kind=8) :: t16
+!f2py    intent(out) t16
+         t16 = value
+       end subroutine s16
+       subroutine sd(td,value)
+         double complex :: value
+         double complex :: td
+!f2py    intent(out) td
+         td = value
+       end subroutine sd
+end module f90_return_complex
diff --git a/numpy/f2py/tests/src/return_integer/foo77.f b/numpy/f2py/tests/src/return_integer/foo77.f
new file mode 100644
index 000000000000..1ab895b9ac34
--- /dev/null
+++ b/numpy/f2py/tests/src/return_integer/foo77.f
@@ -0,0 +1,56 @@
+       function t0(value)
+         integer value
+         integer t0
+         t0 = value
+       end
+       function t1(value)
+         integer*1 value
+         integer*1 t1
+         t1 = value
+       end
+       function t2(value)
+         integer*2 value
+         integer*2 t2
+         t2 = value
+       end
+       function t4(value)
+         integer*4 value
+         integer*4 t4
+         t4 = value
+       end
+       function t8(value)
+         integer*8 value
+         integer*8 t8
+         t8 = value
+       end
+
+       subroutine s0(t0,value)
+         integer value
+         integer t0
+cf2py    intent(out) t0
+         t0 = value
+       end
+       subroutine s1(t1,value)
+         integer*1 value
+         integer*1 t1
+cf2py    intent(out) t1
+         t1 = value
+       end
+       subroutine s2(t2,value)
+         integer*2 value
+         integer*2 t2
+cf2py    intent(out) t2
+         t2 = value
+       end
+       subroutine s4(t4,value)
+         integer*4 value
+         integer*4 t4
+cf2py    intent(out) t4
+         t4 = value
+       end
+       subroutine s8(t8,value)
+         integer*8 value
+         integer*8 t8
+cf2py    intent(out) t8
+         t8 = value
+       end
diff --git a/numpy/f2py/tests/src/return_integer/foo90.f90 b/numpy/f2py/tests/src/return_integer/foo90.f90
new file mode 100644
index 000000000000..ba9249aa20f9
--- /dev/null
+++ b/numpy/f2py/tests/src/return_integer/foo90.f90
@@ -0,0 +1,59 @@
+module f90_return_integer
+  contains
+       function t0(value)
+         integer :: value
+         integer :: t0
+         t0 = value
+       end function t0
+       function t1(value)
+         integer(kind=1) :: value
+         integer(kind=1) :: t1
+         t1 = value
+       end function t1
+       function t2(value)
+         integer(kind=2) :: value
+         integer(kind=2) :: t2
+         t2 = value
+       end function t2
+       function t4(value)
+         integer(kind=4) :: value
+         integer(kind=4) :: t4
+         t4 = value
+       end function t4
+       function t8(value)
+         integer(kind=8) :: value
+         integer(kind=8) :: t8
+         t8 = value
+       end function t8
+
+       subroutine s0(t0,value)
+         integer :: value
+         integer :: t0
+!f2py    intent(out) t0
+         t0 = value
+       end subroutine s0
+       subroutine s1(t1,value)
+         integer(kind=1) :: value
+         integer(kind=1) :: t1
+!f2py    intent(out) t1
+         t1 = value
+       end subroutine s1
+       subroutine s2(t2,value)
+         integer(kind=2) :: value
+         integer(kind=2) :: t2
+!f2py    intent(out) t2
+         t2 = value
+       end subroutine s2
+       subroutine s4(t4,value)
+         integer(kind=4) :: value
+         integer(kind=4) :: t4
+!f2py    intent(out) t4
+         t4 = value
+       end subroutine s4
+       subroutine s8(t8,value)
+         integer(kind=8) :: value
+         integer(kind=8) :: t8
+!f2py    intent(out) t8
+         t8 = value
+       end subroutine s8
+end module f90_return_integer
diff --git a/numpy/f2py/tests/src/return_logical/foo77.f b/numpy/f2py/tests/src/return_logical/foo77.f
new file mode 100644
index 000000000000..ef530145fedf
--- /dev/null
+++ b/numpy/f2py/tests/src/return_logical/foo77.f
@@ -0,0 +1,56 @@
+       function t0(value)
+         logical value
+         logical t0
+         t0 = value
+       end
+       function t1(value)
+         logical*1 value
+         logical*1 t1
+         t1 = value
+       end
+       function t2(value)
+         logical*2 value
+         logical*2 t2
+         t2 = value
+       end
+       function t4(value)
+         logical*4 value
+         logical*4 t4
+         t4 = value
+       end
+c       function t8(value)
+c         logical*8 value
+c         logical*8 t8
+c         t8 = value
+c       end
+
+       subroutine s0(t0,value)
+         logical value
+         logical t0
+cf2py    intent(out) t0
+         t0 = value
+       end
+       subroutine s1(t1,value)
+         logical*1 value
+         logical*1 t1
+cf2py    intent(out) t1
+         t1 = value
+       end
+       subroutine s2(t2,value)
+         logical*2 value
+         logical*2 t2
+cf2py    intent(out) t2
+         t2 = value
+       end
+       subroutine s4(t4,value)
+         logical*4 value
+         logical*4 t4
+cf2py    intent(out) t4
+         t4 = value
+       end
+c       subroutine s8(t8,value)
+c         logical*8 value
+c         logical*8 t8
+cf2py    intent(out) t8
+c         t8 = value
+c       end
diff --git a/numpy/f2py/tests/src/return_logical/foo90.f90 b/numpy/f2py/tests/src/return_logical/foo90.f90
new file mode 100644
index 000000000000..a4526468e371
--- /dev/null
+++ b/numpy/f2py/tests/src/return_logical/foo90.f90
@@ -0,0 +1,59 @@
+module f90_return_logical
+  contains
+       function t0(value)
+         logical :: value
+         logical :: t0
+         t0 = value
+       end function t0
+       function t1(value)
+         logical(kind=1) :: value
+         logical(kind=1) :: t1
+         t1 = value
+       end function t1
+       function t2(value)
+         logical(kind=2) :: value
+         logical(kind=2) :: t2
+         t2 = value
+       end function t2
+       function t4(value)
+         logical(kind=4) :: value
+         logical(kind=4) :: t4
+         t4 = value
+       end function t4
+       function t8(value)
+         logical(kind=8) :: value
+         logical(kind=8) :: t8
+         t8 = value
+       end function t8
+
+       subroutine s0(t0,value)
+         logical :: value
+         logical :: t0
+!f2py    intent(out) t0
+         t0 = value
+       end subroutine s0
+       subroutine s1(t1,value)
+         logical(kind=1) :: value
+         logical(kind=1) :: t1
+!f2py    intent(out) t1
+         t1 = value
+       end subroutine s1
+       subroutine s2(t2,value)
+         logical(kind=2) :: value
+         logical(kind=2) :: t2
+!f2py    intent(out) t2
+         t2 = value
+       end subroutine s2
+       subroutine s4(t4,value)
+         logical(kind=4) :: value
+         logical(kind=4) :: t4
+!f2py    intent(out) t4
+         t4 = value
+       end subroutine s4
+       subroutine s8(t8,value)
+         logical(kind=8) :: value
+         logical(kind=8) :: t8
+!f2py    intent(out) t8
+         t8 = value
+       end subroutine s8
+end module f90_return_logical
diff --git a/numpy/f2py/tests/src/return_real/foo77.f b/numpy/f2py/tests/src/return_real/foo77.f
new file mode 100644
index 000000000000..bf43dbf11773
--- /dev/null
+++ b/numpy/f2py/tests/src/return_real/foo77.f
@@ -0,0 +1,45 @@
+       function t0(value)
+         real value
+         real t0
+         t0 = value
+       end
+       function t4(value)
+         real*4 value
+         real*4 t4
+         t4 = value
+       end
+       function t8(value)
+         real*8 value
+         real*8 t8
+         t8 = value
+       end
+       function td(value)
+         double precision value
+         double precision td
+         td = value
+       end
+
+       subroutine s0(t0,value)
+         real value
+         real t0
+cf2py    intent(out) t0
+         t0 = value
+       end
+       subroutine s4(t4,value)
+         real*4 value
+         real*4 t4
+cf2py    intent(out) t4
+         t4 = value
+       end
+       subroutine s8(t8,value)
+         real*8 value
+         real*8 t8
+cf2py    intent(out) t8
+         t8 = value
+       end
+       subroutine sd(td,value)
+         double precision value
+         double precision td
+cf2py    intent(out) td
+         td = value
+       end
diff --git a/numpy/f2py/tests/src/return_real/foo90.f90 b/numpy/f2py/tests/src/return_real/foo90.f90
new file mode 100644
index 000000000000..df9719980f28
--- /dev/null
+++ b/numpy/f2py/tests/src/return_real/foo90.f90
@@ -0,0 +1,48 @@
+module f90_return_real
+  contains
+       function t0(value)
+         real :: value
+         real :: t0
+         t0 = value
+       end function t0
+       function t4(value)
+         real(kind=4) :: value
+         real(kind=4) :: t4
+         t4 = value
+       end function t4
+       function t8(value)
+         real(kind=8) :: value
+         real(kind=8) :: t8
+         t8 = value
+       end function t8
+       function td(value)
+         double precision :: value
+         double precision :: td
+         td = value
+       end function td
+
+       subroutine s0(t0,value)
+         real :: value
+         real :: t0
+!f2py    intent(out) t0
+         t0 = value
+       end subroutine s0
+       subroutine s4(t4,value)
+         real(kind=4) :: value
+         real(kind=4) :: t4
+!f2py    intent(out) t4
+         t4 = value
+       end subroutine s4
+       subroutine s8(t8,value)
+         real(kind=8) :: value
+         real(kind=8) :: t8
+!f2py    intent(out) t8
+         t8 = value
+       end subroutine s8
+       subroutine sd(td,value)
+         double precision :: value
+         double precision :: td
+!f2py    intent(out) td
+         td = value
+       end subroutine sd
+end module f90_return_real
diff --git a/numpy/f2py/tests/src/string/fixed_string.f90 b/numpy/f2py/tests/src/string/fixed_string.f90
new file mode 100644
index 000000000000..7fd1585430fb
--- /dev/null
+++ b/numpy/f2py/tests/src/string/fixed_string.f90
@@ -0,0 +1,34 @@
+function sint(s) result(i)
+   implicit none
+   character(len=*) :: s
+   integer :: j, i
+   i = 0
+   do j=len(s), 1, -1
+    if (.not.((i.eq.0).and.(s(j:j).eq.' '))) then
+      i = i + ichar(s(j:j)) * 10 ** (j - 1)
+    endif
+   end do
+   return
+ end function sint
+
+ function test_in_bytes4(a) result (i)
+   implicit none
+   integer :: sint
+   character(len=4) :: a
+   integer :: i
+   i = sint(a)
+   a(1:1) = 'A'
+   return
+ end function test_in_bytes4
+
+ function test_inout_bytes4(a) result (i)
+   implicit none
+   integer :: sint
+   character(len=4), intent(inout) :: a
+   integer :: i
+   if (a(1:1).ne.' ') then
+     a(1:1) = 'E'
+   endif
+   i = sint(a)
+   return
+ end function test_inout_bytes4
diff --git a/numpy/f2py/tests/src/string/scalar_string.f90 b/numpy/f2py/tests/src/string/scalar_string.f90
new file mode 100644
index 000000000000..f8f076172ab4
--- /dev/null
+++ b/numpy/f2py/tests/src/string/scalar_string.f90
@@ -0,0 +1,9 @@
+MODULE string_test
+
+  character(len=8) :: string
+  character string77 * 8
+
+  character(len=12), dimension(5,7) :: strarr
+  character strarr77(5,7) * 12
+
+END MODULE string_test
diff --git a/numpy/f2py/tests/src/string/string.f b/numpy/f2py/tests/src/string/string.f
new file mode 100644
index 000000000000..5210ca4dc054
--- /dev/null
+++ b/numpy/f2py/tests/src/string/string.f
@@ -0,0 +1,12 @@
+C FILE: STRING.F
+      SUBROUTINE FOO(A,B,C,D)
+      CHARACTER*5 A, B
+      CHARACTER*(*) C,D
+Cf2py intent(in) a,c
+Cf2py intent(inout) b,d
+      A(1:1) = 'A'
+      B(1:1) = 'B'
+      C(1:1) = 'C'
+      D(1:1) = 'D'
+      END
+C END OF FILE STRING.F
diff --git a/numpy/f2py/tests/src/value_attrspec/gh21665.f90 b/numpy/f2py/tests/src/value_attrspec/gh21665.f90
new file mode 100644
index 000000000000..7d9dc0fd4acb
--- /dev/null
+++ b/numpy/f2py/tests/src/value_attrspec/gh21665.f90
@@ -0,0 +1,9 @@
+module fortfuncs
+  implicit none
+contains
+  subroutine square(x,y)
+    integer, intent(in), value :: x
+    integer, intent(out) :: y
+    y = x*x
+  end subroutine square
+end module fortfuncs
diff --git a/numpy/f2py/tests/test_abstract_interface.py b/numpy/f2py/tests/test_abstract_interface.py
index 936c1f7bc9ae..42902913ed75 100644
--- a/numpy/f2py/tests/test_abstract_interface.py
+++ b/numpy/f2py/tests/test_abstract_interface.py
@@ -1,66 +1,25 @@
+from pathlib import Path
+import pytest
 import textwrap
 from . import util
 from numpy.f2py import crackfortran
+from numpy.testing import IS_WASM
 
 
+@pytest.mark.skipif(IS_WASM, reason="Cannot start subprocess")
 class TestAbstractInterface(util.F2PyTest):
-    suffix = '.f90'
+    sources = [util.getpath("tests", "src", "abstract_interface", "foo.f90")]
 
-    skip = ['add1', 'add2']
-
-    code = textwrap.dedent("""
-        module ops_module
-
-          abstract interface
-            subroutine op(x, y, z)
-              integer, intent(in) :: x, y
-              integer, intent(out) :: z
-            end subroutine
-          end interface
-
-        contains
-
-          subroutine foo(x, y, r1, r2)
-            integer, intent(in) :: x, y
-            integer, intent(out) :: r1, r2
-            procedure (op) add1, add2
-            procedure (op), pointer::p
-            p=>add1
-            call p(x, y, r1)
-            p=>add2
-            call p(x, y, r2)
-          end subroutine
-        end module
-
-        subroutine add1(x, y, z)
-          integer, intent(in) :: x, y
-          integer, intent(out) :: z
-          z = x + y
-        end subroutine
-
-        subroutine add2(x, y, z)
-          integer, intent(in) :: x, y
-          integer, intent(out) :: z
-          z = x + 2 * y
-        end subroutine
-        """)
+    skip = ["add1", "add2"]
 
     def test_abstract_interface(self):
         assert self.module.ops_module.foo(3, 5) == (8, 13)
 
-    def test_parse_abstract_interface(self, tmp_path):
+    def test_parse_abstract_interface(self):
         # Test gh18403
-        f_path = tmp_path / "gh18403_mod.f90"
-        with f_path.open('w') as ff:
-            ff.write(textwrap.dedent("""\
-                module test
-                  abstract interface
-                    subroutine foo()
-                    end subroutine
-                  end interface
-                end module test
-                """))
-        mod = crackfortran.crackfortran([str(f_path)])
+        fpath = util.getpath("tests", "src", "abstract_interface",
+                             "gh18403_mod.f90")
+        mod = crackfortran.crackfortran([str(fpath)])
         assert len(mod) == 1
-        assert len(mod[0]['body']) == 1
-        assert mod[0]['body'][0]['block'] == 'abstract interface'
+        assert len(mod[0]["body"]) == 1
+        assert mod[0]["body"][0]["block"] == "abstract interface"
diff --git a/numpy/f2py/tests/test_array_from_pyobj.py b/numpy/f2py/tests/test_array_from_pyobj.py
index 649fd1c4863b..2b8c8defca5a 100644
--- a/numpy/f2py/tests/test_array_from_pyobj.py
+++ b/numpy/f2py/tests/test_array_from_pyobj.py
@@ -7,11 +7,17 @@
 import numpy as np
 
 from numpy.testing import assert_, assert_equal
-from numpy.core.multiarray import typeinfo
+from numpy.core.multiarray import typeinfo as _typeinfo
 from . import util
 
 wrap = None
 
+# Extend core typeinfo with CHARACTER to test dtype('c')
+_ti = _typeinfo['STRING']
+typeinfo = dict(
+    CHARACTER=type(_ti)(('c', _ti.num, 8, _ti.alignment, _ti.type)),
+    **_typeinfo)
+
 
 def setup_module():
     """
@@ -31,11 +37,13 @@ def setup_module():
                              define_macros=[])
         """
         d = os.path.dirname(__file__)
-        src = [os.path.join(d, 'src', 'array_from_pyobj', 'wrapmodule.c'),
-               os.path.join(d, '..', 'src', 'fortranobject.c'),
-               os.path.join(d, '..', 'src', 'fortranobject.h')]
+        src = [
+            util.getpath("tests", "src", "array_from_pyobj", "wrapmodule.c"),
+            util.getpath("src", "fortranobject.c"),
+            util.getpath("src", "fortranobject.h"),
+        ]
         wrap = util.build_module_distutils(src, config_code,
-                                           'test_array_from_pyobj_ext')
+                                           "test_array_from_pyobj_ext")
 
 
 def flags_info(arr):
@@ -45,39 +53,49 @@ def flags_info(arr):
 
 def flags2names(flags):
     info = []
-    for flagname in ['CONTIGUOUS', 'FORTRAN', 'OWNDATA', 'ENSURECOPY',
-                     'ENSUREARRAY', 'ALIGNED', 'NOTSWAPPED', 'WRITEABLE',
-                     'WRITEBACKIFCOPY', 'UPDATEIFCOPY', 'BEHAVED', 'BEHAVED_RO',
-                     'CARRAY', 'FARRAY'
-                     ]:
+    for flagname in [
+            "CONTIGUOUS",
+            "FORTRAN",
+            "OWNDATA",
+            "ENSURECOPY",
+            "ENSUREARRAY",
+            "ALIGNED",
+            "NOTSWAPPED",
+            "WRITEABLE",
+            "WRITEBACKIFCOPY",
+            "UPDATEIFCOPY",
+            "BEHAVED",
+            "BEHAVED_RO",
+            "CARRAY",
+            "FARRAY",
+    ]:
         if abs(flags) & getattr(wrap, flagname, 0):
             info.append(flagname)
     return info
 
 
 class Intent:
-
     def __init__(self, intent_list=[]):
         self.intent_list = intent_list[:]
         flags = 0
         for i in intent_list:
-            if i == 'optional':
+            if i == "optional":
                 flags |= wrap.F2PY_OPTIONAL
             else:
-                flags |= getattr(wrap, 'F2PY_INTENT_' + i.upper())
+                flags |= getattr(wrap, "F2PY_INTENT_" + i.upper())
         self.flags = flags
 
     def __getattr__(self, name):
         name = name.lower()
-        if name == 'in_':
-            name = 'in'
+        if name == "in_":
+            name = "in"
         return self.__class__(self.intent_list + [name])
 
     def __str__(self):
-        return 'intent(%s)' % (','.join(self.intent_list))
+        return "intent(%s)" % (",".join(self.intent_list))
 
     def __repr__(self):
-        return 'Intent(%r)' % (self.intent_list)
+        return "Intent(%r)" % (self.intent_list)
 
     def is_intent(self, *names):
         for name in names:
@@ -88,32 +106,53 @@ def is_intent(self, *names):
     def is_intent_exact(self, *names):
         return len(self.intent_list) == len(names) and self.is_intent(*names)
 
-intent = Intent()
-
-_type_names = ['BOOL', 'BYTE', 'UBYTE', 'SHORT', 'USHORT', 'INT', 'UINT',
-               'LONG', 'ULONG', 'LONGLONG', 'ULONGLONG',
-               'FLOAT', 'DOUBLE', 'CFLOAT']
-
-_cast_dict = {'BOOL': ['BOOL']}
-_cast_dict['BYTE'] = _cast_dict['BOOL'] + ['BYTE']
-_cast_dict['UBYTE'] = _cast_dict['BOOL'] + ['UBYTE']
-_cast_dict['BYTE'] = ['BYTE']
-_cast_dict['UBYTE'] = ['UBYTE']
-_cast_dict['SHORT'] = _cast_dict['BYTE'] + ['UBYTE', 'SHORT']
-_cast_dict['USHORT'] = _cast_dict['UBYTE'] + ['BYTE', 'USHORT']
-_cast_dict['INT'] = _cast_dict['SHORT'] + ['USHORT', 'INT']
-_cast_dict['UINT'] = _cast_dict['USHORT'] + ['SHORT', 'UINT']
-
-_cast_dict['LONG'] = _cast_dict['INT'] + ['LONG']
-_cast_dict['ULONG'] = _cast_dict['UINT'] + ['ULONG']
 
-_cast_dict['LONGLONG'] = _cast_dict['LONG'] + ['LONGLONG']
-_cast_dict['ULONGLONG'] = _cast_dict['ULONG'] + ['ULONGLONG']
-
-_cast_dict['FLOAT'] = _cast_dict['SHORT'] + ['USHORT', 'FLOAT']
-_cast_dict['DOUBLE'] = _cast_dict['INT'] + ['UINT', 'FLOAT', 'DOUBLE']
+intent = Intent()
 
-_cast_dict['CFLOAT'] = _cast_dict['FLOAT'] + ['CFLOAT']
+_type_names = [
+    "BOOL",
+    "BYTE",
+    "UBYTE",
+    "SHORT",
+    "USHORT",
+    "INT",
+    "UINT",
+    "LONG",
+    "ULONG",
+    "LONGLONG",
+    "ULONGLONG",
+    "FLOAT",
+    "DOUBLE",
+    "CFLOAT",
+    "STRING1",
+    "STRING5",
+    "CHARACTER",
+]
+
+_cast_dict = {"BOOL": ["BOOL"]}
+_cast_dict["BYTE"] = _cast_dict["BOOL"] + ["BYTE"]
+_cast_dict["UBYTE"] = _cast_dict["BOOL"] + ["UBYTE"]
+_cast_dict["BYTE"] = ["BYTE"]
+_cast_dict["UBYTE"] = ["UBYTE"]
+_cast_dict["SHORT"] = _cast_dict["BYTE"] + ["UBYTE", "SHORT"]
+_cast_dict["USHORT"] = _cast_dict["UBYTE"] + ["BYTE", "USHORT"]
+_cast_dict["INT"] = _cast_dict["SHORT"] + ["USHORT", "INT"]
+_cast_dict["UINT"] = _cast_dict["USHORT"] + ["SHORT", "UINT"]
+
+_cast_dict["LONG"] = _cast_dict["INT"] + ["LONG"]
+_cast_dict["ULONG"] = _cast_dict["UINT"] + ["ULONG"]
+
+_cast_dict["LONGLONG"] = _cast_dict["LONG"] + ["LONGLONG"]
+_cast_dict["ULONGLONG"] = _cast_dict["ULONG"] + ["ULONGLONG"]
+
+_cast_dict["FLOAT"] = _cast_dict["SHORT"] + ["USHORT", "FLOAT"]
+_cast_dict["DOUBLE"] = _cast_dict["INT"] + ["UINT", "FLOAT", "DOUBLE"]
+
+_cast_dict["CFLOAT"] = _cast_dict["FLOAT"] + ["CFLOAT"]
+
+_cast_dict['STRING1'] = ['STRING1']
+_cast_dict['STRING5'] = ['STRING5']
+_cast_dict['CHARACTER'] = ['CHARACTER']
 
 # 32 bit system malloc typically does not provide the alignment required by
 # 16 byte long double types this means the inout intent cannot be satisfied
@@ -121,15 +160,22 @@ def is_intent_exact(self, *names):
 # when numpy gains an aligned allocator the tests could be enabled again
 #
 # Furthermore, on macOS ARM64, LONGDOUBLE is an alias for DOUBLE.
-if ((np.intp().dtype.itemsize != 4 or np.clongdouble().dtype.alignment <= 8) and
-        sys.platform != 'win32' and
-        (platform.system(), platform.processor()) != ('Darwin', 'arm')):
-    _type_names.extend(['LONGDOUBLE', 'CDOUBLE', 'CLONGDOUBLE'])
-    _cast_dict['LONGDOUBLE'] = _cast_dict['LONG'] + \
-        ['ULONG', 'FLOAT', 'DOUBLE', 'LONGDOUBLE']
-    _cast_dict['CLONGDOUBLE'] = _cast_dict['LONGDOUBLE'] + \
-        ['CFLOAT', 'CDOUBLE', 'CLONGDOUBLE']
-    _cast_dict['CDOUBLE'] = _cast_dict['DOUBLE'] + ['CFLOAT', 'CDOUBLE']
+if ((np.intp().dtype.itemsize != 4 or np.clongdouble().dtype.alignment <= 8)
+        and sys.platform != "win32"
+        and (platform.system(), platform.processor()) != ("Darwin", "arm")):
+    _type_names.extend(["LONGDOUBLE", "CDOUBLE", "CLONGDOUBLE"])
+    _cast_dict["LONGDOUBLE"] = _cast_dict["LONG"] + [
+        "ULONG",
+        "FLOAT",
+        "DOUBLE",
+        "LONGDOUBLE",
+    ]
+    _cast_dict["CLONGDOUBLE"] = _cast_dict["LONGDOUBLE"] + [
+        "CFLOAT",
+        "CDOUBLE",
+        "CLONGDOUBLE",
+    ]
+    _cast_dict["CDOUBLE"] = _cast_dict["DOUBLE"] + ["CFLOAT", "CDOUBLE"]
 
 
 class Type:
@@ -153,14 +199,33 @@ def __new__(cls, name):
 
     def _init(self, name):
         self.NAME = name.upper()
-        info = typeinfo[self.NAME]
-        self.type_num = getattr(wrap, 'NPY_' + self.NAME)
-        assert_equal(self.type_num, info.num)
-        self.dtype = np.dtype(info.type)
+
+        if self.NAME == 'CHARACTER':
+            info = typeinfo[self.NAME]
+            self.type_num = getattr(wrap, 'NPY_STRING')
+            self.elsize = 1
+            self.dtype = np.dtype('c')
+        elif self.NAME.startswith('STRING'):
+            info = typeinfo[self.NAME[:6]]
+            self.type_num = getattr(wrap, 'NPY_STRING')
+            self.elsize = int(self.NAME[6:] or 0)
+            self.dtype = np.dtype(f'S{self.elsize}')
+        else:
+            info = typeinfo[self.NAME]
+            self.type_num = getattr(wrap, 'NPY_' + self.NAME)
+            self.elsize = info.bits // 8
+            self.dtype = np.dtype(info.type)
+
+        assert self.type_num == info.num
         self.type = info.type
-        self.elsize = info.bits / 8
         self.dtypechar = info.char
 
+    def __repr__(self):
+        return (f"Type({self.NAME})|type_num={self.type_num},"
+                f" dtype={self.dtype},"
+                f" type={self.type}, elsize={self.elsize},"
+                f" dtypechar={self.dtypechar}")
+
     def cast_types(self):
         return [self.__class__(_m) for _m in _cast_dict[self.NAME]]
 
@@ -196,6 +261,10 @@ def larger_types(self):
 
 class Array:
 
+    def __repr__(self):
+        return (f'Array({self.type}, {self.dims}, {self.intent},'
+                f' {self.obj})|arr={self.arr}')
+
     def __init__(self, typ, dims, intent, obj):
         self.type = typ
         self.dims = dims
@@ -204,78 +273,84 @@ def __init__(self, typ, dims, intent, obj):
         self.obj = obj
 
         # arr.dtypechar may be different from typ.dtypechar
-        self.arr = wrap.call(typ.type_num, dims, intent.flags, obj)
+        self.arr = wrap.call(typ.type_num,
+                             typ.elsize,
+                             dims, intent.flags, obj)
 
-        assert_(isinstance(self.arr, np.ndarray), repr(type(self.arr)))
+        assert isinstance(self.arr, np.ndarray)
 
         self.arr_attr = wrap.array_attrs(self.arr)
 
         if len(dims) > 1:
-            if self.intent.is_intent('c'):
-                assert_(intent.flags & wrap.F2PY_INTENT_C)
-                assert_(not self.arr.flags['FORTRAN'],
-                        repr((self.arr.flags, getattr(obj, 'flags', None))))
-                assert_(self.arr.flags['CONTIGUOUS'])
-                assert_(not self.arr_attr[6] & wrap.FORTRAN)
+            if self.intent.is_intent("c"):
+                assert (intent.flags & wrap.F2PY_INTENT_C)
+                assert not self.arr.flags["FORTRAN"]
+                assert self.arr.flags["CONTIGUOUS"]
+                assert (not self.arr_attr[6] & wrap.FORTRAN)
             else:
-                assert_(not intent.flags & wrap.F2PY_INTENT_C)
-                assert_(self.arr.flags['FORTRAN'])
-                assert_(not self.arr.flags['CONTIGUOUS'])
-                assert_(self.arr_attr[6] & wrap.FORTRAN)
+                assert (not intent.flags & wrap.F2PY_INTENT_C)
+                assert self.arr.flags["FORTRAN"]
+                assert not self.arr.flags["CONTIGUOUS"]
+                assert (self.arr_attr[6] & wrap.FORTRAN)
 
         if obj is None:
             self.pyarr = None
             self.pyarr_attr = None
             return
 
-        if intent.is_intent('cache'):
-            assert_(isinstance(obj, np.ndarray), repr(type(obj)))
+        if intent.is_intent("cache"):
+            assert isinstance(obj, np.ndarray), repr(type(obj))
             self.pyarr = np.array(obj).reshape(*dims).copy()
         else:
             self.pyarr = np.array(
-                    np.array(obj, dtype=typ.dtypechar).reshape(*dims),
-                    order=self.intent.is_intent('c') and 'C' or 'F')
-            assert_(self.pyarr.dtype == typ,
-                    repr((self.pyarr.dtype, typ)))
-        self.pyarr.setflags(write=self.arr.flags['WRITEABLE'])
-        assert_(self.pyarr.flags['OWNDATA'], (obj, intent))
+                np.array(obj, dtype=typ.dtypechar).reshape(*dims),
+                order=self.intent.is_intent("c") and "C" or "F",
+            )
+            assert self.pyarr.dtype == typ
+        self.pyarr.setflags(write=self.arr.flags["WRITEABLE"])
+        assert self.pyarr.flags["OWNDATA"], (obj, intent)
         self.pyarr_attr = wrap.array_attrs(self.pyarr)
 
         if len(dims) > 1:
-            if self.intent.is_intent('c'):
-                assert_(not self.pyarr.flags['FORTRAN'])
-                assert_(self.pyarr.flags['CONTIGUOUS'])
-                assert_(not self.pyarr_attr[6] & wrap.FORTRAN)
+            if self.intent.is_intent("c"):
+                assert not self.pyarr.flags["FORTRAN"]
+                assert self.pyarr.flags["CONTIGUOUS"]
+                assert (not self.pyarr_attr[6] & wrap.FORTRAN)
             else:
-                assert_(self.pyarr.flags['FORTRAN'])
-                assert_(not self.pyarr.flags['CONTIGUOUS'])
-                assert_(self.pyarr_attr[6] & wrap.FORTRAN)
+                assert self.pyarr.flags["FORTRAN"]
+                assert not self.pyarr.flags["CONTIGUOUS"]
+                assert (self.pyarr_attr[6] & wrap.FORTRAN)
 
-        assert_(self.arr_attr[1] == self.pyarr_attr[1])  # nd
-        assert_(self.arr_attr[2] == self.pyarr_attr[2])  # dimensions
+        assert self.arr_attr[1] == self.pyarr_attr[1]  # nd
+        assert self.arr_attr[2] == self.pyarr_attr[2]  # dimensions
         if self.arr_attr[1] <= 1:
-            assert_(self.arr_attr[3] == self.pyarr_attr[3],
-                    repr((self.arr_attr[3], self.pyarr_attr[3],
-                          self.arr.tobytes(), self.pyarr.tobytes())))  # strides
-        assert_(self.arr_attr[5][-2:] == self.pyarr_attr[5][-2:],
-                repr((self.arr_attr[5], self.pyarr_attr[5])))  # descr
-        assert_(self.arr_attr[6] == self.pyarr_attr[6],
-                repr((self.arr_attr[6], self.pyarr_attr[6],
-                      flags2names(0 * self.arr_attr[6] - self.pyarr_attr[6]),
-                      flags2names(self.arr_attr[6]), intent)))  # flags
-
-        if intent.is_intent('cache'):
-            assert_(self.arr_attr[5][3] >= self.type.elsize,
-                    repr((self.arr_attr[5][3], self.type.elsize)))
+            assert self.arr_attr[3] == self.pyarr_attr[3], repr((
+                self.arr_attr[3],
+                self.pyarr_attr[3],
+                self.arr.tobytes(),
+                self.pyarr.tobytes(),
+            ))  # strides
+        assert self.arr_attr[5][-2:] == self.pyarr_attr[5][-2:], repr((
+            self.arr_attr[5], self.pyarr_attr[5]
+            ))  # descr
+        assert self.arr_attr[6] == self.pyarr_attr[6], repr((
+            self.arr_attr[6],
+            self.pyarr_attr[6],
+            flags2names(0 * self.arr_attr[6] - self.pyarr_attr[6]),
+            flags2names(self.arr_attr[6]),
+            intent,
+        ))  # flags
+
+        if intent.is_intent("cache"):
+            assert self.arr_attr[5][3] >= self.type.elsize
         else:
-            assert_(self.arr_attr[5][3] == self.type.elsize,
-                    repr((self.arr_attr[5][3], self.type.elsize)))
-        assert_(self.arr_equal(self.pyarr, self.arr))
+            assert self.arr_attr[5][3] == self.type.elsize
+            assert (self.arr_equal(self.pyarr, self.arr))
 
         if isinstance(self.obj, np.ndarray):
             if typ.elsize == Type(obj.dtype).elsize:
-                if not intent.is_intent('copy') and self.arr_attr[1] <= 1:
-                    assert_(self.has_shared_memory())
+                if not intent.is_intent("copy") and self.arr_attr[1] <= 1:
+                    assert self.has_shared_memory()
 
     def arr_equal(self, arr1, arr2):
         if arr1.shape != arr2.shape:
@@ -286,8 +361,7 @@ def __str__(self):
         return str(self.arr)
 
     def has_shared_memory(self):
-        """Check that created array shares data with input array.
-        """
+        """Check that created array shares data with input array."""
         if self.obj is self.arr:
             return True
         if not isinstance(self.obj, np.ndarray):
@@ -297,300 +371,316 @@ def has_shared_memory(self):
 
 
 class TestIntent:
-
     def test_in_out(self):
-        assert_equal(str(intent.in_.out), 'intent(in,out)')
-        assert_(intent.in_.c.is_intent('c'))
-        assert_(not intent.in_.c.is_intent_exact('c'))
-        assert_(intent.in_.c.is_intent_exact('c', 'in'))
-        assert_(intent.in_.c.is_intent_exact('in', 'c'))
-        assert_(not intent.in_.is_intent('c'))
+        assert str(intent.in_.out) == "intent(in,out)"
+        assert intent.in_.c.is_intent("c")
+        assert not intent.in_.c.is_intent_exact("c")
+        assert intent.in_.c.is_intent_exact("c", "in")
+        assert intent.in_.c.is_intent_exact("in", "c")
+        assert not intent.in_.is_intent("c")
 
 
 class TestSharedMemory:
-    num2seq = [1, 2]
-    num23seq = [[1, 2, 3], [4, 5, 6]]
 
-    @pytest.fixture(autouse=True, scope='class', params=_type_names)
+    @pytest.fixture(autouse=True, scope="class", params=_type_names)
     def setup_type(self, request):
         request.cls.type = Type(request.param)
-        request.cls.array = lambda self, dims, intent, obj: \
-            Array(Type(request.param), dims, intent, obj)
+        request.cls.array = lambda self, dims, intent, obj: Array(
+            Type(request.param), dims, intent, obj)
+
+    @property
+    def num2seq(self):
+        if self.type.NAME.startswith('STRING'):
+            elsize = self.type.elsize
+            return ['1' * elsize, '2' * elsize]
+        return [1, 2]
+
+    @property
+    def num23seq(self):
+        if self.type.NAME.startswith('STRING'):
+            elsize = self.type.elsize
+            return [['1' * elsize, '2' * elsize, '3' * elsize],
+                    ['4' * elsize, '5' * elsize, '6' * elsize]]
+        return [[1, 2, 3], [4, 5, 6]]
 
     def test_in_from_2seq(self):
         a = self.array([2], intent.in_, self.num2seq)
-        assert_(not a.has_shared_memory())
+        assert not a.has_shared_memory()
 
     def test_in_from_2casttype(self):
         for t in self.type.cast_types():
             obj = np.array(self.num2seq, dtype=t.dtype)
             a = self.array([len(self.num2seq)], intent.in_, obj)
             if t.elsize == self.type.elsize:
-                assert_(
-                    a.has_shared_memory(), repr((self.type.dtype, t.dtype)))
+                assert a.has_shared_memory(), repr((self.type.dtype, t.dtype))
             else:
-                assert_(not a.has_shared_memory(), repr(t.dtype))
+                assert not a.has_shared_memory()
 
-    @pytest.mark.parametrize('write', ['w', 'ro'])
-    @pytest.mark.parametrize('order', ['C', 'F'])
-    @pytest.mark.parametrize('inp', ['2seq', '23seq'])
+    @pytest.mark.parametrize("write", ["w", "ro"])
+    @pytest.mark.parametrize("order", ["C", "F"])
+    @pytest.mark.parametrize("inp", ["2seq", "23seq"])
     def test_in_nocopy(self, write, order, inp):
-        """Test if intent(in) array can be passed without copies
-        """
-        seq = getattr(self, 'num' + inp)
+        """Test if intent(in) array can be passed without copies"""
+        seq = getattr(self, "num" + inp)
         obj = np.array(seq, dtype=self.type.dtype, order=order)
         obj.setflags(write=(write == 'w'))
-        a = self.array(obj.shape, ((order=='C' and intent.in_.c) or intent.in_), obj)
+        a = self.array(obj.shape,
+                       ((order == 'C' and intent.in_.c) or intent.in_), obj)
         assert a.has_shared_memory()
 
     def test_inout_2seq(self):
         obj = np.array(self.num2seq, dtype=self.type.dtype)
         a = self.array([len(self.num2seq)], intent.inout, obj)
-        assert_(a.has_shared_memory())
+        assert a.has_shared_memory()
 
         try:
             a = self.array([2], intent.in_.inout, self.num2seq)
         except TypeError as msg:
-            if not str(msg).startswith('failed to initialize intent'
-                                       '(inout|inplace|cache) array'):
+            if not str(msg).startswith(
+                    "failed to initialize intent(inout|inplace|cache) array"):
                 raise
         else:
-            raise SystemError('intent(inout) should have failed on sequence')
+            raise SystemError("intent(inout) should have failed on sequence")
 
     def test_f_inout_23seq(self):
-        obj = np.array(self.num23seq, dtype=self.type.dtype, order='F')
+        obj = np.array(self.num23seq, dtype=self.type.dtype, order="F")
         shape = (len(self.num23seq), len(self.num23seq[0]))
         a = self.array(shape, intent.in_.inout, obj)
-        assert_(a.has_shared_memory())
+        assert a.has_shared_memory()
 
-        obj = np.array(self.num23seq, dtype=self.type.dtype, order='C')
+        obj = np.array(self.num23seq, dtype=self.type.dtype, order="C")
         shape = (len(self.num23seq), len(self.num23seq[0]))
         try:
             a = self.array(shape, intent.in_.inout, obj)
         except ValueError as msg:
-            if not str(msg).startswith('failed to initialize intent'
-                                       '(inout) array'):
+            if not str(msg).startswith(
+                    "failed to initialize intent(inout) array"):
                 raise
         else:
             raise SystemError(
-                'intent(inout) should have failed on improper array')
+                "intent(inout) should have failed on improper array")
 
     def test_c_inout_23seq(self):
         obj = np.array(self.num23seq, dtype=self.type.dtype)
         shape = (len(self.num23seq), len(self.num23seq[0]))
         a = self.array(shape, intent.in_.c.inout, obj)
-        assert_(a.has_shared_memory())
+        assert a.has_shared_memory()
 
     def test_in_copy_from_2casttype(self):
         for t in self.type.cast_types():
             obj = np.array(self.num2seq, dtype=t.dtype)
             a = self.array([len(self.num2seq)], intent.in_.copy, obj)
-            assert_(not a.has_shared_memory(), repr(t.dtype))
+            assert not a.has_shared_memory()
 
     def test_c_in_from_23seq(self):
-        a = self.array([len(self.num23seq), len(self.num23seq[0])],
-                       intent.in_, self.num23seq)
-        assert_(not a.has_shared_memory())
+        a = self.array(
+            [len(self.num23seq), len(self.num23seq[0])], intent.in_,
+            self.num23seq)
+        assert not a.has_shared_memory()
 
     def test_in_from_23casttype(self):
         for t in self.type.cast_types():
             obj = np.array(self.num23seq, dtype=t.dtype)
-            a = self.array([len(self.num23seq), len(self.num23seq[0])],
-                           intent.in_, obj)
-            assert_(not a.has_shared_memory(), repr(t.dtype))
+            a = self.array(
+                [len(self.num23seq), len(self.num23seq[0])], intent.in_, obj)
+            assert not a.has_shared_memory()
 
     def test_f_in_from_23casttype(self):
         for t in self.type.cast_types():
-            obj = np.array(self.num23seq, dtype=t.dtype, order='F')
-            a = self.array([len(self.num23seq), len(self.num23seq[0])],
-                           intent.in_, obj)
+            obj = np.array(self.num23seq, dtype=t.dtype, order="F")
+            a = self.array(
+                [len(self.num23seq), len(self.num23seq[0])], intent.in_, obj)
             if t.elsize == self.type.elsize:
-                assert_(a.has_shared_memory(), repr(t.dtype))
+                assert a.has_shared_memory()
             else:
-                assert_(not a.has_shared_memory(), repr(t.dtype))
+                assert not a.has_shared_memory()
 
     def test_c_in_from_23casttype(self):
         for t in self.type.cast_types():
             obj = np.array(self.num23seq, dtype=t.dtype)
-            a = self.array([len(self.num23seq), len(self.num23seq[0])],
-                           intent.in_.c, obj)
+            a = self.array(
+                [len(self.num23seq), len(self.num23seq[0])], intent.in_.c, obj)
             if t.elsize == self.type.elsize:
-                assert_(a.has_shared_memory(), repr(t.dtype))
+                assert a.has_shared_memory()
             else:
-                assert_(not a.has_shared_memory(), repr(t.dtype))
+                assert not a.has_shared_memory()
 
     def test_f_copy_in_from_23casttype(self):
         for t in self.type.cast_types():
-            obj = np.array(self.num23seq, dtype=t.dtype, order='F')
-            a = self.array([len(self.num23seq), len(self.num23seq[0])],
-                           intent.in_.copy, obj)
-            assert_(not a.has_shared_memory(), repr(t.dtype))
+            obj = np.array(self.num23seq, dtype=t.dtype, order="F")
+            a = self.array(
+                [len(self.num23seq), len(self.num23seq[0])], intent.in_.copy,
+                obj)
+            assert not a.has_shared_memory()
 
     def test_c_copy_in_from_23casttype(self):
         for t in self.type.cast_types():
             obj = np.array(self.num23seq, dtype=t.dtype)
-            a = self.array([len(self.num23seq), len(self.num23seq[0])],
-                           intent.in_.c.copy, obj)
-            assert_(not a.has_shared_memory(), repr(t.dtype))
+            a = self.array(
+                [len(self.num23seq), len(self.num23seq[0])], intent.in_.c.copy,
+                obj)
+            assert not a.has_shared_memory()
 
     def test_in_cache_from_2casttype(self):
         for t in self.type.all_types():
             if t.elsize != self.type.elsize:
                 continue
             obj = np.array(self.num2seq, dtype=t.dtype)
-            shape = (len(self.num2seq),)
+            shape = (len(self.num2seq), )
             a = self.array(shape, intent.in_.c.cache, obj)
-            assert_(a.has_shared_memory(), repr(t.dtype))
+            assert a.has_shared_memory()
 
             a = self.array(shape, intent.in_.cache, obj)
-            assert_(a.has_shared_memory(), repr(t.dtype))
+            assert a.has_shared_memory()
 
-            obj = np.array(self.num2seq, dtype=t.dtype, order='F')
+            obj = np.array(self.num2seq, dtype=t.dtype, order="F")
             a = self.array(shape, intent.in_.c.cache, obj)
-            assert_(a.has_shared_memory(), repr(t.dtype))
+            assert a.has_shared_memory()
 
             a = self.array(shape, intent.in_.cache, obj)
-            assert_(a.has_shared_memory(), repr(t.dtype))
+            assert a.has_shared_memory(), repr(t.dtype)
 
             try:
                 a = self.array(shape, intent.in_.cache, obj[::-1])
             except ValueError as msg:
-                if not str(msg).startswith('failed to initialize'
-                                           ' intent(cache) array'):
+                if not str(msg).startswith(
+                        "failed to initialize intent(cache) array"):
                     raise
             else:
                 raise SystemError(
-                    'intent(cache) should have failed on multisegmented array')
+                    "intent(cache) should have failed on multisegmented array")
 
     def test_in_cache_from_2casttype_failure(self):
         for t in self.type.all_types():
+            if t.NAME == 'STRING':
+                # string elsize is 0, so skipping the test
+                continue
             if t.elsize >= self.type.elsize:
                 continue
             obj = np.array(self.num2seq, dtype=t.dtype)
-            shape = (len(self.num2seq),)
+            shape = (len(self.num2seq), )
             try:
                 self.array(shape, intent.in_.cache, obj)  # Should succeed
             except ValueError as msg:
-                if not str(msg).startswith('failed to initialize'
-                                           ' intent(cache) array'):
+                if not str(msg).startswith(
+                        "failed to initialize intent(cache) array"):
                     raise
             else:
                 raise SystemError(
-                    'intent(cache) should have failed on smaller array')
+                    "intent(cache) should have failed on smaller array")
 
     def test_cache_hidden(self):
-        shape = (2,)
+        shape = (2, )
         a = self.array(shape, intent.cache.hide, None)
-        assert_(a.arr.shape == shape)
+        assert a.arr.shape == shape
 
         shape = (2, 3)
         a = self.array(shape, intent.cache.hide, None)
-        assert_(a.arr.shape == shape)
+        assert a.arr.shape == shape
 
         shape = (-1, 3)
         try:
             a = self.array(shape, intent.cache.hide, None)
         except ValueError as msg:
-            if not str(msg).startswith('failed to create intent'
-                                       '(cache|hide)|optional array'):
+            if not str(msg).startswith(
+                    "failed to create intent(cache|hide)|optional array"):
                 raise
         else:
             raise SystemError(
-                'intent(cache) should have failed on undefined dimensions')
+                "intent(cache) should have failed on undefined dimensions")
 
     def test_hidden(self):
-        shape = (2,)
+        shape = (2, )
         a = self.array(shape, intent.hide, None)
-        assert_(a.arr.shape == shape)
-        assert_(a.arr_equal(a.arr, np.zeros(shape, dtype=self.type.dtype)))
+        assert a.arr.shape == shape
+        assert a.arr_equal(a.arr, np.zeros(shape, dtype=self.type.dtype))
 
         shape = (2, 3)
         a = self.array(shape, intent.hide, None)
-        assert_(a.arr.shape == shape)
-        assert_(a.arr_equal(a.arr, np.zeros(shape, dtype=self.type.dtype)))
-        assert_(a.arr.flags['FORTRAN'] and not a.arr.flags['CONTIGUOUS'])
+        assert a.arr.shape == shape
+        assert a.arr_equal(a.arr, np.zeros(shape, dtype=self.type.dtype))
+        assert a.arr.flags["FORTRAN"] and not a.arr.flags["CONTIGUOUS"]
 
         shape = (2, 3)
         a = self.array(shape, intent.c.hide, None)
-        assert_(a.arr.shape == shape)
-        assert_(a.arr_equal(a.arr, np.zeros(shape, dtype=self.type.dtype)))
-        assert_(not a.arr.flags['FORTRAN'] and a.arr.flags['CONTIGUOUS'])
+        assert a.arr.shape == shape
+        assert a.arr_equal(a.arr, np.zeros(shape, dtype=self.type.dtype))
+        assert not a.arr.flags["FORTRAN"] and a.arr.flags["CONTIGUOUS"]
 
         shape = (-1, 3)
         try:
             a = self.array(shape, intent.hide, None)
         except ValueError as msg:
-            if not str(msg).startswith('failed to create intent'
-                                       '(cache|hide)|optional array'):
+            if not str(msg).startswith(
+                    "failed to create intent(cache|hide)|optional array"):
                 raise
         else:
-            raise SystemError('intent(hide) should have failed'
-                              ' on undefined dimensions')
+            raise SystemError(
+                "intent(hide) should have failed on undefined dimensions")
 
     def test_optional_none(self):
-        shape = (2,)
+        shape = (2, )
         a = self.array(shape, intent.optional, None)
-        assert_(a.arr.shape == shape)
-        assert_(a.arr_equal(a.arr, np.zeros(shape, dtype=self.type.dtype)))
+        assert a.arr.shape == shape
+        assert a.arr_equal(a.arr, np.zeros(shape, dtype=self.type.dtype))
 
         shape = (2, 3)
         a = self.array(shape, intent.optional, None)
-        assert_(a.arr.shape == shape)
-        assert_(a.arr_equal(a.arr, np.zeros(shape, dtype=self.type.dtype)))
-        assert_(a.arr.flags['FORTRAN'] and not a.arr.flags['CONTIGUOUS'])
+        assert a.arr.shape == shape
+        assert a.arr_equal(a.arr, np.zeros(shape, dtype=self.type.dtype))
+        assert a.arr.flags["FORTRAN"] and not a.arr.flags["CONTIGUOUS"]
 
         shape = (2, 3)
         a = self.array(shape, intent.c.optional, None)
-        assert_(a.arr.shape == shape)
-        assert_(a.arr_equal(a.arr, np.zeros(shape, dtype=self.type.dtype)))
-        assert_(not a.arr.flags['FORTRAN'] and a.arr.flags['CONTIGUOUS'])
+        assert a.arr.shape == shape
+        assert a.arr_equal(a.arr, np.zeros(shape, dtype=self.type.dtype))
+        assert not a.arr.flags["FORTRAN"] and a.arr.flags["CONTIGUOUS"]
 
     def test_optional_from_2seq(self):
         obj = self.num2seq
-        shape = (len(obj),)
+        shape = (len(obj), )
         a = self.array(shape, intent.optional, obj)
-        assert_(a.arr.shape == shape)
-        assert_(not a.has_shared_memory())
+        assert a.arr.shape == shape
+        assert not a.has_shared_memory()
 
     def test_optional_from_23seq(self):
         obj = self.num23seq
         shape = (len(obj), len(obj[0]))
         a = self.array(shape, intent.optional, obj)
-        assert_(a.arr.shape == shape)
-        assert_(not a.has_shared_memory())
+        assert a.arr.shape == shape
+        assert not a.has_shared_memory()
 
         a = self.array(shape, intent.optional.c, obj)
-        assert_(a.arr.shape == shape)
-        assert_(not a.has_shared_memory())
+        assert a.arr.shape == shape
+        assert not a.has_shared_memory()
 
     def test_inplace(self):
         obj = np.array(self.num23seq, dtype=self.type.dtype)
-        assert_(not obj.flags['FORTRAN'] and obj.flags['CONTIGUOUS'])
+        assert not obj.flags["FORTRAN"] and obj.flags["CONTIGUOUS"]
         shape = obj.shape
         a = self.array(shape, intent.inplace, obj)
-        assert_(obj[1][2] == a.arr[1][2], repr((obj, a.arr)))
+        assert obj[1][2] == a.arr[1][2], repr((obj, a.arr))
         a.arr[1][2] = 54
-        assert_(obj[1][2] == a.arr[1][2] ==
-                np.array(54, dtype=self.type.dtype), repr((obj, a.arr)))
-        assert_(a.arr is obj)
-        assert_(obj.flags['FORTRAN'])  # obj attributes are changed inplace!
-        assert_(not obj.flags['CONTIGUOUS'])
+        assert obj[1][2] == a.arr[1][2] == np.array(54, dtype=self.type.dtype)
+        assert a.arr is obj
+        assert obj.flags["FORTRAN"]  # obj attributes are changed inplace!
+        assert not obj.flags["CONTIGUOUS"]
 
     def test_inplace_from_casttype(self):
         for t in self.type.cast_types():
             if t is self.type:
                 continue
             obj = np.array(self.num23seq, dtype=t.dtype)
-            assert_(obj.dtype.type == t.type)
-            assert_(obj.dtype.type is not self.type.type)
-            assert_(not obj.flags['FORTRAN'] and obj.flags['CONTIGUOUS'])
+            assert obj.dtype.type == t.type
+            assert obj.dtype.type is not self.type.type
+            assert not obj.flags["FORTRAN"] and obj.flags["CONTIGUOUS"]
             shape = obj.shape
             a = self.array(shape, intent.inplace, obj)
-            assert_(obj[1][2] == a.arr[1][2], repr((obj, a.arr)))
+            assert obj[1][2] == a.arr[1][2], repr((obj, a.arr))
             a.arr[1][2] = 54
-            assert_(obj[1][2] == a.arr[1][2] ==
-                    np.array(54, dtype=self.type.dtype), repr((obj, a.arr)))
-            assert_(a.arr is obj)
-            assert_(obj.flags['FORTRAN'])  # obj attributes changed inplace!
-            assert_(not obj.flags['CONTIGUOUS'])
-            assert_(obj.dtype.type is self.type.type)  # obj changed inplace!
+            assert obj[1][2] == a.arr[1][2] == np.array(54,
+                                                        dtype=self.type.dtype)
+            assert a.arr is obj
+            assert obj.flags["FORTRAN"]  # obj attributes changed inplace!
+            assert not obj.flags["CONTIGUOUS"]
+            assert obj.dtype.type is self.type.type  # obj changed inplace!
diff --git a/numpy/f2py/tests/test_assumed_shape.py b/numpy/f2py/tests/test_assumed_shape.py
index 79e3ad138426..d4664cf88cbe 100644
--- a/numpy/f2py/tests/test_assumed_shape.py
+++ b/numpy/f2py/tests/test_assumed_shape.py
@@ -2,52 +2,48 @@
 import pytest
 import tempfile
 
-from numpy.testing import assert_
 from . import util
 
 
-def _path(*a):
-    return os.path.join(*((os.path.dirname(__file__),) + a))
-
-
 class TestAssumedShapeSumExample(util.F2PyTest):
-    sources = [_path('src', 'assumed_shape', 'foo_free.f90'),
-               _path('src', 'assumed_shape', 'foo_use.f90'),
-               _path('src', 'assumed_shape', 'precision.f90'),
-               _path('src', 'assumed_shape', 'foo_mod.f90'),
-               _path('src', 'assumed_shape', '.f2py_f2cmap'),
-               ]
+    sources = [
+        util.getpath("tests", "src", "assumed_shape", "foo_free.f90"),
+        util.getpath("tests", "src", "assumed_shape", "foo_use.f90"),
+        util.getpath("tests", "src", "assumed_shape", "precision.f90"),
+        util.getpath("tests", "src", "assumed_shape", "foo_mod.f90"),
+        util.getpath("tests", "src", "assumed_shape", ".f2py_f2cmap"),
+    ]
 
     @pytest.mark.slow
     def test_all(self):
         r = self.module.fsum([1, 2])
-        assert_(r == 3, repr(r))
+        assert r == 3
         r = self.module.sum([1, 2])
-        assert_(r == 3, repr(r))
+        assert r == 3
         r = self.module.sum_with_use([1, 2])
-        assert_(r == 3, repr(r))
+        assert r == 3
 
         r = self.module.mod.sum([1, 2])
-        assert_(r == 3, repr(r))
+        assert r == 3
         r = self.module.mod.fsum([1, 2])
-        assert_(r == 3, repr(r))
+        assert r == 3
 
 
 class TestF2cmapOption(TestAssumedShapeSumExample):
-    def setup(self):
+    def setup_method(self):
         # Use a custom file name for .f2py_f2cmap
         self.sources = list(self.sources)
         f2cmap_src = self.sources.pop(-1)
 
         self.f2cmap_file = tempfile.NamedTemporaryFile(delete=False)
-        with open(f2cmap_src, 'rb') as f:
+        with open(f2cmap_src, "rb") as f:
             self.f2cmap_file.write(f.read())
         self.f2cmap_file.close()
 
         self.sources.append(self.f2cmap_file.name)
         self.options = ["--f2cmap", self.f2cmap_file.name]
 
-        super().setup()
+        super().setup_method()
 
-    def teardown(self):
+    def teardown_method(self):
         os.unlink(self.f2cmap_file.name)
diff --git a/numpy/f2py/tests/test_block_docstring.py b/numpy/f2py/tests/test_block_docstring.py
index 7d725165b2fb..e0eacc0329c5 100644
--- a/numpy/f2py/tests/test_block_docstring.py
+++ b/numpy/f2py/tests/test_block_docstring.py
@@ -2,22 +2,16 @@
 import pytest
 from . import util
 
-from numpy.testing import assert_equal, IS_PYPY
+from numpy.testing import IS_PYPY
 
-class TestBlockDocString(util.F2PyTest):
-    code = """
-      SUBROUTINE FOO()
-      INTEGER BAR(2, 3)
 
-      COMMON  /BLOCK/ BAR
-      RETURN
-      END
-    """
+class TestBlockDocString(util.F2PyTest):
+    sources = [util.getpath("tests", "src", "block_docstring", "foo.f")]
 
-    @pytest.mark.skipif(sys.platform=='win32',
-                        reason='Fails with MinGW64 Gfortran (Issue #9673)')
+    @pytest.mark.skipif(sys.platform == "win32",
+                        reason="Fails with MinGW64 Gfortran (Issue #9673)")
     @pytest.mark.xfail(IS_PYPY,
                        reason="PyPy cannot modify tp_doc after PyType_Ready")
     def test_block_docstring(self):
         expected = "bar : 'i'-array(2,3)\n"
-        assert_equal(self.module.block.__doc__, expected)
+        assert self.module.block.__doc__ == expected
diff --git a/numpy/f2py/tests/test_callback.py b/numpy/f2py/tests/test_callback.py
index 5d2aab94df9a..018cea4fd5e3 100644
--- a/numpy/f2py/tests/test_callback.py
+++ b/numpy/f2py/tests/test_callback.py
@@ -7,77 +7,14 @@
 import time
 
 import numpy as np
-from numpy.testing import assert_, assert_equal, IS_PYPY
+from numpy.testing import IS_PYPY
 from . import util
 
 
 class TestF77Callback(util.F2PyTest):
-    code = """
-       subroutine t(fun,a)
-       integer a
-cf2py  intent(out) a
-       external fun
-       call fun(a)
-       end
-
-       subroutine func(a)
-cf2py  intent(in,out) a
-       integer a
-       a = a + 11
-       end
-
-       subroutine func0(a)
-cf2py  intent(out) a
-       integer a
-       a = 11
-       end
-
-       subroutine t2(a)
-cf2py  intent(callback) fun
-       integer a
-cf2py  intent(out) a
-       external fun
-       call fun(a)
-       end
-
-       subroutine string_callback(callback, a)
-       external callback
-       double precision callback
-       double precision a
-       character*1 r
-cf2py  intent(out) a
-       r = 'r'
-       a = callback(r)
-       end
-
-       subroutine string_callback_array(callback, cu, lencu, a)
-       external callback
-       integer callback
-       integer lencu
-       character*8 cu(lencu)
-       integer a
-cf2py  intent(out) a
-
-       a = callback(cu, lencu)
-       end
-
-       subroutine hidden_callback(a, r)
-       external global_f
-cf2py  intent(callback, hide) global_f
-       integer a, r, global_f
-cf2py  intent(out) r
-       r = global_f(a)
-       end
-
-       subroutine hidden_callback2(a, r)
-       external global_f
-       integer a, r, global_f
-cf2py  intent(out) r
-       r = global_f(a)
-       end
-    """
+    sources = [util.getpath("tests", "src", "callback", "foo.f")]
 
-    @pytest.mark.parametrize('name', 't,t2'.split(','))
+    @pytest.mark.parametrize("name", "t,t2".split(","))
     def test_all(self, name):
         self.check_function(name)
 
@@ -110,75 +47,77 @@ def fun(): return a
             Return objects:
                 a : int
         """)
-        assert_equal(self.module.t.__doc__, expected)
+        assert self.module.t.__doc__ == expected
 
     def check_function(self, name):
         t = getattr(self.module, name)
         r = t(lambda: 4)
-        assert_(r == 4, repr(r))
-        r = t(lambda a: 5, fun_extra_args=(6,))
-        assert_(r == 5, repr(r))
-        r = t(lambda a: a, fun_extra_args=(6,))
-        assert_(r == 6, repr(r))
-        r = t(lambda a: 5 + a, fun_extra_args=(7,))
-        assert_(r == 12, repr(r))
-        r = t(lambda a: math.degrees(a), fun_extra_args=(math.pi,))
-        assert_(r == 180, repr(r))
-        r = t(math.degrees, fun_extra_args=(math.pi,))
-        assert_(r == 180, repr(r))
-
-        r = t(self.module.func, fun_extra_args=(6,))
-        assert_(r == 17, repr(r))
+        assert r == 4
+        r = t(lambda a: 5, fun_extra_args=(6, ))
+        assert r == 5
+        r = t(lambda a: a, fun_extra_args=(6, ))
+        assert r == 6
+        r = t(lambda a: 5 + a, fun_extra_args=(7, ))
+        assert r == 12
+        r = t(lambda a: math.degrees(a), fun_extra_args=(math.pi, ))
+        assert r == 180
+        r = t(math.degrees, fun_extra_args=(math.pi, ))
+        assert r == 180
+
+        r = t(self.module.func, fun_extra_args=(6, ))
+        assert r == 17
         r = t(self.module.func0)
-        assert_(r == 11, repr(r))
+        assert r == 11
         r = t(self.module.func0._cpointer)
-        assert_(r == 11, repr(r))
+        assert r == 11
 
         class A:
-
             def __call__(self):
                 return 7
 
             def mth(self):
                 return 9
+
         a = A()
         r = t(a)
-        assert_(r == 7, repr(r))
+        assert r == 7
         r = t(a.mth)
-        assert_(r == 9, repr(r))
+        assert r == 9
 
-    @pytest.mark.skipif(sys.platform=='win32',
+    @pytest.mark.skipif(sys.platform == 'win32',
                         reason='Fails with MinGW64 Gfortran (Issue #9673)')
     def test_string_callback(self):
-
         def callback(code):
-            if code == 'r':
+            if code == "r":
                 return 0
             else:
                 return 1
 
-        f = getattr(self.module, 'string_callback')
+        f = getattr(self.module, "string_callback")
         r = f(callback)
-        assert_(r == 0, repr(r))
+        assert r == 0
 
-    @pytest.mark.skipif(sys.platform=='win32',
+    @pytest.mark.skipif(sys.platform == 'win32',
                         reason='Fails with MinGW64 Gfortran (Issue #9673)')
     def test_string_callback_array(self):
         # See gh-10027
-        cu = np.zeros((1, 8), 'S1')
+        cu1 = np.zeros((1, ), "S8")
+        cu2 = np.zeros((1, 8), "c")
+        cu3 = np.array([""], "S8")
 
         def callback(cu, lencu):
-            if cu.shape != (lencu, 8):
+            if cu.shape != (lencu,):
                 return 1
-            if cu.dtype != 'S1':
+            if cu.dtype != "S8":
                 return 2
-            if not np.all(cu == b''):
+            if not np.all(cu == b""):
                 return 3
             return 0
 
-        f = getattr(self.module, 'string_callback_array')
-        res = f(callback, cu, len(cu))
-        assert_(res == 0, repr(res))
+        f = getattr(self.module, "string_callback_array")
+        for cu in [cu1, cu2, cu3]:
+            res = f(callback, cu, cu.size)
+            assert res == 0
 
     def test_threadsafety(self):
         # Segfaults if the callback handling is not threadsafe
@@ -192,7 +131,7 @@ def cb():
 
             # Check reentrancy
             r = self.module.t(lambda: 123)
-            assert_(r == 123)
+            assert r == 123
 
             return 42
 
@@ -200,13 +139,15 @@ def runner(name):
             try:
                 for j in range(50):
                     r = self.module.t(cb)
-                    assert_(r == 42)
+                    assert r == 42
                     self.check_function(name)
             except Exception:
                 errors.append(traceback.format_exc())
 
-        threads = [threading.Thread(target=runner, args=(arg,))
-                   for arg in ("t", "t2") for n in range(20)]
+        threads = [
+            threading.Thread(target=runner, args=(arg, ))
+            for arg in ("t", "t2") for n in range(20)
+        ]
 
         for t in threads:
             t.start()
@@ -222,34 +163,34 @@ def test_hidden_callback(self):
         try:
             self.module.hidden_callback(2)
         except Exception as msg:
-            assert_(str(msg).startswith('Callback global_f not defined'))
+            assert str(msg).startswith("Callback global_f not defined")
 
         try:
             self.module.hidden_callback2(2)
         except Exception as msg:
-            assert_(str(msg).startswith('cb: Callback global_f not defined'))
+            assert str(msg).startswith("cb: Callback global_f not defined")
 
         self.module.global_f = lambda x: x + 1
         r = self.module.hidden_callback(2)
-        assert_(r == 3)
+        assert r == 3
 
         self.module.global_f = lambda x: x + 2
         r = self.module.hidden_callback(2)
-        assert_(r == 4)
+        assert r == 4
 
         del self.module.global_f
         try:
             self.module.hidden_callback(2)
         except Exception as msg:
-            assert_(str(msg).startswith('Callback global_f not defined'))
+            assert str(msg).startswith("Callback global_f not defined")
 
         self.module.global_f = lambda x=0: x + 3
         r = self.module.hidden_callback(2)
-        assert_(r == 5)
+        assert r == 5
 
         # reproducer of gh18341
         r = self.module.hidden_callback2(2)
-        assert_(r == 3)
+        assert r == 3
 
 
 class TestF77CallbackPythonTLS(TestF77Callback):
@@ -257,26 +198,14 @@ class TestF77CallbackPythonTLS(TestF77Callback):
     Callback tests using Python thread-local storage instead of
     compiler-provided
     """
+
     options = ["-DF2PY_USE_PYTHON_TLS"]
 
 
 class TestF90Callback(util.F2PyTest):
-
-    suffix = '.f90'
-
-    code = textwrap.dedent(
-        """
-        function gh17797(f, y) result(r)
-          external f
-          integer(8) :: r, f
-          integer(8), dimension(:) :: y
-          r = f(0)
-          r = r + sum(y)
-        end function gh17797
-        """)
+    sources = [util.getpath("tests", "src", "callback", "gh17797.f90")]
 
     def test_gh17797(self):
-
         def incr(x):
             return x + 123
 
@@ -291,35 +220,11 @@ class TestGH18335(util.F2PyTest):
     implemented as a separate test class. Do not extend this test with
     other tests!
     """
-
-    suffix = '.f90'
-
-    code = textwrap.dedent(
-        """
-        ! When gh18335_workaround is defined as an extension,
-        ! the issue cannot be reproduced.
-        !subroutine gh18335_workaround(f, y)
-        !  implicit none
-        !  external f
-        !  integer(kind=1) :: y(1)
-        !  call f(y)
-        !end subroutine gh18335_workaround
-
-        function gh18335(f) result (r)
-          implicit none
-          external f
-          integer(kind=1) :: y(1), r
-          y(1) = 123
-          call f(y)
-          r = y(1)
-        end function gh18335
-        """)
+    sources = [util.getpath("tests", "src", "callback", "gh18335.f90")]
 
     def test_gh18335(self):
-
         def foo(x):
             x[0] += 1
 
-        y = np.array([1, 2, 3], dtype=np.int8)
         r = self.module.gh18335(foo)
         assert r == 123 + 1
diff --git a/numpy/f2py/tests/test_character.py b/numpy/f2py/tests/test_character.py
new file mode 100644
index 000000000000..79998b460edf
--- /dev/null
+++ b/numpy/f2py/tests/test_character.py
@@ -0,0 +1,592 @@
+import pytest
+import textwrap
+from numpy.testing import assert_array_equal, assert_equal, assert_raises
+import numpy as np
+from numpy.f2py.tests import util
+
+
+class TestCharacterString(util.F2PyTest):
+    # options = ['--debug-capi', '--build-dir', '/tmp/test-build-f2py']
+    suffix = '.f90'
+    fprefix = 'test_character_string'
+    length_list = ['1', '3', 'star']
+
+    code = ''
+    for length in length_list:
+        fsuffix = length
+        clength = dict(star='(*)').get(length, length)
+
+        code += textwrap.dedent(f"""
+
+        subroutine {fprefix}_input_{fsuffix}(c, o, n)
+          character*{clength}, intent(in) :: c
+          integer n
+          !f2py integer, depend(c), intent(hide) :: n = slen(c)
+          integer*1, dimension(n) :: o
+          !f2py intent(out) o
+          o = transfer(c, o)
+        end subroutine {fprefix}_input_{fsuffix}
+
+        subroutine {fprefix}_output_{fsuffix}(c, o, n)
+          character*{clength}, intent(out) :: c
+          integer n
+          integer*1, dimension(n), intent(in) :: o
+          !f2py integer, depend(o), intent(hide) :: n = len(o)
+          c = transfer(o, c)
+        end subroutine {fprefix}_output_{fsuffix}
+
+        subroutine {fprefix}_array_input_{fsuffix}(c, o, m, n)
+          integer m, i, n
+          character*{clength}, intent(in), dimension(m) :: c
+          !f2py integer, depend(c), intent(hide) :: m = len(c)
+          !f2py integer, depend(c), intent(hide) :: n = f2py_itemsize(c)
+          integer*1, dimension(m, n), intent(out) :: o
+          do i=1,m
+            o(i, :) = transfer(c(i), o(i, :))
+          end do
+        end subroutine {fprefix}_array_input_{fsuffix}
+
+        subroutine {fprefix}_array_output_{fsuffix}(c, o, m, n)
+          character*{clength}, intent(out), dimension(m) :: c
+          integer n
+          integer*1, dimension(m, n), intent(in) :: o
+          !f2py character(f2py_len=n) :: c
+          !f2py integer, depend(o), intent(hide) :: m = len(o)
+          !f2py integer, depend(o), intent(hide) :: n = shape(o, 1)
+          do i=1,m
+            c(i) = transfer(o(i, :), c(i))
+          end do
+        end subroutine {fprefix}_array_output_{fsuffix}
+
+        subroutine {fprefix}_2d_array_input_{fsuffix}(c, o, m1, m2, n)
+          integer m1, m2, i, j, n
+          character*{clength}, intent(in), dimension(m1, m2) :: c
+          !f2py integer, depend(c), intent(hide) :: m1 = len(c)
+          !f2py integer, depend(c), intent(hide) :: m2 = shape(c, 1)
+          !f2py integer, depend(c), intent(hide) :: n = f2py_itemsize(c)
+          integer*1, dimension(m1, m2, n), intent(out) :: o
+          do i=1,m1
+            do j=1,m2
+              o(i, j, :) = transfer(c(i, j), o(i, j, :))
+            end do
+          end do
+        end subroutine {fprefix}_2d_array_input_{fsuffix}
+        """)
+
+    @pytest.mark.parametrize("length", length_list)
+    def test_input(self, length):
+        fsuffix = {'(*)': 'star'}.get(length, length)
+        f = getattr(self.module, self.fprefix + '_input_' + fsuffix)
+
+        a = {'1': 'a', '3': 'abc', 'star': 'abcde' * 3}[length]
+
+        assert_array_equal(f(a), np.array(list(map(ord, a)), dtype='u1'))
+
+    @pytest.mark.parametrize("length", length_list[:-1])
+    def test_output(self, length):
+        fsuffix = length
+        f = getattr(self.module, self.fprefix + '_output_' + fsuffix)
+
+        a = {'1': 'a', '3': 'abc'}[length]
+
+        assert_array_equal(f(np.array(list(map(ord, a)), dtype='u1')),
+                           a.encode())
+
+    @pytest.mark.parametrize("length", length_list)
+    def test_array_input(self, length):
+        fsuffix = length
+        f = getattr(self.module, self.fprefix + '_array_input_' + fsuffix)
+
+        a = np.array([{'1': 'a', '3': 'abc', 'star': 'abcde' * 3}[length],
+                      {'1': 'A', '3': 'ABC', 'star': 'ABCDE' * 3}[length],
+                      ], dtype='S')
+
+        expected = np.array([[c for c in s] for s in a], dtype='u1')
+        assert_array_equal(f(a), expected)
+
+    @pytest.mark.parametrize("length", length_list)
+    def test_array_output(self, length):
+        fsuffix = length
+        f = getattr(self.module, self.fprefix + '_array_output_' + fsuffix)
+
+        expected = np.array(
+            [{'1': 'a', '3': 'abc', 'star': 'abcde' * 3}[length],
+             {'1': 'A', '3': 'ABC', 'star': 'ABCDE' * 3}[length]], dtype='S')
+
+        a = np.array([[c for c in s] for s in expected], dtype='u1')
+        assert_array_equal(f(a), expected)
+
+    @pytest.mark.parametrize("length", length_list)
+    def test_2d_array_input(self, length):
+        fsuffix = length
+        f = getattr(self.module, self.fprefix + '_2d_array_input_' + fsuffix)
+
+        a = np.array([[{'1': 'a', '3': 'abc', 'star': 'abcde' * 3}[length],
+                       {'1': 'A', '3': 'ABC', 'star': 'ABCDE' * 3}[length]],
+                      [{'1': 'f', '3': 'fgh', 'star': 'fghij' * 3}[length],
+                       {'1': 'F', '3': 'FGH', 'star': 'FGHIJ' * 3}[length]]],
+                     dtype='S')
+        expected = np.array([[[c for c in item] for item in row] for row in a],
+                            dtype='u1', order='F')
+        assert_array_equal(f(a), expected)
+
+
+class TestCharacter(util.F2PyTest):
+    # options = ['--debug-capi', '--build-dir', '/tmp/test-build-f2py']
+    suffix = '.f90'
+    fprefix = 'test_character'
+
+    code = textwrap.dedent(f"""
+       subroutine {fprefix}_input(c, o)
+          character, intent(in) :: c
+          integer*1 o
+          !f2py intent(out) o
+          o = transfer(c, o)
+       end subroutine {fprefix}_input
+
+       subroutine {fprefix}_output(c, o)
+          character :: c
+          integer*1, intent(in) :: o
+          !f2py intent(out) c
+          c = transfer(o, c)
+       end subroutine {fprefix}_output
+
+       subroutine {fprefix}_input_output(c, o)
+          character, intent(in) :: c
+          character o
+          !f2py intent(out) o
+          o = c
+       end subroutine {fprefix}_input_output
+
+       subroutine {fprefix}_inout(c, n)
+          character :: c, n
+          !f2py intent(in) n
+          !f2py intent(inout) c
+          c = n
+       end subroutine {fprefix}_inout
+
+       function {fprefix}_return(o) result (c)
+          character :: c
+          character, intent(in) :: o
+          c = transfer(o, c)
+       end function {fprefix}_return
+
+       subroutine {fprefix}_array_input(c, o)
+          character, intent(in) :: c(3)
+          integer*1 o(3)
+          !f2py intent(out) o
+          integer i
+          do i=1,3
+            o(i) = transfer(c(i), o(i))
+          end do
+       end subroutine {fprefix}_array_input
+
+       subroutine {fprefix}_2d_array_input(c, o)
+          character, intent(in) :: c(2, 3)
+          integer*1 o(2, 3)
+          !f2py intent(out) o
+          integer i, j
+          do i=1,2
+            do j=1,3
+              o(i, j) = transfer(c(i, j), o(i, j))
+            end do
+          end do
+       end subroutine {fprefix}_2d_array_input
+
+       subroutine {fprefix}_array_output(c, o)
+          character :: c(3)
+          integer*1, intent(in) :: o(3)
+          !f2py intent(out) c
+          do i=1,3
+            c(i) = transfer(o(i), c(i))
+          end do
+       end subroutine {fprefix}_array_output
+
+       subroutine {fprefix}_array_inout(c, n)
+          character :: c(3), n(3)
+          !f2py intent(in) n(3)
+          !f2py intent(inout) c(3)
+          do i=1,3
+            c(i) = n(i)
+          end do
+       end subroutine {fprefix}_array_inout
+
+       subroutine {fprefix}_2d_array_inout(c, n)
+          character :: c(2, 3), n(2, 3)
+          !f2py intent(in) n(2, 3)
+          !f2py intent(inout) c(2. 3)
+          integer i, j
+          do i=1,2
+            do j=1,3
+              c(i, j) = n(i, j)
+            end do
+          end do
+       end subroutine {fprefix}_2d_array_inout
+
+       function {fprefix}_array_return(o) result (c)
+          character, dimension(3) :: c
+          character, intent(in) :: o(3)
+          do i=1,3
+            c(i) = o(i)
+          end do
+       end function {fprefix}_array_return
+
+       function {fprefix}_optional(o) result (c)
+          character, intent(in) :: o
+          !f2py character o = "a"
+          character :: c
+          c = o
+       end function {fprefix}_optional
+    """)
+
+    @pytest.mark.parametrize("dtype", ['c', 'S1'])
+    def test_input(self, dtype):
+        f = getattr(self.module, self.fprefix + '_input')
+
+        assert_equal(f(np.array('a', dtype=dtype)), ord('a'))
+        assert_equal(f(np.array(b'a', dtype=dtype)), ord('a'))
+        assert_equal(f(np.array(['a'], dtype=dtype)), ord('a'))
+        assert_equal(f(np.array('abc', dtype=dtype)), ord('a'))
+        assert_equal(f(np.array([['a']], dtype=dtype)), ord('a'))
+
+    def test_input_varia(self):
+        f = getattr(self.module, self.fprefix + '_input')
+
+        assert_equal(f('a'), ord('a'))
+        assert_equal(f(b'a'), ord(b'a'))
+        assert_equal(f(''), 0)
+        assert_equal(f(b''), 0)
+        assert_equal(f(b'\0'), 0)
+        assert_equal(f('ab'), ord('a'))
+        assert_equal(f(b'ab'), ord('a'))
+        assert_equal(f(['a']), ord('a'))
+
+        assert_equal(f(np.array(b'a')), ord('a'))
+        assert_equal(f(np.array([b'a'])), ord('a'))
+        a = np.array('a')
+        assert_equal(f(a), ord('a'))
+        a = np.array(['a'])
+        assert_equal(f(a), ord('a'))
+
+        try:
+            f([])
+        except IndexError as msg:
+            if not str(msg).endswith(' got 0-list'):
+                raise
+        else:
+            raise SystemError(f'{f.__name__} should have failed on empty list')
+
+        try:
+            f(97)
+        except TypeError as msg:
+            if not str(msg).endswith(' got int instance'):
+                raise
+        else:
+            raise SystemError(f'{f.__name__} should have failed on int value')
+
+    @pytest.mark.parametrize("dtype", ['c', 'S1', 'U1'])
+    def test_array_input(self, dtype):
+        f = getattr(self.module, self.fprefix + '_array_input')
+
+        assert_array_equal(f(np.array(['a', 'b', 'c'], dtype=dtype)),
+                           np.array(list(map(ord, 'abc')), dtype='i1'))
+        assert_array_equal(f(np.array([b'a', b'b', b'c'], dtype=dtype)),
+                           np.array(list(map(ord, 'abc')), dtype='i1'))
+
+    def test_array_input_varia(self):
+        f = getattr(self.module, self.fprefix + '_array_input')
+        assert_array_equal(f(['a', 'b', 'c']),
+                           np.array(list(map(ord, 'abc')), dtype='i1'))
+        assert_array_equal(f([b'a', b'b', b'c']),
+                           np.array(list(map(ord, 'abc')), dtype='i1'))
+
+        try:
+            f(['a', 'b', 'c', 'd'])
+        except ValueError as msg:
+            if not str(msg).endswith(
+                    'th dimension must be fixed to 3 but got 4'):
+                raise
+        else:
+            raise SystemError(
+                f'{f.__name__} should have failed on wrong input')
+
+    @pytest.mark.parametrize("dtype", ['c', 'S1', 'U1'])
+    def test_2d_array_input(self, dtype):
+        f = getattr(self.module, self.fprefix + '_2d_array_input')
+
+        a = np.array([['a', 'b', 'c'],
+                      ['d', 'e', 'f']], dtype=dtype, order='F')
+        expected = a.view(np.uint32 if dtype == 'U1' else np.uint8)
+        assert_array_equal(f(a), expected)
+
+    def test_output(self):
+        f = getattr(self.module, self.fprefix + '_output')
+
+        assert_equal(f(ord(b'a')), b'a')
+        assert_equal(f(0), b'\0')
+
+    def test_array_output(self):
+        f = getattr(self.module, self.fprefix + '_array_output')
+
+        assert_array_equal(f(list(map(ord, 'abc'))),
+                           np.array(list('abc'), dtype='S1'))
+
+    def test_input_output(self):
+        f = getattr(self.module, self.fprefix + '_input_output')
+
+        assert_equal(f(b'a'), b'a')
+        assert_equal(f('a'), b'a')
+        assert_equal(f(''), b'\0')
+
+    @pytest.mark.parametrize("dtype", ['c', 'S1'])
+    def test_inout(self, dtype):
+        f = getattr(self.module, self.fprefix + '_inout')
+
+        a = np.array(list('abc'), dtype=dtype)
+        f(a, 'A')
+        assert_array_equal(a, np.array(list('Abc'), dtype=a.dtype))
+        f(a[1:], 'B')
+        assert_array_equal(a, np.array(list('ABc'), dtype=a.dtype))
+
+        a = np.array(['abc'], dtype=dtype)
+        f(a, 'A')
+        assert_array_equal(a, np.array(['Abc'], dtype=a.dtype))
+
+    def test_inout_varia(self):
+        f = getattr(self.module, self.fprefix + '_inout')
+        a = np.array('abc', dtype='S3')
+        f(a, 'A')
+        assert_array_equal(a, np.array('Abc', dtype=a.dtype))
+
+        a = np.array(['abc'], dtype='S3')
+        f(a, 'A')
+        assert_array_equal(a, np.array(['Abc'], dtype=a.dtype))
+
+        try:
+            f('abc', 'A')
+        except ValueError as msg:
+            if not str(msg).endswith(' got 3-str'):
+                raise
+        else:
+            raise SystemError(f'{f.__name__} should have failed on str value')
+
+    @pytest.mark.parametrize("dtype", ['c', 'S1'])
+    def test_array_inout(self, dtype):
+        f = getattr(self.module, self.fprefix + '_array_inout')
+        n = np.array(['A', 'B', 'C'], dtype=dtype, order='F')
+
+        a = np.array(['a', 'b', 'c'], dtype=dtype, order='F')
+        f(a, n)
+        assert_array_equal(a, n)
+
+        a = np.array(['a', 'b', 'c', 'd'], dtype=dtype)
+        f(a[1:], n)
+        assert_array_equal(a, np.array(['a', 'A', 'B', 'C'], dtype=dtype))
+
+        a = np.array([['a', 'b', 'c']], dtype=dtype, order='F')
+        f(a, n)
+        assert_array_equal(a, np.array([['A', 'B', 'C']], dtype=dtype))
+
+        a = np.array(['a', 'b', 'c', 'd'], dtype=dtype, order='F')
+        try:
+            f(a, n)
+        except ValueError as msg:
+            if not str(msg).endswith(
+                    'th dimension must be fixed to 3 but got 4'):
+                raise
+        else:
+            raise SystemError(
+                f'{f.__name__} should have failed on wrong input')
+
+    @pytest.mark.parametrize("dtype", ['c', 'S1'])
+    def test_2d_array_inout(self, dtype):
+        f = getattr(self.module, self.fprefix + '_2d_array_inout')
+        n = np.array([['A', 'B', 'C'],
+                      ['D', 'E', 'F']],
+                     dtype=dtype, order='F')
+        a = np.array([['a', 'b', 'c'],
+                      ['d', 'e', 'f']],
+                     dtype=dtype, order='F')
+        f(a, n)
+        assert_array_equal(a, n)
+
+    def test_return(self):
+        f = getattr(self.module, self.fprefix + '_return')
+
+        assert_equal(f('a'), b'a')
+
+    @pytest.mark.skip('fortran function returning array segfaults')
+    def test_array_return(self):
+        f = getattr(self.module, self.fprefix + '_array_return')
+
+        a = np.array(list('abc'), dtype='S1')
+        assert_array_equal(f(a), a)
+
+    def test_optional(self):
+        f = getattr(self.module, self.fprefix + '_optional')
+
+        assert_equal(f(), b"a")
+        assert_equal(f(b'B'), b"B")
+
+
+class TestMiscCharacter(util.F2PyTest):
+    # options = ['--debug-capi', '--build-dir', '/tmp/test-build-f2py']
+    suffix = '.f90'
+    fprefix = 'test_misc_character'
+
+    code = textwrap.dedent(f"""
+       subroutine {fprefix}_gh18684(x, y, m)
+         character(len=5), dimension(m), intent(in) :: x
+         character*5, dimension(m), intent(out) :: y
+         integer i, m
+         !f2py integer, intent(hide), depend(x) :: m = f2py_len(x)
+         do i=1,m
+           y(i) = x(i)
+         end do
+       end subroutine {fprefix}_gh18684
+
+       subroutine {fprefix}_gh6308(x, i)
+         integer i
+         !f2py check(i>=0 && i<12) i
+         character*5 name, x
+         common name(12)
+         name(i + 1) = x
+       end subroutine {fprefix}_gh6308
+
+       subroutine {fprefix}_gh4519(x)
+         character(len=*), intent(in) :: x(:)
+         !f2py intent(out) x
+         integer :: i
+         do i=1, size(x)
+           print*, "x(",i,")=", x(i)
+         end do
+       end subroutine {fprefix}_gh4519
+
+       pure function {fprefix}_gh3425(x) result (y)
+         character(len=*), intent(in) :: x
+         character(len=len(x)) :: y
+         integer :: i
+         do i = 1, len(x)
+           j = iachar(x(i:i))
+           if (j>=iachar("a") .and. j<=iachar("z") ) then
+             y(i:i) = achar(j-32)
+           else
+             y(i:i) = x(i:i)
+           endif
+         end do
+       end function {fprefix}_gh3425
+
+       subroutine {fprefix}_character_bc_new(x, y, z)
+         character, intent(in) :: x
+         character, intent(out) :: y
+         !f2py character, depend(x) :: y = x
+         !f2py character, dimension((x=='a'?1:2)), depend(x), intent(out) :: z
+         character, dimension(*) :: z
+         !f2py character, optional, check(x == 'a' || x == 'b') :: x = 'a'
+         !f2py callstatement (*f2py_func)(&x, &y, z)
+         !f2py callprotoargument character*, character*, character*
+         if (y.eq.x) then
+           y = x
+         else
+           y = 'e'
+         endif
+         z(1) = 'c'
+       end subroutine {fprefix}_character_bc_new
+
+       subroutine {fprefix}_character_bc_old(x, y, z)
+         character, intent(in) :: x
+         character, intent(out) :: y
+         !f2py character, depend(x) :: y = x[0]
+         !f2py character, dimension((*x=='a'?1:2)), depend(x), intent(out) :: z
+         character, dimension(*) :: z
+         !f2py character, optional, check(*x == 'a' || x[0] == 'b') :: x = 'a'
+         !f2py callstatement (*f2py_func)(x, y, z)
+         !f2py callprotoargument char*, char*, char*
+          if (y.eq.x) then
+           y = x
+         else
+           y = 'e'
+         endif
+         z(1) = 'c'
+       end subroutine {fprefix}_character_bc_old
+    """)
+
+    def test_gh18684(self):
+        # Test character(len=5) and character*5 usages
+        f = getattr(self.module, self.fprefix + '_gh18684')
+        x = np.array(["abcde", "fghij"], dtype='S5')
+        y = f(x)
+
+        assert_array_equal(x, y)
+
+    def test_gh6308(self):
+        # Test character string array in a common block
+        f = getattr(self.module, self.fprefix + '_gh6308')
+
+        assert_equal(self.module._BLNK_.name.dtype, np.dtype('S5'))
+        assert_equal(len(self.module._BLNK_.name), 12)
+        f("abcde", 0)
+        assert_equal(self.module._BLNK_.name[0], b"abcde")
+        f("12345", 5)
+        assert_equal(self.module._BLNK_.name[5], b"12345")
+
+    def test_gh4519(self):
+        # Test array of assumed length strings
+        f = getattr(self.module, self.fprefix + '_gh4519')
+
+        for x, expected in [
+                ('a', dict(shape=(), dtype=np.dtype('S1'))),
+                ('text', dict(shape=(), dtype=np.dtype('S4'))),
+                (np.array(['1', '2', '3'], dtype='S1'),
+                 dict(shape=(3,), dtype=np.dtype('S1'))),
+                (['1', '2', '34'],
+                 dict(shape=(3,), dtype=np.dtype('S2'))),
+                (['', ''], dict(shape=(2,), dtype=np.dtype('S1')))]:
+            r = f(x)
+            for k, v in expected.items():
+                assert_equal(getattr(r, k), v)
+
+    def test_gh3425(self):
+        # Test returning a copy of assumed length string
+        f = getattr(self.module, self.fprefix + '_gh3425')
+        # f is equivalent to bytes.upper
+
+        assert_equal(f('abC'), b'ABC')
+        assert_equal(f(''), b'')
+        assert_equal(f('abC12d'), b'ABC12D')
+
+    @pytest.mark.parametrize("state", ['new', 'old'])
+    def test_character_bc(self, state):
+        f = getattr(self.module, self.fprefix + '_character_bc_' + state)
+
+        c, a = f()
+        assert_equal(c, b'a')
+        assert_equal(len(a), 1)
+
+        c, a = f(b'b')
+        assert_equal(c, b'b')
+        assert_equal(len(a), 2)
+
+        assert_raises(Exception, lambda: f(b'c'))
+
+
+class TestStringScalarArr(util.F2PyTest):
+    sources = [util.getpath("tests", "src", "string", "scalar_string.f90")]
+
+    @pytest.mark.slow
+    def test_char(self):
+        for out in (self.module.string_test.string,
+                    self.module.string_test.string77):
+            expected = ()
+            assert out.shape == expected
+            expected = '|S8'
+            assert out.dtype == expected
+
+    @pytest.mark.slow
+    def test_char_arr(self):
+        for out in (self.module.string_test.strarr,
+                    self.module.string_test.strarr77):
+            expected = (5,7)
+            assert out.shape == expected
+            expected = '|S12'
+            assert out.dtype == expected
diff --git a/numpy/f2py/tests/test_common.py b/numpy/f2py/tests/test_common.py
index e4bf35504761..8a4b221ef8bd 100644
--- a/numpy/f2py/tests/test_common.py
+++ b/numpy/f2py/tests/test_common.py
@@ -5,21 +5,14 @@
 import numpy as np
 from . import util
 
-from numpy.testing import assert_array_equal
-
-def _path(*a):
-    return os.path.join(*((os.path.dirname(__file__),) + a))
 
 class TestCommonBlock(util.F2PyTest):
-    sources = [_path('src', 'common', 'block.f')]
+    sources = [util.getpath("tests", "src", "common", "block.f")]
 
-    @pytest.mark.skipif(sys.platform=='win32',
-                        reason='Fails with MinGW64 Gfortran (Issue #9673)')
+    @pytest.mark.skipif(sys.platform == "win32",
+                        reason="Fails with MinGW64 Gfortran (Issue #9673)")
     def test_common_block(self):
         self.module.initcb()
-        assert_array_equal(self.module.block.long_bn,
-                           np.array(1.0, dtype=np.float64))
-        assert_array_equal(self.module.block.string_bn,
-                           np.array('2', dtype='|S1'))
-        assert_array_equal(self.module.block.ok,
-                           np.array(3, dtype=np.int32))
+        assert self.module.block.long_bn == np.array(1.0, dtype=np.float64)
+        assert self.module.block.string_bn == np.array("2", dtype="|S1")
+        assert self.module.block.ok == np.array(3, dtype=np.int32)
diff --git a/numpy/f2py/tests/test_compile_function.py b/numpy/f2py/tests/test_compile_function.py
index f76fd644807c..3c16f319812f 100644
--- a/numpy/f2py/tests/test_compile_function.py
+++ b/numpy/f2py/tests/test_compile_function.py
@@ -9,7 +9,6 @@
 
 import numpy.f2py
 
-from numpy.testing import assert_equal
 from . import util
 
 
@@ -17,14 +16,13 @@ def setup_module():
     if not util.has_c_compiler():
         pytest.skip("Needs C compiler")
     if not util.has_f77_compiler():
-        pytest.skip('Needs FORTRAN 77 compiler')
+        pytest.skip("Needs FORTRAN 77 compiler")
 
 
 # extra_args can be a list (since gh-11937) or string.
 # also test absence of extra_args
-@pytest.mark.parametrize(
-    "extra_args", [['--noopt', '--debug'], '--noopt --debug', '']
-    )
+@pytest.mark.parametrize("extra_args",
+                         [["--noopt", "--debug"], "--noopt --debug", ""])
 @pytest.mark.leaks_references(reason="Imported module seems never deleted.")
 def test_f2py_init_compile(extra_args):
     # flush through the f2py __init__ compile() function code path as a
@@ -33,7 +31,7 @@ def test_f2py_init_compile(extra_args):
 
     # the Fortran 77 syntax requires 6 spaces before any commands, but
     # more space may be added/
-    fsource =  """
+    fsource = """
         integer function foo()
         foo = 10 + 5
         return
@@ -45,7 +43,7 @@ def test_f2py_init_compile(extra_args):
     modname = util.get_temp_module_name()
 
     cwd = os.getcwd()
-    target = os.path.join(moddir, str(uuid.uuid4()) + '.f')
+    target = os.path.join(moddir, str(uuid.uuid4()) + ".f")
     # try running compile() with and without a source_fn provided so
     # that the code path where a temporary file for writing Fortran
     # source is created is also explored
@@ -54,40 +52,35 @@ def test_f2py_init_compile(extra_args):
         # util.py, but don't actually use build_module() because it has
         # its own invocation of subprocess that circumvents the
         # f2py.compile code block under test
-        try:
-            os.chdir(moddir)
-            ret_val = numpy.f2py.compile(
-                fsource,
-                modulename=modname,
-                extra_args=extra_args,
-                source_fn=source_fn
-                )
-        finally:
-            os.chdir(cwd)
-
-        # check for compile success return value
-        assert_equal(ret_val, 0)
-
-        # we are not currently able to import the Python-Fortran
-        # interface module on Windows / Appveyor, even though we do get
-        # successful compilation on that platform with Python 3.x
-        if sys.platform != 'win32':
-            # check for sensible result of Fortran function; that means
-            # we can import the module name in Python and retrieve the
-            # result of the sum operation
-            return_check = import_module(modname)
-            calc_result = return_check.foo()
-            assert_equal(calc_result, 15)
-            # Removal from sys.modules, is not as such necessary. Even with
-            # removal, the module (dict) stays alive.
-            del sys.modules[modname]
+        with util.switchdir(moddir):
+            ret_val = numpy.f2py.compile(fsource,
+                                         modulename=modname,
+                                         extra_args=extra_args,
+                                         source_fn=source_fn)
+
+            # check for compile success return value
+            assert ret_val == 0
+
+    # we are not currently able to import the Python-Fortran
+    # interface module on Windows / Appveyor, even though we do get
+    # successful compilation on that platform with Python 3.x
+    if sys.platform != "win32":
+        # check for sensible result of Fortran function; that means
+        # we can import the module name in Python and retrieve the
+        # result of the sum operation
+        return_check = import_module(modname)
+        calc_result = return_check.foo()
+        assert calc_result == 15
+        # Removal from sys.modules, is not as such necessary. Even with
+        # removal, the module (dict) stays alive.
+        del sys.modules[modname]
 
 
 def test_f2py_init_compile_failure():
     # verify an appropriate integer status value returned by
     # f2py.compile() when invalid Fortran is provided
     ret_val = numpy.f2py.compile(b"invalid")
-    assert_equal(ret_val, 1)
+    assert ret_val == 1
 
 
 def test_f2py_init_compile_bad_cmd():
@@ -99,27 +92,26 @@ def test_f2py_init_compile_bad_cmd():
     # downstream NOTE: how bad of an idea is this patching?
     try:
         temp = sys.executable
-        sys.executable = 'does not exist'
+        sys.executable = "does not exist"
 
         # the OSError should take precedence over invalid Fortran
         ret_val = numpy.f2py.compile(b"invalid")
-        assert_equal(ret_val, 127)
+        assert ret_val == 127
     finally:
         sys.executable = temp
 
 
-@pytest.mark.parametrize('fsource',
-        ['program test_f2py\nend program test_f2py',
-         b'program test_f2py\nend program test_f2py',])
+@pytest.mark.parametrize(
+    "fsource",
+    [
+        "program test_f2py\nend program test_f2py",
+        b"program test_f2py\nend program test_f2py",
+    ],
+)
 def test_compile_from_strings(tmpdir, fsource):
     # Make sure we can compile str and bytes gh-12796
-    cwd = os.getcwd()
-    try:
-        os.chdir(str(tmpdir))
-        ret_val = numpy.f2py.compile(
-                fsource,
-                modulename='test_compile_from_strings',
-                extension='.f90')
-        assert_equal(ret_val, 0)
-    finally:
-        os.chdir(cwd)
+    with util.switchdir(tmpdir):
+        ret_val = numpy.f2py.compile(fsource,
+                                     modulename="test_compile_from_strings",
+                                     extension=".f90")
+        assert ret_val == 0
diff --git a/numpy/f2py/tests/test_crackfortran.py b/numpy/f2py/tests/test_crackfortran.py
index 039e085b48f8..73ac4e2760cd 100644
--- a/numpy/f2py/tests/test_crackfortran.py
+++ b/numpy/f2py/tests/test_crackfortran.py
@@ -1,6 +1,8 @@
+import importlib
+import codecs
+import unicodedata
 import pytest
 import numpy as np
-from numpy.testing import assert_array_equal, assert_equal
 from numpy.f2py.crackfortran import markinnerspaces
 from . import util
 from numpy.f2py import crackfortran
@@ -10,164 +12,127 @@
 class TestNoSpace(util.F2PyTest):
     # issue gh-15035: add handling for endsubroutine, endfunction with no space
     # between "end" and the block name
-    code = """
-        subroutine subb(k)
-          real(8), intent(inout) :: k(:)
-          k=k+1
-        endsubroutine
-
-        subroutine subc(w,k)
-          real(8), intent(in) :: w(:)
-          real(8), intent(out) :: k(size(w))
-          k=w+1
-        endsubroutine
-
-        function t0(value)
-          character value
-          character t0
-          t0 = value
-        endfunction
-    """
+    sources = [util.getpath("tests", "src", "crackfortran", "gh15035.f")]
 
     def test_module(self):
         k = np.array([1, 2, 3], dtype=np.float64)
         w = np.array([1, 2, 3], dtype=np.float64)
         self.module.subb(k)
-        assert_array_equal(k, w + 1)
+        assert np.allclose(k, w + 1)
         self.module.subc([w, k])
-        assert_array_equal(k, w + 1)
-        assert self.module.t0(23) == b'2'
-
-
-class TestPublicPrivate():
-
-    def test_defaultPrivate(self, tmp_path):
-        f_path = tmp_path / "mod.f90"
-        with f_path.open('w') as ff:
-            ff.write(textwrap.dedent("""\
-            module foo
-              private
-              integer :: a
-              public :: setA
-              integer :: b
-            contains
-              subroutine setA(v)
-                integer, intent(in) :: v
-                a = v
-              end subroutine setA
-            end module foo
-            """))
-        mod = crackfortran.crackfortran([str(f_path)])
+        assert np.allclose(k, w + 1)
+        assert self.module.t0("23") == b"2"
+
+
+class TestPublicPrivate:
+    def test_defaultPrivate(self):
+        fpath = util.getpath("tests", "src", "crackfortran", "privatemod.f90")
+        mod = crackfortran.crackfortran([str(fpath)])
         assert len(mod) == 1
         mod = mod[0]
-        assert 'private' in mod['vars']['a']['attrspec']
-        assert 'public' not in mod['vars']['a']['attrspec']
-        assert 'private' in mod['vars']['b']['attrspec']
-        assert 'public' not in mod['vars']['b']['attrspec']
-        assert 'private' not in mod['vars']['seta']['attrspec']
-        assert 'public' in mod['vars']['seta']['attrspec']
+        assert "private" in mod["vars"]["a"]["attrspec"]
+        assert "public" not in mod["vars"]["a"]["attrspec"]
+        assert "private" in mod["vars"]["b"]["attrspec"]
+        assert "public" not in mod["vars"]["b"]["attrspec"]
+        assert "private" not in mod["vars"]["seta"]["attrspec"]
+        assert "public" in mod["vars"]["seta"]["attrspec"]
 
     def test_defaultPublic(self, tmp_path):
-        f_path = tmp_path / "mod.f90"
-        with f_path.open('w') as ff:
-            ff.write(textwrap.dedent("""\
-            module foo
-              public
-              integer, private :: a
-              public :: setA
-            contains
-              subroutine setA(v)
-                integer, intent(in) :: v
-                a = v
-              end subroutine setA
-            end module foo
-            """))
-        mod = crackfortran.crackfortran([str(f_path)])
+        fpath = util.getpath("tests", "src", "crackfortran", "publicmod.f90")
+        mod = crackfortran.crackfortran([str(fpath)])
         assert len(mod) == 1
         mod = mod[0]
-        assert 'private' in mod['vars']['a']['attrspec']
-        assert 'public' not in mod['vars']['a']['attrspec']
-        assert 'private' not in mod['vars']['seta']['attrspec']
-        assert 'public' in mod['vars']['seta']['attrspec']
+        assert "private" in mod["vars"]["a"]["attrspec"]
+        assert "public" not in mod["vars"]["a"]["attrspec"]
+        assert "private" not in mod["vars"]["seta"]["attrspec"]
+        assert "public" in mod["vars"]["seta"]["attrspec"]
+
+    def test_access_type(self, tmp_path):
+        fpath = util.getpath("tests", "src", "crackfortran", "accesstype.f90")
+        mod = crackfortran.crackfortran([str(fpath)])
+        assert len(mod) == 1
+        tt = mod[0]['vars']
+        assert set(tt['a']['attrspec']) == {'private', 'bind(c)'}
+        assert set(tt['b_']['attrspec']) == {'public', 'bind(c)'}
+        assert set(tt['c']['attrspec']) == {'public'}
+
+
+class TestModuleProcedure():
+    def test_moduleOperators(self, tmp_path):
+        fpath = util.getpath("tests", "src", "crackfortran", "operators.f90")
+        mod = crackfortran.crackfortran([str(fpath)])
+        assert len(mod) == 1
+        mod = mod[0]
+        assert "body" in mod and len(mod["body"]) == 9
+        assert mod["body"][1]["name"] == "operator(.item.)"
+        assert "implementedby" in mod["body"][1]
+        assert mod["body"][1]["implementedby"] == \
+            ["item_int", "item_real"]
+        assert mod["body"][2]["name"] == "operator(==)"
+        assert "implementedby" in mod["body"][2]
+        assert mod["body"][2]["implementedby"] == ["items_are_equal"]
+        assert mod["body"][3]["name"] == "assignment(=)"
+        assert "implementedby" in mod["body"][3]
+        assert mod["body"][3]["implementedby"] == \
+            ["get_int", "get_real"]
+
+    def test_notPublicPrivate(self, tmp_path):
+        fpath = util.getpath("tests", "src", "crackfortran", "pubprivmod.f90")
+        mod = crackfortran.crackfortran([str(fpath)])
+        assert len(mod) == 1
+        mod = mod[0]
+        assert mod['vars']['a']['attrspec'] == ['private', ]
+        assert mod['vars']['b']['attrspec'] == ['public', ]
+        assert mod['vars']['seta']['attrspec'] == ['public', ]
 
 
 class TestExternal(util.F2PyTest):
     # issue gh-17859: add external attribute support
-    code = """
-        integer(8) function external_as_statement(fcn)
-        implicit none
-        external fcn
-        integer(8) :: fcn
-        external_as_statement = fcn(0)
-        end
-
-        integer(8) function external_as_attribute(fcn)
-        implicit none
-        integer(8), external :: fcn
-        external_as_attribute = fcn(0)
-        end
-    """
+    sources = [util.getpath("tests", "src", "crackfortran", "gh17859.f")]
 
     def test_external_as_statement(self):
         def incr(x):
             return x + 123
+
         r = self.module.external_as_statement(incr)
         assert r == 123
 
     def test_external_as_attribute(self):
         def incr(x):
             return x + 123
+
         r = self.module.external_as_attribute(incr)
         assert r == 123
 
 
 class TestCrackFortran(util.F2PyTest):
-
-    suffix = '.f90'
-
-    code = textwrap.dedent("""
-      subroutine gh2848( &
-        ! first 2 parameters
-        par1, par2,&
-        ! last 2 parameters
-        par3, par4)
-
-        integer, intent(in)  :: par1, par2
-        integer, intent(out) :: par3, par4
-
-        par3 = par1
-        par4 = par2
-
-      end subroutine gh2848
-    """)
+    # gh-2848: commented lines between parameters in subroutine parameter lists
+    sources = [util.getpath("tests", "src", "crackfortran", "gh2848.f90")]
 
     def test_gh2848(self):
         r = self.module.gh2848(1, 2)
         assert r == (1, 2)
 
 
-class TestMarkinnerspaces():
-    # issue #14118: markinnerspaces does not handle multiple quotations
+class TestMarkinnerspaces:
+    # gh-14118: markinnerspaces does not handle multiple quotations
 
     def test_do_not_touch_normal_spaces(self):
         test_list = ["a ", " a", "a b c", "'abcdefghij'"]
         for i in test_list:
-            assert_equal(markinnerspaces(i), i)
+            assert markinnerspaces(i) == i
 
     def test_one_relevant_space(self):
-        assert_equal(markinnerspaces("a 'b c' \\\' \\\'"), "a 'b@_@c' \\' \\'")
-        assert_equal(markinnerspaces(r'a "b c" \" \"'), r'a "b@_@c" \" \"')
+        assert markinnerspaces("a 'b c' \\' \\'") == "a 'b@_@c' \\' \\'"
+        assert markinnerspaces(r'a "b c" \" \"') == r'a "b@_@c" \" \"'
 
     def test_ignore_inner_quotes(self):
-        assert_equal(markinnerspaces('a \'b c" " d\' e'),
-                     "a 'b@_@c\"@_@\"@_@d' e")
-        assert_equal(markinnerspaces('a "b c\' \' d" e'),
-                     "a \"b@_@c'@_@'@_@d\" e")
+        assert markinnerspaces("a 'b c\" \" d' e") == "a 'b@_@c\"@_@\"@_@d' e"
+        assert markinnerspaces("a \"b c' ' d\" e") == "a \"b@_@c'@_@'@_@d\" e"
 
     def test_multiple_relevant_spaces(self):
-        assert_equal(markinnerspaces("a 'b c' 'd e'"), "a 'b@_@c' 'd@_@e'")
-        assert_equal(markinnerspaces(r'a "b c" "d e"'), r'a "b@_@c" "d@_@e"')
-
+        assert markinnerspaces("a 'b c' 'd e'") == "a 'b@_@c' 'd@_@e'"
+        assert markinnerspaces(r'a "b c" "d e"') == r'a "b@_@c" "d@_@e"'
 
 class TestDimSpec(util.F2PyTest):
     """This test suite tests various expressions that are used as dimension
@@ -200,7 +165,7 @@ class TestDimSpec(util.F2PyTest):
 
     """
 
-    suffix = '.f90'
+    suffix = ".f90"
 
     code_template = textwrap.dedent("""
       function get_arr_size_{count}(a, n) result (length)
@@ -221,33 +186,38 @@ class TestDimSpec(util.F2PyTest):
       end subroutine
     """)
 
-    linear_dimspecs = ['n', '2*n', '2:n', 'n/2', '5 - n/2', '3*n:20',
-                       'n*(n+1):n*(n+5)']
-    nonlinear_dimspecs = ['2*n:3*n*n+2*n']
+    linear_dimspecs = [
+        "n", "2*n", "2:n", "n/2", "5 - n/2", "3*n:20", "n*(n+1):n*(n+5)",
+        "2*n, n"
+    ]
+    nonlinear_dimspecs = ["2*n:3*n*n+2*n"]
     all_dimspecs = linear_dimspecs + nonlinear_dimspecs
 
-    code = ''
+    code = ""
     for count, dimspec in enumerate(all_dimspecs):
+        lst = [(d.split(":")[0] if ":" in d else "1") for d in dimspec.split(',')]
         code += code_template.format(
-            count=count, dimspec=dimspec,
-            first=dimspec.split(':')[0] if ':' in dimspec else '1')
+            count=count,
+            dimspec=dimspec,
+            first=", ".join(lst),
+        )
 
-    @pytest.mark.parametrize('dimspec', all_dimspecs)
+    @pytest.mark.parametrize("dimspec", all_dimspecs)
     def test_array_size(self, dimspec):
 
         count = self.all_dimspecs.index(dimspec)
-        get_arr_size = getattr(self.module, f'get_arr_size_{count}')
+        get_arr_size = getattr(self.module, f"get_arr_size_{count}")
 
         for n in [1, 2, 3, 4, 5]:
             sz, a = get_arr_size(n)
-            assert len(a) == sz
+            assert a.size == sz
 
-    @pytest.mark.parametrize('dimspec', all_dimspecs)
+    @pytest.mark.parametrize("dimspec", all_dimspecs)
     def test_inv_array_size(self, dimspec):
 
         count = self.all_dimspecs.index(dimspec)
-        get_arr_size = getattr(self.module, f'get_arr_size_{count}')
-        get_inv_arr_size = getattr(self.module, f'get_inv_arr_size_{count}')
+        get_arr_size = getattr(self.module, f"get_arr_size_{count}")
+        get_inv_arr_size = getattr(self.module, f"get_inv_arr_size_{count}")
 
         for n in [1, 2, 3, 4, 5]:
             sz, a = get_arr_size(n)
@@ -266,18 +236,43 @@ def test_inv_array_size(self, dimspec):
             assert sz == sz1, (n, n1, sz, sz1)
 
 
-class TestModuleDeclaration():
+class TestModuleDeclaration:
     def test_dependencies(self, tmp_path):
-        f_path = tmp_path / "mod.f90"
-        with f_path.open('w') as ff:
-            ff.write(textwrap.dedent("""\
-            module foo
-              type bar
-                character(len = 4) :: text
-              end type bar
-              type(bar), parameter :: abar = bar('abar')
-            end module foo
-            """))
-        mod = crackfortran.crackfortran([str(f_path)])
+        fpath = util.getpath("tests", "src", "crackfortran", "foo_deps.f90")
+        mod = crackfortran.crackfortran([str(fpath)])
         assert len(mod) == 1
-        assert mod[0]['vars']['abar']['='] == "bar('abar')"
+        assert mod[0]["vars"]["abar"]["="] == "bar('abar')"
+
+class TestEval(util.F2PyTest):
+    def test_eval_scalar(self):
+        eval_scalar = crackfortran._eval_scalar
+
+        assert eval_scalar('123', {}) == '123'
+        assert eval_scalar('12 + 3', {}) == '15'
+        assert eval_scalar('a + b', dict(a=1, b=2)) == '3'
+        assert eval_scalar('"123"', {}) == "'123'"
+
+
+class TestFortranReader(util.F2PyTest):
+    @pytest.mark.parametrize("encoding",
+                             ['ascii', 'utf-8', 'utf-16', 'utf-32'])
+    def test_input_encoding(self, tmp_path, encoding):
+        # gh-635
+        f_path = tmp_path / f"input_with_{encoding}_encoding.f90"
+        with f_path.open('w', encoding=encoding) as ff:
+            ff.write("""
+                     subroutine foo()
+                     end subroutine foo
+                     """)
+        mod = crackfortran.crackfortran([str(f_path)])
+        assert mod[0]['name'] == 'foo'
+
+class TestUnicodeComment(util.F2PyTest):
+    sources = [util.getpath("tests", "src", "crackfortran", "unicode_comment.f90")]
+
+    @pytest.mark.skipif(
+        (importlib.util.find_spec("charset_normalizer") is None),
+        reason="test requires charset_normalizer which is not installed",
+    )
+    def test_encoding_comment(self):
+        self.module.foo(3)
diff --git a/numpy/f2py/tests/test_docs.py b/numpy/f2py/tests/test_docs.py
new file mode 100644
index 000000000000..6631dd82c9c7
--- /dev/null
+++ b/numpy/f2py/tests/test_docs.py
@@ -0,0 +1,55 @@
+import os
+import pytest
+import numpy as np
+from numpy.testing import assert_array_equal, assert_equal
+from . import util
+
+
+def get_docdir():
+    # assuming that documentation tests are run from a source
+    # directory
+    return os.path.abspath(os.path.join(
+        os.path.dirname(__file__),
+        '..', '..', '..',
+        'doc', 'source', 'f2py', 'code'))
+
+
+pytestmark = pytest.mark.skipif(
+    not os.path.isdir(get_docdir()),
+    reason=('Could not find f2py documentation sources'
+            f' ({get_docdir()} does not exists)'))
+
+
+def _path(*a):
+    return os.path.join(*((get_docdir(),) + a))
+
+
+class TestDocAdvanced(util.F2PyTest):
+    # options = ['--debug-capi', '--build-dir', '/tmp/build-f2py']
+    sources = [_path('asterisk1.f90'), _path('asterisk2.f90'),
+               _path('ftype.f')]
+
+    def test_asterisk1(self):
+        foo = getattr(self.module, 'foo1')
+        assert_equal(foo(), b'123456789A12')
+
+    def test_asterisk2(self):
+        foo = getattr(self.module, 'foo2')
+        assert_equal(foo(2), b'12')
+        assert_equal(foo(12), b'123456789A12')
+        assert_equal(foo(24), b'123456789A123456789B')
+
+    def test_ftype(self):
+        ftype = self.module
+        ftype.foo()
+        assert_equal(ftype.data.a, 0)
+        ftype.data.a = 3
+        ftype.data.x = [1, 2, 3]
+        assert_equal(ftype.data.a, 3)
+        assert_array_equal(ftype.data.x,
+                           np.array([1, 2, 3], dtype=np.float32))
+        ftype.data.x[1] = 45
+        assert_array_equal(ftype.data.x,
+                           np.array([1, 45, 3], dtype=np.float32))
+
+    # TODO: implement test methods for other example Fortran codes
diff --git a/numpy/f2py/tests/test_f2cmap.py b/numpy/f2py/tests/test_f2cmap.py
new file mode 100644
index 000000000000..d2967e4f73d7
--- /dev/null
+++ b/numpy/f2py/tests/test_f2cmap.py
@@ -0,0 +1,15 @@
+from . import util
+import numpy as np
+
+class TestF2Cmap(util.F2PyTest):
+    sources = [
+        util.getpath("tests", "src", "f2cmap", "isoFortranEnvMap.f90"),
+        util.getpath("tests", "src", "f2cmap", ".f2py_f2cmap")
+    ]
+
+    # gh-15095
+    def test_long_long_map(self):
+        inp = np.ones(3)
+        out = self.module.func1(inp)
+        exp_out = 3
+        assert out == exp_out
diff --git a/numpy/f2py/tests/test_f2py2e.py b/numpy/f2py/tests/test_f2py2e.py
new file mode 100644
index 000000000000..2c10f046f1d9
--- /dev/null
+++ b/numpy/f2py/tests/test_f2py2e.py
@@ -0,0 +1,769 @@
+import textwrap, re, sys, subprocess, shlex
+from pathlib import Path
+from collections import namedtuple
+
+import pytest
+
+from . import util
+from numpy.f2py.f2py2e import main as f2pycli
+
+#########################
+# CLI utils and classes #
+#########################
+
+PPaths = namedtuple("PPaths", "finp, f90inp, pyf, wrap77, wrap90, cmodf")
+
+
+def get_io_paths(fname_inp, mname="untitled"):
+    """Takes in a temporary file for testing and returns the expected output and input paths
+
+    Here expected output is essentially one of any of the possible generated
+    files.
+
+    ..note::
+
+         Since this does not actually run f2py, none of these are guaranteed to
+         exist, and module names are typically incorrect
+
+    Parameters
+    ----------
+    fname_inp : str
+                The input filename
+    mname : str, optional
+                The name of the module, untitled by default
+
+    Returns
+    -------
+    genp : NamedTuple PPaths
+            The possible paths which are generated, not all of which exist
+    """
+    bpath = Path(fname_inp)
+    return PPaths(
+        finp=bpath.with_suffix(".f"),
+        f90inp=bpath.with_suffix(".f90"),
+        pyf=bpath.with_suffix(".pyf"),
+        wrap77=bpath.with_name(f"{mname}-f2pywrappers.f"),
+        wrap90=bpath.with_name(f"{mname}-f2pywrappers2.f90"),
+        cmodf=bpath.with_name(f"{mname}module.c"),
+    )
+
+
+##############
+# CLI Fixtures and Tests #
+#############
+
+
+@pytest.fixture(scope="session")
+def hello_world_f90(tmpdir_factory):
+    """Generates a single f90 file for testing"""
+    fdat = util.getpath("tests", "src", "cli", "hiworld.f90").read_text()
+    fn = tmpdir_factory.getbasetemp() / "hello.f90"
+    fn.write_text(fdat, encoding="ascii")
+    return fn
+
+
+@pytest.fixture(scope="session")
+def hello_world_f77(tmpdir_factory):
+    """Generates a single f77 file for testing"""
+    fdat = util.getpath("tests", "src", "cli", "hi77.f").read_text()
+    fn = tmpdir_factory.getbasetemp() / "hello.f"
+    fn.write_text(fdat, encoding="ascii")
+    return fn
+
+
+@pytest.fixture(scope="session")
+def retreal_f77(tmpdir_factory):
+    """Generates a single f77 file for testing"""
+    fdat = util.getpath("tests", "src", "return_real", "foo77.f").read_text()
+    fn = tmpdir_factory.getbasetemp() / "foo.f"
+    fn.write_text(fdat, encoding="ascii")
+    return fn
+
+@pytest.fixture(scope="session")
+def f2cmap_f90(tmpdir_factory):
+    """Generates a single f90 file for testing"""
+    fdat = util.getpath("tests", "src", "f2cmap", "isoFortranEnvMap.f90").read_text()
+    f2cmap = util.getpath("tests", "src", "f2cmap", ".f2py_f2cmap").read_text()
+    fn = tmpdir_factory.getbasetemp() / "f2cmap.f90"
+    fmap = tmpdir_factory.getbasetemp() / "mapfile"
+    fn.write_text(fdat, encoding="ascii")
+    fmap.write_text(f2cmap, encoding="ascii")
+    return fn
+
+
+def test_gen_pyf(capfd, hello_world_f90, monkeypatch):
+    """Ensures that a signature file is generated via the CLI
+    CLI :: -h
+    """
+    ipath = Path(hello_world_f90)
+    opath = Path(hello_world_f90).stem + ".pyf"
+    monkeypatch.setattr(sys, "argv", f'f2py -h {opath} {ipath}'.split())
+
+    with util.switchdir(ipath.parent):
+        f2pycli()  # Generate wrappers
+        out, _ = capfd.readouterr()
+        assert "Saving signatures to file" in out
+        assert Path(f'{opath}').exists()
+
+
+def test_gen_pyf_stdout(capfd, hello_world_f90, monkeypatch):
+    """Ensures that a signature file can be dumped to stdout
+    CLI :: -h
+    """
+    ipath = Path(hello_world_f90)
+    monkeypatch.setattr(sys, "argv", f'f2py -h stdout {ipath}'.split())
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        out, _ = capfd.readouterr()
+        assert "Saving signatures to file" in out
+        assert "function hi() ! in " in out
+
+
+def test_gen_pyf_no_overwrite(capfd, hello_world_f90, monkeypatch):
+    """Ensures that the CLI refuses to overwrite signature files
+    CLI :: -h without --overwrite-signature
+    """
+    ipath = Path(hello_world_f90)
+    monkeypatch.setattr(sys, "argv", f'f2py -h faker.pyf {ipath}'.split())
+
+    with util.switchdir(ipath.parent):
+        Path("faker.pyf").write_text("Fake news", encoding="ascii")
+        with pytest.raises(SystemExit):
+            f2pycli()  # Refuse to overwrite
+            _, err = capfd.readouterr()
+            assert "Use --overwrite-signature to overwrite" in err
+
+
+@pytest.mark.xfail
+def test_f2py_skip(capfd, retreal_f77, monkeypatch):
+    """Tests that functions can be skipped
+    CLI :: skip:
+    """
+    foutl = get_io_paths(retreal_f77, mname="test")
+    ipath = foutl.finp
+    toskip = "t0 t4 t8 sd s8 s4"
+    remaining = "td s0"
+    monkeypatch.setattr(
+        sys, "argv",
+        f'f2py {ipath} -m test skip: {toskip}'.split())
+
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        out, err = capfd.readouterr()
+        for skey in toskip.split():
+            assert (
+                f'buildmodule: Could not found the body of interfaced routine "{skey}". Skipping.'
+                in err)
+        for rkey in remaining.split():
+            assert f'Constructing wrapper function "{rkey}"' in out
+
+
+def test_f2py_only(capfd, retreal_f77, monkeypatch):
+    """Test that functions can be kept by only:
+    CLI :: only:
+    """
+    foutl = get_io_paths(retreal_f77, mname="test")
+    ipath = foutl.finp
+    toskip = "t0 t4 t8 sd s8 s4"
+    tokeep = "td s0"
+    monkeypatch.setattr(
+        sys, "argv",
+        f'f2py {ipath} -m test only: {tokeep}'.split())
+
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        out, err = capfd.readouterr()
+        for skey in toskip.split():
+            assert (
+                f'buildmodule: Could not find the body of interfaced routine "{skey}". Skipping.'
+                in err)
+        for rkey in tokeep.split():
+            assert f'Constructing wrapper function "{rkey}"' in out
+
+
+def test_file_processing_switch(capfd, hello_world_f90, retreal_f77,
+                                monkeypatch):
+    """Tests that it is possible to return to file processing mode
+    CLI :: :
+    BUG: numpy-gh #20520
+    """
+    foutl = get_io_paths(retreal_f77, mname="test")
+    ipath = foutl.finp
+    toskip = "t0 t4 t8 sd s8 s4"
+    ipath2 = Path(hello_world_f90)
+    tokeep = "td s0 hi"  # hi is in ipath2
+    mname = "blah"
+    monkeypatch.setattr(
+        sys,
+        "argv",
+        f'f2py {ipath} -m {mname} only: {tokeep} : {ipath2}'.split(
+        ),
+    )
+
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        out, err = capfd.readouterr()
+        for skey in toskip.split():
+            assert (
+                f'buildmodule: Could not find the body of interfaced routine "{skey}". Skipping.'
+                in err)
+        for rkey in tokeep.split():
+            assert f'Constructing wrapper function "{rkey}"' in out
+
+
+def test_mod_gen_f77(capfd, hello_world_f90, monkeypatch):
+    """Checks the generation of files based on a module name
+    CLI :: -m
+    """
+    MNAME = "hi"
+    foutl = get_io_paths(hello_world_f90, mname=MNAME)
+    ipath = foutl.f90inp
+    monkeypatch.setattr(sys, "argv", f'f2py {ipath} -m {MNAME}'.split())
+    with util.switchdir(ipath.parent):
+        f2pycli()
+
+    # Always generate C module
+    assert Path.exists(foutl.cmodf)
+    # File contains a function, check for F77 wrappers
+    assert Path.exists(foutl.wrap77)
+
+
+def test_lower_cmod(capfd, hello_world_f77, monkeypatch):
+    """Lowers cases by flag or when -h is present
+
+    CLI :: --[no-]lower
+    """
+    foutl = get_io_paths(hello_world_f77, mname="test")
+    ipath = foutl.finp
+    capshi = re.compile(r"HI\(\)")
+    capslo = re.compile(r"hi\(\)")
+    # Case I: --lower is passed
+    monkeypatch.setattr(sys, "argv", f'f2py {ipath} -m test --lower'.split())
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        out, _ = capfd.readouterr()
+        assert capslo.search(out) is not None
+        assert capshi.search(out) is None
+    # Case II: --no-lower is passed
+    monkeypatch.setattr(sys, "argv",
+                        f'f2py {ipath} -m test --no-lower'.split())
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        out, _ = capfd.readouterr()
+        assert capslo.search(out) is None
+        assert capshi.search(out) is not None
+
+
+def test_lower_sig(capfd, hello_world_f77, monkeypatch):
+    """Lowers cases in signature files by flag or when -h is present
+
+    CLI :: --[no-]lower -h
+    """
+    foutl = get_io_paths(hello_world_f77, mname="test")
+    ipath = foutl.finp
+    # Signature files
+    capshi = re.compile(r"Block: HI")
+    capslo = re.compile(r"Block: hi")
+    # Case I: --lower is implied by -h
+    # TODO: Clean up to prevent passing --overwrite-signature
+    monkeypatch.setattr(
+        sys,
+        "argv",
+        f'f2py {ipath} -h {foutl.pyf} -m test --overwrite-signature'.split(),
+    )
+
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        out, _ = capfd.readouterr()
+        assert capslo.search(out) is not None
+        assert capshi.search(out) is None
+
+    # Case II: --no-lower overrides -h
+    monkeypatch.setattr(
+        sys,
+        "argv",
+        f'f2py {ipath} -h {foutl.pyf} -m test --overwrite-signature --no-lower'
+        .split(),
+    )
+
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        out, _ = capfd.readouterr()
+        assert capslo.search(out) is None
+        assert capshi.search(out) is not None
+
+
+def test_build_dir(capfd, hello_world_f90, monkeypatch):
+    """Ensures that the build directory can be specified
+
+    CLI :: --build-dir
+    """
+    ipath = Path(hello_world_f90)
+    mname = "blah"
+    odir = "tttmp"
+    monkeypatch.setattr(sys, "argv",
+                        f'f2py -m {mname} {ipath} --build-dir {odir}'.split())
+
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        out, _ = capfd.readouterr()
+        assert f"Wrote C/API module \"{mname}\"" in out
+
+
+def test_overwrite(capfd, hello_world_f90, monkeypatch):
+    """Ensures that the build directory can be specified
+
+    CLI :: --overwrite-signature
+    """
+    ipath = Path(hello_world_f90)
+    monkeypatch.setattr(
+        sys, "argv",
+        f'f2py -h faker.pyf {ipath} --overwrite-signature'.split())
+
+    with util.switchdir(ipath.parent):
+        Path("faker.pyf").write_text("Fake news", encoding="ascii")
+        f2pycli()
+        out, _ = capfd.readouterr()
+        assert "Saving signatures to file" in out
+
+
+def test_latexdoc(capfd, hello_world_f90, monkeypatch):
+    """Ensures that TeX documentation is written out
+
+    CLI :: --latex-doc
+    """
+    ipath = Path(hello_world_f90)
+    mname = "blah"
+    monkeypatch.setattr(sys, "argv",
+                        f'f2py -m {mname} {ipath} --latex-doc'.split())
+
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        out, _ = capfd.readouterr()
+        assert "Documentation is saved to file" in out
+        with Path(f"{mname}module.tex").open() as otex:
+            assert "\\documentclass" in otex.read()
+
+
+def test_nolatexdoc(capfd, hello_world_f90, monkeypatch):
+    """Ensures that TeX documentation is written out
+
+    CLI :: --no-latex-doc
+    """
+    ipath = Path(hello_world_f90)
+    mname = "blah"
+    monkeypatch.setattr(sys, "argv",
+                        f'f2py -m {mname} {ipath} --no-latex-doc'.split())
+
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        out, _ = capfd.readouterr()
+        assert "Documentation is saved to file" not in out
+
+
+def test_shortlatex(capfd, hello_world_f90, monkeypatch):
+    """Ensures that truncated documentation is written out
+
+    TODO: Test to ensure this has no effect without --latex-doc
+    CLI :: --latex-doc --short-latex
+    """
+    ipath = Path(hello_world_f90)
+    mname = "blah"
+    monkeypatch.setattr(
+        sys,
+        "argv",
+        f'f2py -m {mname} {ipath} --latex-doc --short-latex'.split(),
+    )
+
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        out, _ = capfd.readouterr()
+        assert "Documentation is saved to file" in out
+        with Path(f"./{mname}module.tex").open() as otex:
+            assert "\\documentclass" not in otex.read()
+
+
+def test_restdoc(capfd, hello_world_f90, monkeypatch):
+    """Ensures that RsT documentation is written out
+
+    CLI :: --rest-doc
+    """
+    ipath = Path(hello_world_f90)
+    mname = "blah"
+    monkeypatch.setattr(sys, "argv",
+                        f'f2py -m {mname} {ipath} --rest-doc'.split())
+
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        out, _ = capfd.readouterr()
+        assert "ReST Documentation is saved to file" in out
+        with Path(f"./{mname}module.rest").open() as orst:
+            assert r".. -*- rest -*-" in orst.read()
+
+
+def test_norestexdoc(capfd, hello_world_f90, monkeypatch):
+    """Ensures that TeX documentation is written out
+
+    CLI :: --no-rest-doc
+    """
+    ipath = Path(hello_world_f90)
+    mname = "blah"
+    monkeypatch.setattr(sys, "argv",
+                        f'f2py -m {mname} {ipath} --no-rest-doc'.split())
+
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        out, _ = capfd.readouterr()
+        assert "ReST Documentation is saved to file" not in out
+
+
+def test_debugcapi(capfd, hello_world_f90, monkeypatch):
+    """Ensures that debugging wrappers are written
+
+    CLI :: --debug-capi
+    """
+    ipath = Path(hello_world_f90)
+    mname = "blah"
+    monkeypatch.setattr(sys, "argv",
+                        f'f2py -m {mname} {ipath} --debug-capi'.split())
+
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        with Path(f"./{mname}module.c").open() as ocmod:
+            assert r"#define DEBUGCFUNCS" in ocmod.read()
+
+
+@pytest.mark.xfail(reason="Consistently fails on CI.")
+def test_debugcapi_bld(hello_world_f90, monkeypatch):
+    """Ensures that debugging wrappers work
+
+    CLI :: --debug-capi -c
+    """
+    ipath = Path(hello_world_f90)
+    mname = "blah"
+    monkeypatch.setattr(sys, "argv",
+                        f'f2py -m {mname} {ipath} -c --debug-capi'.split())
+
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        cmd_run = shlex.split("python3 -c \"import blah; blah.hi()\"")
+        rout = subprocess.run(cmd_run, capture_output=True, encoding='UTF-8')
+        eout = ' Hello World\n'
+        eerr = textwrap.dedent("""\
+debug-capi:Python C/API function blah.hi()
+debug-capi:float hi=:output,hidden,scalar
+debug-capi:hi=0
+debug-capi:Fortran subroutine `f2pywraphi(&hi)'
+debug-capi:hi=0
+debug-capi:Building return value.
+debug-capi:Python C/API function blah.hi: successful.
+debug-capi:Freeing memory.
+        """)
+        assert rout.stdout == eout
+        assert rout.stderr == eerr
+
+
+def test_wrapfunc_def(capfd, hello_world_f90, monkeypatch):
+    """Ensures that fortran subroutine wrappers for F77 are included by default
+
+    CLI :: --[no]-wrap-functions
+    """
+    # Implied
+    ipath = Path(hello_world_f90)
+    mname = "blah"
+    monkeypatch.setattr(sys, "argv", f'f2py -m {mname} {ipath}'.split())
+
+    with util.switchdir(ipath.parent):
+        f2pycli()
+    out, _ = capfd.readouterr()
+    assert r"Fortran 77 wrappers are saved to" in out
+
+    # Explicit
+    monkeypatch.setattr(sys, "argv",
+                        f'f2py -m {mname} {ipath} --wrap-functions'.split())
+
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        out, _ = capfd.readouterr()
+        assert r"Fortran 77 wrappers are saved to" in out
+
+
+def test_nowrapfunc(capfd, hello_world_f90, monkeypatch):
+    """Ensures that fortran subroutine wrappers for F77 can be disabled
+
+    CLI :: --no-wrap-functions
+    """
+    ipath = Path(hello_world_f90)
+    mname = "blah"
+    monkeypatch.setattr(sys, "argv",
+                        f'f2py -m {mname} {ipath} --no-wrap-functions'.split())
+
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        out, _ = capfd.readouterr()
+        assert r"Fortran 77 wrappers are saved to" not in out
+
+
+def test_inclheader(capfd, hello_world_f90, monkeypatch):
+    """Add to the include directories
+
+    CLI :: -include
+    TODO: Document this in the help string
+    """
+    ipath = Path(hello_world_f90)
+    mname = "blah"
+    monkeypatch.setattr(
+        sys,
+        "argv",
+        f'f2py -m {mname} {ipath} -include -include '.
+        split(),
+    )
+
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        with Path(f"./{mname}module.c").open() as ocmod:
+            ocmr = ocmod.read()
+            assert "#include " in ocmr
+            assert "#include " in ocmr
+
+
+def test_inclpath():
+    """Add to the include directories
+
+    CLI :: --include-paths
+    """
+    # TODO: populate
+    pass
+
+
+def test_hlink():
+    """Add to the include directories
+
+    CLI :: --help-link
+    """
+    # TODO: populate
+    pass
+
+
+def test_f2cmap(capfd, f2cmap_f90, monkeypatch):
+    """Check that Fortran-to-Python KIND specs can be passed
+
+    CLI :: --f2cmap
+    """
+    ipath = Path(f2cmap_f90)
+    monkeypatch.setattr(sys, "argv", f'f2py -m blah {ipath} --f2cmap mapfile'.split())
+
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        out, _ = capfd.readouterr()
+        assert "Reading f2cmap from 'mapfile' ..." in out
+        assert "Mapping \"real(kind=real32)\" to \"float\"" in out
+        assert "Mapping \"real(kind=real64)\" to \"double\"" in out
+        assert "Mapping \"integer(kind=int64)\" to \"long_long\"" in out
+        assert "Successfully applied user defined f2cmap changes" in out
+
+
+def test_quiet(capfd, hello_world_f90, monkeypatch):
+    """Reduce verbosity
+
+    CLI :: --quiet
+    """
+    ipath = Path(hello_world_f90)
+    monkeypatch.setattr(sys, "argv", f'f2py -m blah {ipath} --quiet'.split())
+
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        out, _ = capfd.readouterr()
+        assert len(out) == 0
+
+
+def test_verbose(capfd, hello_world_f90, monkeypatch):
+    """Increase verbosity
+
+    CLI :: --verbose
+    """
+    ipath = Path(hello_world_f90)
+    monkeypatch.setattr(sys, "argv", f'f2py -m blah {ipath} --verbose'.split())
+
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        out, _ = capfd.readouterr()
+        assert "analyzeline" in out
+
+
+def test_version(capfd, monkeypatch):
+    """Ensure version
+
+    CLI :: -v
+    """
+    monkeypatch.setattr(sys, "argv", 'f2py -v'.split())
+    # TODO: f2py2e should not call sys.exit() after printing the version
+    with pytest.raises(SystemExit):
+        f2pycli()
+        out, _ = capfd.readouterr()
+        import numpy as np
+        assert np.__version__ == out.strip()
+
+
+@pytest.mark.xfail(reason="Consistently fails on CI.")
+def test_npdistop(hello_world_f90, monkeypatch):
+    """
+    CLI :: -c
+    """
+    ipath = Path(hello_world_f90)
+    monkeypatch.setattr(sys, "argv", f'f2py -m blah {ipath} -c'.split())
+
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        cmd_run = shlex.split("python -c \"import blah; blah.hi()\"")
+        rout = subprocess.run(cmd_run, capture_output=True, encoding='UTF-8')
+        eout = ' Hello World\n'
+        assert rout.stdout == eout
+
+
+# Numpy distutils flags
+# TODO: These should be tested separately
+
+
+def test_npd_fcompiler():
+    """
+    CLI :: -c --fcompiler
+    """
+    # TODO: populate
+    pass
+
+
+def test_npd_compiler():
+    """
+    CLI :: -c --compiler
+    """
+    # TODO: populate
+    pass
+
+
+def test_npd_help_fcompiler():
+    """
+    CLI :: -c --help-fcompiler
+    """
+    # TODO: populate
+    pass
+
+
+def test_npd_f77exec():
+    """
+    CLI :: -c --f77exec
+    """
+    # TODO: populate
+    pass
+
+
+def test_npd_f90exec():
+    """
+    CLI :: -c --f90exec
+    """
+    # TODO: populate
+    pass
+
+
+def test_npd_f77flags():
+    """
+    CLI :: -c --f77flags
+    """
+    # TODO: populate
+    pass
+
+
+def test_npd_f90flags():
+    """
+    CLI :: -c --f90flags
+    """
+    # TODO: populate
+    pass
+
+
+def test_npd_opt():
+    """
+    CLI :: -c --opt
+    """
+    # TODO: populate
+    pass
+
+
+def test_npd_arch():
+    """
+    CLI :: -c --arch
+    """
+    # TODO: populate
+    pass
+
+
+def test_npd_noopt():
+    """
+    CLI :: -c --noopt
+    """
+    # TODO: populate
+    pass
+
+
+def test_npd_noarch():
+    """
+    CLI :: -c --noarch
+    """
+    # TODO: populate
+    pass
+
+
+def test_npd_debug():
+    """
+    CLI :: -c --debug
+    """
+    # TODO: populate
+    pass
+
+
+def test_npd_link_auto():
+    """
+    CLI :: -c --link-
+    """
+    # TODO: populate
+    pass
+
+
+def test_npd_lib():
+    """
+    CLI :: -c -L/path/to/lib/ -l
+    """
+    # TODO: populate
+    pass
+
+
+def test_npd_define():
+    """
+    CLI :: -D
+    """
+    # TODO: populate
+    pass
+
+
+def test_npd_undefine():
+    """
+    CLI :: -U
+    """
+    # TODO: populate
+    pass
+
+
+def test_npd_incl():
+    """
+    CLI :: -I/path/to/include/
+    """
+    # TODO: populate
+    pass
+
+
+def test_npd_linker():
+    """
+    CLI :: .o .so .a
+    """
+    # TODO: populate
+    pass
diff --git a/numpy/f2py/tests/test_kind.py b/numpy/f2py/tests/test_kind.py
index a7e2b28ed37c..f0cb61fb6ce3 100644
--- a/numpy/f2py/tests/test_kind.py
+++ b/numpy/f2py/tests/test_kind.py
@@ -1,32 +1,26 @@
 import os
 import pytest
 
-from numpy.testing import assert_
 from numpy.f2py.crackfortran import (
     _selected_int_kind_func as selected_int_kind,
-    _selected_real_kind_func as selected_real_kind
-    )
+    _selected_real_kind_func as selected_real_kind,
+)
 from . import util
 
 
-def _path(*a):
-    return os.path.join(*((os.path.dirname(__file__),) + a))
-
-
 class TestKind(util.F2PyTest):
-    sources = [_path('src', 'kind', 'foo.f90')]
+    sources = [util.getpath("tests", "src", "kind", "foo.f90")]
 
-    @pytest.mark.slow
     def test_all(self):
         selectedrealkind = self.module.selectedrealkind
         selectedintkind = self.module.selectedintkind
 
         for i in range(40):
-            assert_(selectedintkind(i) in [selected_int_kind(i), -1],
-                    'selectedintkind(%s): expected %r but got %r' %
-                    (i, selected_int_kind(i), selectedintkind(i)))
+            assert selectedintkind(i) == selected_int_kind(
+                i
+            ), f"selectedintkind({i}): expected {selected_int_kind(i)!r} but got {selectedintkind(i)!r}"
 
         for i in range(20):
-            assert_(selectedrealkind(i) in [selected_real_kind(i), -1],
-                    'selectedrealkind(%s): expected %r but got %r' %
-                    (i, selected_real_kind(i), selectedrealkind(i)))
+            assert selectedrealkind(i) == selected_real_kind(
+                i
+            ), f"selectedrealkind({i}): expected {selected_real_kind(i)!r} but got {selectedrealkind(i)!r}"
diff --git a/numpy/f2py/tests/test_mixed.py b/numpy/f2py/tests/test_mixed.py
index 04266ca5b190..80653b7d2d77 100644
--- a/numpy/f2py/tests/test_mixed.py
+++ b/numpy/f2py/tests/test_mixed.py
@@ -2,23 +2,21 @@
 import textwrap
 import pytest
 
-from numpy.testing import assert_, assert_equal, IS_PYPY
+from numpy.testing import IS_PYPY
 from . import util
 
 
-def _path(*a):
-    return os.path.join(*((os.path.dirname(__file__),) + a))
-
-
 class TestMixed(util.F2PyTest):
-    sources = [_path('src', 'mixed', 'foo.f'),
-               _path('src', 'mixed', 'foo_fixed.f90'),
-               _path('src', 'mixed', 'foo_free.f90')]
+    sources = [
+        util.getpath("tests", "src", "mixed", "foo.f"),
+        util.getpath("tests", "src", "mixed", "foo_fixed.f90"),
+        util.getpath("tests", "src", "mixed", "foo_free.f90"),
+    ]
 
     def test_all(self):
-        assert_(self.module.bar11() == 11)
-        assert_(self.module.foo_fixed.bar12() == 12)
-        assert_(self.module.foo_free.bar13() == 13)
+        assert self.module.bar11() == 11
+        assert self.module.foo_fixed.bar12() == 12
+        assert self.module.foo_free.bar13() == 13
 
     @pytest.mark.xfail(IS_PYPY,
                        reason="PyPy cannot modify tp_doc after PyType_Ready")
@@ -32,4 +30,4 @@ def test_docstring(self):
         -------
         a : int
         """)
-        assert_equal(self.module.bar11.__doc__, expected)
+        assert self.module.bar11.__doc__ == expected
diff --git a/numpy/f2py/tests/test_module_doc.py b/numpy/f2py/tests/test_module_doc.py
index 4b9555cee1fc..28822d405cc0 100644
--- a/numpy/f2py/tests/test_module_doc.py
+++ b/numpy/f2py/tests/test_module_doc.py
@@ -4,27 +4,24 @@
 import textwrap
 
 from . import util
-from numpy.testing import assert_equal, IS_PYPY
-
-
-def _path(*a):
-    return os.path.join(*((os.path.dirname(__file__),) + a))
+from numpy.testing import IS_PYPY
 
 
 class TestModuleDocString(util.F2PyTest):
-    sources = [_path('src', 'module_data', 'module_data_docstring.f90')]
+    sources = [
+        util.getpath("tests", "src", "module_data",
+                     "module_data_docstring.f90")
+    ]
 
-    @pytest.mark.skipif(sys.platform=='win32',
-                        reason='Fails with MinGW64 Gfortran (Issue #9673)')
+    @pytest.mark.skipif(sys.platform == "win32",
+                        reason="Fails with MinGW64 Gfortran (Issue #9673)")
     @pytest.mark.xfail(IS_PYPY,
                        reason="PyPy cannot modify tp_doc after PyType_Ready")
     def test_module_docstring(self):
-        assert_equal(self.module.mod.__doc__,
-                     textwrap.dedent('''\
+        assert self.module.mod.__doc__ == textwrap.dedent("""\
                      i : 'i'-scalar
                      x : 'i'-array(4)
                      a : 'f'-array(2,3)
                      b : 'f'-array(-1,-1), not allocated\x00
                      foo()\n
-                     Wrapper for ``foo``.\n\n''')
-                     )
+                     Wrapper for ``foo``.\n\n""")
diff --git a/numpy/f2py/tests/test_parameter.py b/numpy/f2py/tests/test_parameter.py
index b6182716987b..2f620eaa0722 100644
--- a/numpy/f2py/tests/test_parameter.py
+++ b/numpy/f2py/tests/test_parameter.py
@@ -2,115 +2,111 @@
 import pytest
 
 import numpy as np
-from numpy.testing import assert_raises, assert_equal
 
 from . import util
 
 
-def _path(*a):
-    return os.path.join(*((os.path.dirname(__file__),) + a))
-
-
 class TestParameters(util.F2PyTest):
     # Check that intent(in out) translates as intent(inout)
-    sources = [_path('src', 'parameter', 'constant_real.f90'),
-               _path('src', 'parameter', 'constant_integer.f90'),
-               _path('src', 'parameter', 'constant_both.f90'),
-               _path('src', 'parameter', 'constant_compound.f90'),
-               _path('src', 'parameter', 'constant_non_compound.f90'),
+    sources = [
+        util.getpath("tests", "src", "parameter", "constant_real.f90"),
+        util.getpath("tests", "src", "parameter", "constant_integer.f90"),
+        util.getpath("tests", "src", "parameter", "constant_both.f90"),
+        util.getpath("tests", "src", "parameter", "constant_compound.f90"),
+        util.getpath("tests", "src", "parameter", "constant_non_compound.f90"),
     ]
 
     @pytest.mark.slow
     def test_constant_real_single(self):
         # non-contiguous should raise error
         x = np.arange(6, dtype=np.float32)[::2]
-        assert_raises(ValueError, self.module.foo_single, x)
+        pytest.raises(ValueError, self.module.foo_single, x)
 
         # check values with contiguous array
         x = np.arange(3, dtype=np.float32)
         self.module.foo_single(x)
-        assert_equal(x, [0 + 1 + 2*3, 1, 2])
+        assert np.allclose(x, [0 + 1 + 2 * 3, 1, 2])
 
     @pytest.mark.slow
     def test_constant_real_double(self):
         # non-contiguous should raise error
         x = np.arange(6, dtype=np.float64)[::2]
-        assert_raises(ValueError, self.module.foo_double, x)
+        pytest.raises(ValueError, self.module.foo_double, x)
 
         # check values with contiguous array
         x = np.arange(3, dtype=np.float64)
         self.module.foo_double(x)
-        assert_equal(x, [0 + 1 + 2*3, 1, 2])
+        assert np.allclose(x, [0 + 1 + 2 * 3, 1, 2])
 
     @pytest.mark.slow
     def test_constant_compound_int(self):
         # non-contiguous should raise error
         x = np.arange(6, dtype=np.int32)[::2]
-        assert_raises(ValueError, self.module.foo_compound_int, x)
+        pytest.raises(ValueError, self.module.foo_compound_int, x)
 
         # check values with contiguous array
         x = np.arange(3, dtype=np.int32)
         self.module.foo_compound_int(x)
-        assert_equal(x, [0 + 1 + 2*6, 1, 2])
+        assert np.allclose(x, [0 + 1 + 2 * 6, 1, 2])
 
     @pytest.mark.slow
     def test_constant_non_compound_int(self):
         # check values
         x = np.arange(4, dtype=np.int32)
         self.module.foo_non_compound_int(x)
-        assert_equal(x, [0 + 1 + 2 + 3*4, 1, 2, 3])
+        assert np.allclose(x, [0 + 1 + 2 + 3 * 4, 1, 2, 3])
 
     @pytest.mark.slow
     def test_constant_integer_int(self):
         # non-contiguous should raise error
         x = np.arange(6, dtype=np.int32)[::2]
-        assert_raises(ValueError, self.module.foo_int, x)
+        pytest.raises(ValueError, self.module.foo_int, x)
 
         # check values with contiguous array
         x = np.arange(3, dtype=np.int32)
         self.module.foo_int(x)
-        assert_equal(x, [0 + 1 + 2*3, 1, 2])
+        assert np.allclose(x, [0 + 1 + 2 * 3, 1, 2])
 
     @pytest.mark.slow
     def test_constant_integer_long(self):
         # non-contiguous should raise error
         x = np.arange(6, dtype=np.int64)[::2]
-        assert_raises(ValueError, self.module.foo_long, x)
+        pytest.raises(ValueError, self.module.foo_long, x)
 
         # check values with contiguous array
         x = np.arange(3, dtype=np.int64)
         self.module.foo_long(x)
-        assert_equal(x, [0 + 1 + 2*3, 1, 2])
+        assert np.allclose(x, [0 + 1 + 2 * 3, 1, 2])
 
     @pytest.mark.slow
     def test_constant_both(self):
         # non-contiguous should raise error
         x = np.arange(6, dtype=np.float64)[::2]
-        assert_raises(ValueError, self.module.foo, x)
+        pytest.raises(ValueError, self.module.foo, x)
 
         # check values with contiguous array
         x = np.arange(3, dtype=np.float64)
         self.module.foo(x)
-        assert_equal(x, [0 + 1*3*3 + 2*3*3, 1*3, 2*3])
+        assert np.allclose(x, [0 + 1 * 3 * 3 + 2 * 3 * 3, 1 * 3, 2 * 3])
 
     @pytest.mark.slow
     def test_constant_no(self):
         # non-contiguous should raise error
         x = np.arange(6, dtype=np.float64)[::2]
-        assert_raises(ValueError, self.module.foo_no, x)
+        pytest.raises(ValueError, self.module.foo_no, x)
 
         # check values with contiguous array
         x = np.arange(3, dtype=np.float64)
         self.module.foo_no(x)
-        assert_equal(x, [0 + 1*3*3 + 2*3*3, 1*3, 2*3])
+        assert np.allclose(x, [0 + 1 * 3 * 3 + 2 * 3 * 3, 1 * 3, 2 * 3])
 
     @pytest.mark.slow
     def test_constant_sum(self):
         # non-contiguous should raise error
         x = np.arange(6, dtype=np.float64)[::2]
-        assert_raises(ValueError, self.module.foo_sum, x)
+        pytest.raises(ValueError, self.module.foo_sum, x)
 
         # check values with contiguous array
         x = np.arange(3, dtype=np.float64)
         self.module.foo_sum(x)
-        assert_equal(x, [0 + 1*3*3 + 2*3*3, 1*3, 2*3])
+        assert np.allclose(x, [0 + 1 * 3 * 3 + 2 * 3 * 3, 1 * 3, 2 * 3])
diff --git a/numpy/f2py/tests/test_quoted_character.py b/numpy/f2py/tests/test_quoted_character.py
index 20c77666c59a..82671cd8e72f 100644
--- a/numpy/f2py/tests/test_quoted_character.py
+++ b/numpy/f2py/tests/test_quoted_character.py
@@ -4,29 +4,13 @@
 import sys
 import pytest
 
-from numpy.testing import assert_equal
 from . import util
 
 
 class TestQuotedCharacter(util.F2PyTest):
-    code = """
-      SUBROUTINE FOO(OUT1, OUT2, OUT3, OUT4, OUT5, OUT6)
-      CHARACTER SINGLE, DOUBLE, SEMICOL, EXCLA, OPENPAR, CLOSEPAR
-      PARAMETER (SINGLE="'", DOUBLE='"', SEMICOL=';', EXCLA="!",
-     1           OPENPAR="(", CLOSEPAR=")")
-      CHARACTER OUT1, OUT2, OUT3, OUT4, OUT5, OUT6
-Cf2py intent(out) OUT1, OUT2, OUT3, OUT4, OUT5, OUT6
-      OUT1 = SINGLE
-      OUT2 = DOUBLE
-      OUT3 = SEMICOL
-      OUT4 = EXCLA
-      OUT5 = OPENPAR
-      OUT6 = CLOSEPAR
-      RETURN
-      END
-    """
+    sources = [util.getpath("tests", "src", "quoted_character", "foo.f")]
 
-    @pytest.mark.skipif(sys.platform=='win32',
-                        reason='Fails with MinGW64 Gfortran (Issue #9673)')
+    @pytest.mark.skipif(sys.platform == "win32",
+                        reason="Fails with MinGW64 Gfortran (Issue #9673)")
     def test_quoted_character(self):
-        assert_equal(self.module.foo(), (b"'", b'"', b';', b'!', b'(', b')'))
+        assert self.module.foo() == (b"'", b'"', b";", b"!", b"(", b")")
diff --git a/numpy/f2py/tests/test_regression.py b/numpy/f2py/tests/test_regression.py
index b91499e4adb3..044f952f2268 100644
--- a/numpy/f2py/tests/test_regression.py
+++ b/numpy/f2py/tests/test_regression.py
@@ -2,54 +2,65 @@
 import pytest
 
 import numpy as np
-from numpy.testing import assert_, assert_raises, assert_equal, assert_string_equal
 
 from . import util
 
 
-def _path(*a):
-    return os.path.join(*((os.path.dirname(__file__),) + a))
-
-
 class TestIntentInOut(util.F2PyTest):
     # Check that intent(in out) translates as intent(inout)
-    sources = [_path('src', 'regression', 'inout.f90')]
+    sources = [util.getpath("tests", "src", "regression", "inout.f90")]
 
     @pytest.mark.slow
     def test_inout(self):
         # non-contiguous should raise error
         x = np.arange(6, dtype=np.float32)[::2]
-        assert_raises(ValueError, self.module.foo, x)
+        pytest.raises(ValueError, self.module.foo, x)
 
         # check values with contiguous array
         x = np.arange(3, dtype=np.float32)
         self.module.foo(x)
-        assert_equal(x, [3, 1, 2])
+        assert np.allclose(x, [3, 1, 2])
+
+
+class TestNegativeBounds(util.F2PyTest):
+    # Check that negative bounds work correctly
+    sources = [util.getpath("tests", "src", "negative_bounds", "issue_20853.f90")]
+
+    @pytest.mark.slow
+    def test_negbound(self):
+        xvec = np.arange(12)
+        xlow = -6
+        xhigh = 4
+        # Calculate the upper bound,
+        # Keeping the 1 index in mind
+        def ubound(xl, xh):
+            return xh - xl + 1
+        rval = self.module.foo(is_=xlow, ie_=xhigh,
+                        arr=xvec[:ubound(xlow, xhigh)])
+        expval = np.arange(11, dtype = np.float32)
+        assert np.allclose(rval, expval)
 
 
 class TestNumpyVersionAttribute(util.F2PyTest):
     # Check that th attribute __f2py_numpy_version__ is present
     # in the compiled module and that has the value np.__version__.
-    sources = [_path('src', 'regression', 'inout.f90')]
+    sources = [util.getpath("tests", "src", "regression", "inout.f90")]
 
     @pytest.mark.slow
     def test_numpy_version_attribute(self):
 
         # Check that self.module has an attribute named "__f2py_numpy_version__"
-        assert_(hasattr(self.module, "__f2py_numpy_version__"),
-                msg="Fortran module does not have __f2py_numpy_version__")
+        assert hasattr(self.module, "__f2py_numpy_version__")
 
         # Check that the attribute __f2py_numpy_version__ is a string
-        assert_(isinstance(self.module.__f2py_numpy_version__, str),
-                msg="__f2py_numpy_version__ is not a string")
+        assert isinstance(self.module.__f2py_numpy_version__, str)
 
         # Check that __f2py_numpy_version__ has the value numpy.__version__
-        assert_string_equal(np.__version__, self.module.__f2py_numpy_version__)
+        assert np.__version__ == self.module.__f2py_numpy_version__
 
 
 def test_include_path():
     incdir = np.f2py.get_include()
     fnames_in_dir = os.listdir(incdir)
-    for fname in ('fortranobject.c', 'fortranobject.h'):
+    for fname in ("fortranobject.c", "fortranobject.h"):
         assert fname in fnames_in_dir
-
diff --git a/numpy/f2py/tests/test_return_character.py b/numpy/f2py/tests/test_return_character.py
index 2c999ed0b071..36c1f10f4191 100644
--- a/numpy/f2py/tests/test_return_character.py
+++ b/numpy/f2py/tests/test_return_character.py
@@ -1,145 +1,45 @@
 import pytest
 
 from numpy import array
-from numpy.testing import assert_
 from . import util
 import platform
-IS_S390X = platform.machine() == 's390x'
 
+IS_S390X = platform.machine() == "s390x"
 
-class TestReturnCharacter(util.F2PyTest):
 
+class TestReturnCharacter(util.F2PyTest):
     def check_function(self, t, tname):
-        if tname in ['t0', 't1', 's0', 's1']:
-            assert_(t(23) == b'2')
-            r = t('ab')
-            assert_(r == b'a', repr(r))
-            r = t(array('ab'))
-            assert_(r == b'a', repr(r))
-            r = t(array(77, 'u1'))
-            assert_(r == b'M', repr(r))
-            #assert_(_raises(ValueError, t, array([77,87])))
-            #assert_(_raises(ValueError, t, array(77)))
-        elif tname in ['ts', 'ss']:
-            assert_(t(23) == b'23', repr(t(23)))
-            assert_(t('123456789abcdef') == b'123456789a')
-        elif tname in ['t5', 's5']:
-            assert_(t(23) == b'23', repr(t(23)))
-            assert_(t('ab') == b'ab', repr(t('ab')))
-            assert_(t('123456789abcdef') == b'12345')
+        if tname in ["t0", "t1", "s0", "s1"]:
+            assert t("23") == b"2"
+            r = t("ab")
+            assert r == b"a"
+            r = t(array("ab"))
+            assert r == b"a"
+            r = t(array(77, "u1"))
+            assert r == b"M"
+        elif tname in ["ts", "ss"]:
+            assert t(23) == b"23"
+            assert t("123456789abcdef") == b"123456789a"
+        elif tname in ["t5", "s5"]:
+            assert t(23) == b"23"
+            assert t("ab") == b"ab"
+            assert t("123456789abcdef") == b"12345"
         else:
             raise NotImplementedError
 
 
-class TestF77ReturnCharacter(TestReturnCharacter):
-    code = """
-       function t0(value)
-         character value
-         character t0
-         t0 = value
-       end
-       function t1(value)
-         character*1 value
-         character*1 t1
-         t1 = value
-       end
-       function t5(value)
-         character*5 value
-         character*5 t5
-         t5 = value
-       end
-       function ts(value)
-         character*(*) value
-         character*(*) ts
-         ts = value
-       end
-
-       subroutine s0(t0,value)
-         character value
-         character t0
-cf2py    intent(out) t0
-         t0 = value
-       end
-       subroutine s1(t1,value)
-         character*1 value
-         character*1 t1
-cf2py    intent(out) t1
-         t1 = value
-       end
-       subroutine s5(t5,value)
-         character*5 value
-         character*5 t5
-cf2py    intent(out) t5
-         t5 = value
-       end
-       subroutine ss(ts,value)
-         character*(*) value
-         character*10 ts
-cf2py    intent(out) ts
-         ts = value
-       end
-    """
+class TestFReturnCharacter(TestReturnCharacter):
+    sources = [
+        util.getpath("tests", "src", "return_character", "foo77.f"),
+        util.getpath("tests", "src", "return_character", "foo90.f90"),
+    ]
 
     @pytest.mark.xfail(IS_S390X, reason="callback returns ' '")
-    @pytest.mark.parametrize('name', 't0,t1,t5,s0,s1,s5,ss'.split(','))
-    def test_all(self, name):
+    @pytest.mark.parametrize("name", "t0,t1,t5,s0,s1,s5,ss".split(","))
+    def test_all_f77(self, name):
         self.check_function(getattr(self.module, name), name)
 
-
-class TestF90ReturnCharacter(TestReturnCharacter):
-    suffix = ".f90"
-    code = """
-module f90_return_char
-  contains
-       function t0(value)
-         character :: value
-         character :: t0
-         t0 = value
-       end function t0
-       function t1(value)
-         character(len=1) :: value
-         character(len=1) :: t1
-         t1 = value
-       end function t1
-       function t5(value)
-         character(len=5) :: value
-         character(len=5) :: t5
-         t5 = value
-       end function t5
-       function ts(value)
-         character(len=*) :: value
-         character(len=10) :: ts
-         ts = value
-       end function ts
-
-       subroutine s0(t0,value)
-         character :: value
-         character :: t0
-!f2py    intent(out) t0
-         t0 = value
-       end subroutine s0
-       subroutine s1(t1,value)
-         character(len=1) :: value
-         character(len=1) :: t1
-!f2py    intent(out) t1
-         t1 = value
-       end subroutine s1
-       subroutine s5(t5,value)
-         character(len=5) :: value
-         character(len=5) :: t5
-!f2py    intent(out) t5
-         t5 = value
-       end subroutine s5
-       subroutine ss(ts,value)
-         character(len=*) :: value
-         character(len=10) :: ts
-!f2py    intent(out) ts
-         ts = value
-       end subroutine ss
-end module f90_return_char
-    """
-
     @pytest.mark.xfail(IS_S390X, reason="callback returns ' '")
-    @pytest.mark.parametrize('name', 't0,t1,t5,ts,s0,s1,s5,ss'.split(','))
-    def test_all(self, name):
+    @pytest.mark.parametrize("name", "t0,t1,t5,ts,s0,s1,s5,ss".split(","))
+    def test_all_f90(self, name):
         self.check_function(getattr(self.module.f90_return_char, name), name)
diff --git a/numpy/f2py/tests/test_return_complex.py b/numpy/f2py/tests/test_return_complex.py
index 3d2e2b94f27a..9df79632dd40 100644
--- a/numpy/f2py/tests/test_return_complex.py
+++ b/numpy/f2py/tests/test_return_complex.py
@@ -1,163 +1,65 @@
 import pytest
 
 from numpy import array
-from numpy.testing import assert_, assert_raises
 from . import util
 
 
 class TestReturnComplex(util.F2PyTest):
-
     def check_function(self, t, tname):
-        if tname in ['t0', 't8', 's0', 's8']:
+        if tname in ["t0", "t8", "s0", "s8"]:
             err = 1e-5
         else:
             err = 0.0
-        assert_(abs(t(234j) - 234.0j) <= err)
-        assert_(abs(t(234.6) - 234.6) <= err)
-        assert_(abs(t(234) - 234.0) <= err)
-        assert_(abs(t(234.6 + 3j) - (234.6 + 3j)) <= err)
-        #assert_( abs(t('234')-234.)<=err)
-        #assert_( abs(t('234.6')-234.6)<=err)
-        assert_(abs(t(-234) + 234.) <= err)
-        assert_(abs(t([234]) - 234.) <= err)
-        assert_(abs(t((234,)) - 234.) <= err)
-        assert_(abs(t(array(234)) - 234.) <= err)
-        assert_(abs(t(array(23 + 4j, 'F')) - (23 + 4j)) <= err)
-        assert_(abs(t(array([234])) - 234.) <= err)
-        assert_(abs(t(array([[234]])) - 234.) <= err)
-        assert_(abs(t(array([234], 'b')) + 22.) <= err)
-        assert_(abs(t(array([234], 'h')) - 234.) <= err)
-        assert_(abs(t(array([234], 'i')) - 234.) <= err)
-        assert_(abs(t(array([234], 'l')) - 234.) <= err)
-        assert_(abs(t(array([234], 'q')) - 234.) <= err)
-        assert_(abs(t(array([234], 'f')) - 234.) <= err)
-        assert_(abs(t(array([234], 'd')) - 234.) <= err)
-        assert_(abs(t(array([234 + 3j], 'F')) - (234 + 3j)) <= err)
-        assert_(abs(t(array([234], 'D')) - 234.) <= err)
-
-        #assert_raises(TypeError, t, array([234], 'a1'))
-        assert_raises(TypeError, t, 'abc')
-
-        assert_raises(IndexError, t, [])
-        assert_raises(IndexError, t, ())
-
-        assert_raises(TypeError, t, t)
-        assert_raises(TypeError, t, {})
+        assert abs(t(234j) - 234.0j) <= err
+        assert abs(t(234.6) - 234.6) <= err
+        assert abs(t(234) - 234.0) <= err
+        assert abs(t(234.6 + 3j) - (234.6 + 3j)) <= err
+        # assert abs(t('234')-234.)<=err
+        # assert abs(t('234.6')-234.6)<=err
+        assert abs(t(-234) + 234.0) <= err
+        assert abs(t([234]) - 234.0) <= err
+        assert abs(t((234, )) - 234.0) <= err
+        assert abs(t(array(234)) - 234.0) <= err
+        assert abs(t(array(23 + 4j, "F")) - (23 + 4j)) <= err
+        assert abs(t(array([234])) - 234.0) <= err
+        assert abs(t(array([[234]])) - 234.0) <= err
+        assert abs(t(array([234]).astype("b")) + 22.0) <= err
+        assert abs(t(array([234], "h")) - 234.0) <= err
+        assert abs(t(array([234], "i")) - 234.0) <= err
+        assert abs(t(array([234], "l")) - 234.0) <= err
+        assert abs(t(array([234], "q")) - 234.0) <= err
+        assert abs(t(array([234], "f")) - 234.0) <= err
+        assert abs(t(array([234], "d")) - 234.0) <= err
+        assert abs(t(array([234 + 3j], "F")) - (234 + 3j)) <= err
+        assert abs(t(array([234], "D")) - 234.0) <= err
+
+        # pytest.raises(TypeError, t, array([234], 'a1'))
+        pytest.raises(TypeError, t, "abc")
+
+        pytest.raises(IndexError, t, [])
+        pytest.raises(IndexError, t, ())
+
+        pytest.raises(TypeError, t, t)
+        pytest.raises(TypeError, t, {})
 
         try:
-            r = t(10 ** 400)
-            assert_(repr(r) in ['(inf+0j)', '(Infinity+0j)'], repr(r))
+            r = t(10**400)
+            assert repr(r) in ["(inf+0j)", "(Infinity+0j)"]
         except OverflowError:
             pass
 
 
-class TestF77ReturnComplex(TestReturnComplex):
-    code = """
-       function t0(value)
-         complex value
-         complex t0
-         t0 = value
-       end
-       function t8(value)
-         complex*8 value
-         complex*8 t8
-         t8 = value
-       end
-       function t16(value)
-         complex*16 value
-         complex*16 t16
-         t16 = value
-       end
-       function td(value)
-         double complex value
-         double complex td
-         td = value
-       end
+class TestFReturnComplex(TestReturnComplex):
+    sources = [
+        util.getpath("tests", "src", "return_complex", "foo77.f"),
+        util.getpath("tests", "src", "return_complex", "foo90.f90"),
+    ]
 
-       subroutine s0(t0,value)
-         complex value
-         complex t0
-cf2py    intent(out) t0
-         t0 = value
-       end
-       subroutine s8(t8,value)
-         complex*8 value
-         complex*8 t8
-cf2py    intent(out) t8
-         t8 = value
-       end
-       subroutine s16(t16,value)
-         complex*16 value
-         complex*16 t16
-cf2py    intent(out) t16
-         t16 = value
-       end
-       subroutine sd(td,value)
-         double complex value
-         double complex td
-cf2py    intent(out) td
-         td = value
-       end
-    """
-
-    @pytest.mark.parametrize('name', 't0,t8,t16,td,s0,s8,s16,sd'.split(','))
-    def test_all(self, name):
+    @pytest.mark.parametrize("name", "t0,t8,t16,td,s0,s8,s16,sd".split(","))
+    def test_all_f77(self, name):
         self.check_function(getattr(self.module, name), name)
 
-
-class TestF90ReturnComplex(TestReturnComplex):
-    suffix = ".f90"
-    code = """
-module f90_return_complex
-  contains
-       function t0(value)
-         complex :: value
-         complex :: t0
-         t0 = value
-       end function t0
-       function t8(value)
-         complex(kind=4) :: value
-         complex(kind=4) :: t8
-         t8 = value
-       end function t8
-       function t16(value)
-         complex(kind=8) :: value
-         complex(kind=8) :: t16
-         t16 = value
-       end function t16
-       function td(value)
-         double complex :: value
-         double complex :: td
-         td = value
-       end function td
-
-       subroutine s0(t0,value)
-         complex :: value
-         complex :: t0
-!f2py    intent(out) t0
-         t0 = value
-       end subroutine s0
-       subroutine s8(t8,value)
-         complex(kind=4) :: value
-         complex(kind=4) :: t8
-!f2py    intent(out) t8
-         t8 = value
-       end subroutine s8
-       subroutine s16(t16,value)
-         complex(kind=8) :: value
-         complex(kind=8) :: t16
-!f2py    intent(out) t16
-         t16 = value
-       end subroutine s16
-       subroutine sd(td,value)
-         double complex :: value
-         double complex :: td
-!f2py    intent(out) td
-         td = value
-       end subroutine sd
-end module f90_return_complex
-    """
-
-    @pytest.mark.parametrize('name', 't0,t8,t16,td,s0,s8,s16,sd'.split(','))
-    def test_all(self, name):
-        self.check_function(getattr(self.module.f90_return_complex, name), name)
+    @pytest.mark.parametrize("name", "t0,t8,t16,td,s0,s8,s16,sd".split(","))
+    def test_all_f90(self, name):
+        self.check_function(getattr(self.module.f90_return_complex, name),
+                            name)
diff --git a/numpy/f2py/tests/test_return_integer.py b/numpy/f2py/tests/test_return_integer.py
index 0a8121dc14b8..a43c677fd0af 100644
--- a/numpy/f2py/tests/test_return_integer.py
+++ b/numpy/f2py/tests/test_return_integer.py
@@ -1,175 +1,55 @@
 import pytest
 
 from numpy import array
-from numpy.testing import assert_, assert_raises
 from . import util
 
 
 class TestReturnInteger(util.F2PyTest):
-
     def check_function(self, t, tname):
-        assert_(t(123) == 123, repr(t(123)))
-        assert_(t(123.6) == 123)
-        assert_(t('123') == 123)
-        assert_(t(-123) == -123)
-        assert_(t([123]) == 123)
-        assert_(t((123,)) == 123)
-        assert_(t(array(123)) == 123)
-        assert_(t(array([123])) == 123)
-        assert_(t(array([[123]])) == 123)
-        assert_(t(array([123], 'b')) == 123)
-        assert_(t(array([123], 'h')) == 123)
-        assert_(t(array([123], 'i')) == 123)
-        assert_(t(array([123], 'l')) == 123)
-        assert_(t(array([123], 'B')) == 123)
-        assert_(t(array([123], 'f')) == 123)
-        assert_(t(array([123], 'd')) == 123)
-
-        #assert_raises(ValueError, t, array([123],'S3'))
-        assert_raises(ValueError, t, 'abc')
-
-        assert_raises(IndexError, t, [])
-        assert_raises(IndexError, t, ())
-
-        assert_raises(Exception, t, t)
-        assert_raises(Exception, t, {})
-
-        if tname in ['t8', 's8']:
-            assert_raises(OverflowError, t, 100000000000000000000000)
-            assert_raises(OverflowError, t, 10000000011111111111111.23)
-
-
-class TestF77ReturnInteger(TestReturnInteger):
-    code = """
-       function t0(value)
-         integer value
-         integer t0
-         t0 = value
-       end
-       function t1(value)
-         integer*1 value
-         integer*1 t1
-         t1 = value
-       end
-       function t2(value)
-         integer*2 value
-         integer*2 t2
-         t2 = value
-       end
-       function t4(value)
-         integer*4 value
-         integer*4 t4
-         t4 = value
-       end
-       function t8(value)
-         integer*8 value
-         integer*8 t8
-         t8 = value
-       end
-
-       subroutine s0(t0,value)
-         integer value
-         integer t0
-cf2py    intent(out) t0
-         t0 = value
-       end
-       subroutine s1(t1,value)
-         integer*1 value
-         integer*1 t1
-cf2py    intent(out) t1
-         t1 = value
-       end
-       subroutine s2(t2,value)
-         integer*2 value
-         integer*2 t2
-cf2py    intent(out) t2
-         t2 = value
-       end
-       subroutine s4(t4,value)
-         integer*4 value
-         integer*4 t4
-cf2py    intent(out) t4
-         t4 = value
-       end
-       subroutine s8(t8,value)
-         integer*8 value
-         integer*8 t8
-cf2py    intent(out) t8
-         t8 = value
-       end
-    """
-
-    @pytest.mark.parametrize('name',
-                             't0,t1,t2,t4,t8,s0,s1,s2,s4,s8'.split(','))
-    def test_all(self, name):
+        assert t(123) == 123
+        assert t(123.6) == 123
+        assert t("123") == 123
+        assert t(-123) == -123
+        assert t([123]) == 123
+        assert t((123, )) == 123
+        assert t(array(123)) == 123
+        assert t(array([123])) == 123
+        assert t(array([[123]])) == 123
+        assert t(array([123], "b")) == 123
+        assert t(array([123], "h")) == 123
+        assert t(array([123], "i")) == 123
+        assert t(array([123], "l")) == 123
+        assert t(array([123], "B")) == 123
+        assert t(array([123], "f")) == 123
+        assert t(array([123], "d")) == 123
+
+        # pytest.raises(ValueError, t, array([123],'S3'))
+        pytest.raises(ValueError, t, "abc")
+
+        pytest.raises(IndexError, t, [])
+        pytest.raises(IndexError, t, ())
+
+        pytest.raises(Exception, t, t)
+        pytest.raises(Exception, t, {})
+
+        if tname in ["t8", "s8"]:
+            pytest.raises(OverflowError, t, 100000000000000000000000)
+            pytest.raises(OverflowError, t, 10000000011111111111111.23)
+
+
+class TestFReturnInteger(TestReturnInteger):
+    sources = [
+        util.getpath("tests", "src", "return_integer", "foo77.f"),
+        util.getpath("tests", "src", "return_integer", "foo90.f90"),
+    ]
+
+    @pytest.mark.parametrize("name",
+                             "t0,t1,t2,t4,t8,s0,s1,s2,s4,s8".split(","))
+    def test_all_f77(self, name):
         self.check_function(getattr(self.module, name), name)
 
-
-class TestF90ReturnInteger(TestReturnInteger):
-    suffix = ".f90"
-    code = """
-module f90_return_integer
-  contains
-       function t0(value)
-         integer :: value
-         integer :: t0
-         t0 = value
-       end function t0
-       function t1(value)
-         integer(kind=1) :: value
-         integer(kind=1) :: t1
-         t1 = value
-       end function t1
-       function t2(value)
-         integer(kind=2) :: value
-         integer(kind=2) :: t2
-         t2 = value
-       end function t2
-       function t4(value)
-         integer(kind=4) :: value
-         integer(kind=4) :: t4
-         t4 = value
-       end function t4
-       function t8(value)
-         integer(kind=8) :: value
-         integer(kind=8) :: t8
-         t8 = value
-       end function t8
-
-       subroutine s0(t0,value)
-         integer :: value
-         integer :: t0
-!f2py    intent(out) t0
-         t0 = value
-       end subroutine s0
-       subroutine s1(t1,value)
-         integer(kind=1) :: value
-         integer(kind=1) :: t1
-!f2py    intent(out) t1
-         t1 = value
-       end subroutine s1
-       subroutine s2(t2,value)
-         integer(kind=2) :: value
-         integer(kind=2) :: t2
-!f2py    intent(out) t2
-         t2 = value
-       end subroutine s2
-       subroutine s4(t4,value)
-         integer(kind=4) :: value
-         integer(kind=4) :: t4
-!f2py    intent(out) t4
-         t4 = value
-       end subroutine s4
-       subroutine s8(t8,value)
-         integer(kind=8) :: value
-         integer(kind=8) :: t8
-!f2py    intent(out) t8
-         t8 = value
-       end subroutine s8
-end module f90_return_integer
-    """
-
-    @pytest.mark.parametrize('name',
-                             't0,t1,t2,t4,t8,s0,s1,s2,s4,s8'.split(','))
-    def test_all(self, name):
-        self.check_function(getattr(self.module.f90_return_integer, name), name)
+    @pytest.mark.parametrize("name",
+                             "t0,t1,t2,t4,t8,s0,s1,s2,s4,s8".split(","))
+    def test_all_f90(self, name):
+        self.check_function(getattr(self.module.f90_return_integer, name),
+                            name)
diff --git a/numpy/f2py/tests/test_return_logical.py b/numpy/f2py/tests/test_return_logical.py
index 9db939c7e066..92fb902af4dd 100644
--- a/numpy/f2py/tests/test_return_logical.py
+++ b/numpy/f2py/tests/test_return_logical.py
@@ -1,185 +1,64 @@
 import pytest
 
 from numpy import array
-from numpy.testing import assert_, assert_raises
 from . import util
 
 
 class TestReturnLogical(util.F2PyTest):
-
     def check_function(self, t):
-        assert_(t(True) == 1, repr(t(True)))
-        assert_(t(False) == 0, repr(t(False)))
-        assert_(t(0) == 0)
-        assert_(t(None) == 0)
-        assert_(t(0.0) == 0)
-        assert_(t(0j) == 0)
-        assert_(t(1j) == 1)
-        assert_(t(234) == 1)
-        assert_(t(234.6) == 1)
-        assert_(t(234.6 + 3j) == 1)
-        assert_(t('234') == 1)
-        assert_(t('aaa') == 1)
-        assert_(t('') == 0)
-        assert_(t([]) == 0)
-        assert_(t(()) == 0)
-        assert_(t({}) == 0)
-        assert_(t(t) == 1)
-        assert_(t(-234) == 1)
-        assert_(t(10 ** 100) == 1)
-        assert_(t([234]) == 1)
-        assert_(t((234,)) == 1)
-        assert_(t(array(234)) == 1)
-        assert_(t(array([234])) == 1)
-        assert_(t(array([[234]])) == 1)
-        assert_(t(array([234], 'b')) == 1)
-        assert_(t(array([234], 'h')) == 1)
-        assert_(t(array([234], 'i')) == 1)
-        assert_(t(array([234], 'l')) == 1)
-        assert_(t(array([234], 'f')) == 1)
-        assert_(t(array([234], 'd')) == 1)
-        assert_(t(array([234 + 3j], 'F')) == 1)
-        assert_(t(array([234], 'D')) == 1)
-        assert_(t(array(0)) == 0)
-        assert_(t(array([0])) == 0)
-        assert_(t(array([[0]])) == 0)
-        assert_(t(array([0j])) == 0)
-        assert_(t(array([1])) == 1)
-        assert_raises(ValueError, t, array([0, 0]))
-
+        assert t(True) == 1
+        assert t(False) == 0
+        assert t(0) == 0
+        assert t(None) == 0
+        assert t(0.0) == 0
+        assert t(0j) == 0
+        assert t(1j) == 1
+        assert t(234) == 1
+        assert t(234.6) == 1
+        assert t(234.6 + 3j) == 1
+        assert t("234") == 1
+        assert t("aaa") == 1
+        assert t("") == 0
+        assert t([]) == 0
+        assert t(()) == 0
+        assert t({}) == 0
+        assert t(t) == 1
+        assert t(-234) == 1
+        assert t(10**100) == 1
+        assert t([234]) == 1
+        assert t((234, )) == 1
+        assert t(array(234)) == 1
+        assert t(array([234])) == 1
+        assert t(array([[234]])) == 1
+        assert t(array([127], "b")) == 1
+        assert t(array([234], "h")) == 1
+        assert t(array([234], "i")) == 1
+        assert t(array([234], "l")) == 1
+        assert t(array([234], "f")) == 1
+        assert t(array([234], "d")) == 1
+        assert t(array([234 + 3j], "F")) == 1
+        assert t(array([234], "D")) == 1
+        assert t(array(0)) == 0
+        assert t(array([0])) == 0
+        assert t(array([[0]])) == 0
+        assert t(array([0j])) == 0
+        assert t(array([1])) == 1
+        pytest.raises(ValueError, t, array([0, 0]))
 
-class TestF77ReturnLogical(TestReturnLogical):
-    code = """
-       function t0(value)
-         logical value
-         logical t0
-         t0 = value
-       end
-       function t1(value)
-         logical*1 value
-         logical*1 t1
-         t1 = value
-       end
-       function t2(value)
-         logical*2 value
-         logical*2 t2
-         t2 = value
-       end
-       function t4(value)
-         logical*4 value
-         logical*4 t4
-         t4 = value
-       end
-c       function t8(value)
-c         logical*8 value
-c         logical*8 t8
-c         t8 = value
-c       end
 
-       subroutine s0(t0,value)
-         logical value
-         logical t0
-cf2py    intent(out) t0
-         t0 = value
-       end
-       subroutine s1(t1,value)
-         logical*1 value
-         logical*1 t1
-cf2py    intent(out) t1
-         t1 = value
-       end
-       subroutine s2(t2,value)
-         logical*2 value
-         logical*2 t2
-cf2py    intent(out) t2
-         t2 = value
-       end
-       subroutine s4(t4,value)
-         logical*4 value
-         logical*4 t4
-cf2py    intent(out) t4
-         t4 = value
-       end
-c       subroutine s8(t8,value)
-c         logical*8 value
-c         logical*8 t8
-cf2py    intent(out) t8
-c         t8 = value
-c       end
-    """
+class TestFReturnLogical(TestReturnLogical):
+    sources = [
+        util.getpath("tests", "src", "return_logical", "foo77.f"),
+        util.getpath("tests", "src", "return_logical", "foo90.f90"),
+    ]
 
     @pytest.mark.slow
-    @pytest.mark.parametrize('name', 't0,t1,t2,t4,s0,s1,s2,s4'.split(','))
-    def test_all(self, name):
+    @pytest.mark.parametrize("name", "t0,t1,t2,t4,s0,s1,s2,s4".split(","))
+    def test_all_f77(self, name):
         self.check_function(getattr(self.module, name))
 
-
-class TestF90ReturnLogical(TestReturnLogical):
-    suffix = ".f90"
-    code = """
-module f90_return_logical
-  contains
-       function t0(value)
-         logical :: value
-         logical :: t0
-         t0 = value
-       end function t0
-       function t1(value)
-         logical(kind=1) :: value
-         logical(kind=1) :: t1
-         t1 = value
-       end function t1
-       function t2(value)
-         logical(kind=2) :: value
-         logical(kind=2) :: t2
-         t2 = value
-       end function t2
-       function t4(value)
-         logical(kind=4) :: value
-         logical(kind=4) :: t4
-         t4 = value
-       end function t4
-       function t8(value)
-         logical(kind=8) :: value
-         logical(kind=8) :: t8
-         t8 = value
-       end function t8
-
-       subroutine s0(t0,value)
-         logical :: value
-         logical :: t0
-!f2py    intent(out) t0
-         t0 = value
-       end subroutine s0
-       subroutine s1(t1,value)
-         logical(kind=1) :: value
-         logical(kind=1) :: t1
-!f2py    intent(out) t1
-         t1 = value
-       end subroutine s1
-       subroutine s2(t2,value)
-         logical(kind=2) :: value
-         logical(kind=2) :: t2
-!f2py    intent(out) t2
-         t2 = value
-       end subroutine s2
-       subroutine s4(t4,value)
-         logical(kind=4) :: value
-         logical(kind=4) :: t4
-!f2py    intent(out) t4
-         t4 = value
-       end subroutine s4
-       subroutine s8(t8,value)
-         logical(kind=8) :: value
-         logical(kind=8) :: t8
-!f2py    intent(out) t8
-         t8 = value
-       end subroutine s8
-end module f90_return_logical
-    """
-
     @pytest.mark.slow
-    @pytest.mark.parametrize('name',
-                             't0,t1,t2,t4,t8,s0,s1,s2,s4,s8'.split(','))
-    def test_all(self, name):
+    @pytest.mark.parametrize("name",
+                             "t0,t1,t2,t4,t8,s0,s1,s2,s4,s8".split(","))
+    def test_all_f90(self, name):
         self.check_function(getattr(self.module.f90_return_logical, name))
diff --git a/numpy/f2py/tests/test_return_real.py b/numpy/f2py/tests/test_return_real.py
index 8e5022a8ec97..9e76c151e88e 100644
--- a/numpy/f2py/tests/test_return_real.py
+++ b/numpy/f2py/tests/test_return_real.py
@@ -1,59 +1,62 @@
 import platform
 import pytest
+import numpy as np
 
 from numpy import array
-from numpy.testing import assert_, assert_raises
 from . import util
 
 
 class TestReturnReal(util.F2PyTest):
-
     def check_function(self, t, tname):
-        if tname in ['t0', 't4', 's0', 's4']:
+        if tname in ["t0", "t4", "s0", "s4"]:
             err = 1e-5
         else:
             err = 0.0
-        assert_(abs(t(234) - 234.0) <= err)
-        assert_(abs(t(234.6) - 234.6) <= err)
-        assert_(abs(t('234') - 234) <= err)
-        assert_(abs(t('234.6') - 234.6) <= err)
-        assert_(abs(t(-234) + 234) <= err)
-        assert_(abs(t([234]) - 234) <= err)
-        assert_(abs(t((234,)) - 234.) <= err)
-        assert_(abs(t(array(234)) - 234.) <= err)
-        assert_(abs(t(array([234])) - 234.) <= err)
-        assert_(abs(t(array([[234]])) - 234.) <= err)
-        assert_(abs(t(array([234], 'b')) + 22) <= err)
-        assert_(abs(t(array([234], 'h')) - 234.) <= err)
-        assert_(abs(t(array([234], 'i')) - 234.) <= err)
-        assert_(abs(t(array([234], 'l')) - 234.) <= err)
-        assert_(abs(t(array([234], 'B')) - 234.) <= err)
-        assert_(abs(t(array([234], 'f')) - 234.) <= err)
-        assert_(abs(t(array([234], 'd')) - 234.) <= err)
-        if tname in ['t0', 't4', 's0', 's4']:
-            assert_(t(1e200) == t(1e300))  # inf
-
-        #assert_raises(ValueError, t, array([234], 'S1'))
-        assert_raises(ValueError, t, 'abc')
-
-        assert_raises(IndexError, t, [])
-        assert_raises(IndexError, t, ())
-
-        assert_raises(Exception, t, t)
-        assert_raises(Exception, t, {})
+        assert abs(t(234) - 234.0) <= err
+        assert abs(t(234.6) - 234.6) <= err
+        assert abs(t("234") - 234) <= err
+        assert abs(t("234.6") - 234.6) <= err
+        assert abs(t(-234) + 234) <= err
+        assert abs(t([234]) - 234) <= err
+        assert abs(t((234, )) - 234.0) <= err
+        assert abs(t(array(234)) - 234.0) <= err
+        assert abs(t(array([234])) - 234.0) <= err
+        assert abs(t(array([[234]])) - 234.0) <= err
+        assert abs(t(array([234]).astype("b")) + 22) <= err
+        assert abs(t(array([234], "h")) - 234.0) <= err
+        assert abs(t(array([234], "i")) - 234.0) <= err
+        assert abs(t(array([234], "l")) - 234.0) <= err
+        assert abs(t(array([234], "B")) - 234.0) <= err
+        assert abs(t(array([234], "f")) - 234.0) <= err
+        assert abs(t(array([234], "d")) - 234.0) <= err
+        if tname in ["t0", "t4", "s0", "s4"]:
+            assert t(1e200) == t(1e300)  # inf
+
+        # pytest.raises(ValueError, t, array([234], 'S1'))
+        pytest.raises(ValueError, t, "abc")
+
+        pytest.raises(IndexError, t, [])
+        pytest.raises(IndexError, t, ())
+
+        pytest.raises(Exception, t, t)
+        pytest.raises(Exception, t, {})
 
         try:
-            r = t(10 ** 400)
-            assert_(repr(r) in ['inf', 'Infinity'], repr(r))
+            r = t(10**400)
+            assert repr(r) in ["inf", "Infinity"]
         except OverflowError:
             pass
 
 
-
 @pytest.mark.skipif(
-    platform.system() == 'Darwin',
+    platform.system() == "Darwin",
     reason="Prone to error when run with numpy/f2py/tests on mac os, "
-           "but not when run in isolation")
+    "but not when run in isolation",
+)
+@pytest.mark.skipif(
+    np.dtype(np.intp).itemsize < 8,
+    reason="32-bit builds are buggy"
+)
 class TestCReturnReal(TestReturnReal):
     suffix = ".pyf"
     module_name = "c_ext_return_real"
@@ -86,118 +89,21 @@ class TestCReturnReal(TestReturnReal):
 end python module c_ext_return_real
     """
 
-    @pytest.mark.parametrize('name', 't4,t8,s4,s8'.split(','))
+    @pytest.mark.parametrize("name", "t4,t8,s4,s8".split(","))
     def test_all(self, name):
         self.check_function(getattr(self.module, name), name)
 
 
-class TestF77ReturnReal(TestReturnReal):
-    code = """
-       function t0(value)
-         real value
-         real t0
-         t0 = value
-       end
-       function t4(value)
-         real*4 value
-         real*4 t4
-         t4 = value
-       end
-       function t8(value)
-         real*8 value
-         real*8 t8
-         t8 = value
-       end
-       function td(value)
-         double precision value
-         double precision td
-         td = value
-       end
-
-       subroutine s0(t0,value)
-         real value
-         real t0
-cf2py    intent(out) t0
-         t0 = value
-       end
-       subroutine s4(t4,value)
-         real*4 value
-         real*4 t4
-cf2py    intent(out) t4
-         t4 = value
-       end
-       subroutine s8(t8,value)
-         real*8 value
-         real*8 t8
-cf2py    intent(out) t8
-         t8 = value
-       end
-       subroutine sd(td,value)
-         double precision value
-         double precision td
-cf2py    intent(out) td
-         td = value
-       end
-    """
+class TestFReturnReal(TestReturnReal):
+    sources = [
+        util.getpath("tests", "src", "return_real", "foo77.f"),
+        util.getpath("tests", "src", "return_real", "foo90.f90"),
+    ]
 
-    @pytest.mark.parametrize('name', 't0,t4,t8,td,s0,s4,s8,sd'.split(','))
-    def test_all(self, name):
+    @pytest.mark.parametrize("name", "t0,t4,t8,td,s0,s4,s8,sd".split(","))
+    def test_all_f77(self, name):
         self.check_function(getattr(self.module, name), name)
 
-
-class TestF90ReturnReal(TestReturnReal):
-    suffix = ".f90"
-    code = """
-module f90_return_real
-  contains
-       function t0(value)
-         real :: value
-         real :: t0
-         t0 = value
-       end function t0
-       function t4(value)
-         real(kind=4) :: value
-         real(kind=4) :: t4
-         t4 = value
-       end function t4
-       function t8(value)
-         real(kind=8) :: value
-         real(kind=8) :: t8
-         t8 = value
-       end function t8
-       function td(value)
-         double precision :: value
-         double precision :: td
-         td = value
-       end function td
-
-       subroutine s0(t0,value)
-         real :: value
-         real :: t0
-!f2py    intent(out) t0
-         t0 = value
-       end subroutine s0
-       subroutine s4(t4,value)
-         real(kind=4) :: value
-         real(kind=4) :: t4
-!f2py    intent(out) t4
-         t4 = value
-       end subroutine s4
-       subroutine s8(t8,value)
-         real(kind=8) :: value
-         real(kind=8) :: t8
-!f2py    intent(out) t8
-         t8 = value
-       end subroutine s8
-       subroutine sd(td,value)
-         double precision :: value
-         double precision :: td
-!f2py    intent(out) td
-         td = value
-       end subroutine sd
-end module f90_return_real
-    """
-
-    @pytest.mark.parametrize('name', 't0,t4,t8,td,s0,s4,s8,sd'.split(','))
-    def test_all(self, name):
+    @pytest.mark.parametrize("name", "t0,t4,t8,td,s0,s4,s8,sd".split(","))
+    def test_all_f90(self, name):
         self.check_function(getattr(self.module.f90_return_real, name), name)
diff --git a/numpy/f2py/tests/test_semicolon_split.py b/numpy/f2py/tests/test_semicolon_split.py
index d8b4bf222122..6d499046c1a5 100644
--- a/numpy/f2py/tests/test_semicolon_split.py
+++ b/numpy/f2py/tests/test_semicolon_split.py
@@ -1,18 +1,24 @@
 import platform
 import pytest
+import numpy as np
 
 from . import util
-from numpy.testing import assert_equal
+
 
 @pytest.mark.skipif(
-    platform.system() == 'Darwin',
+    platform.system() == "Darwin",
     reason="Prone to error when run with numpy/f2py/tests on mac os, "
-           "but not when run in isolation")
+    "but not when run in isolation",
+)
+@pytest.mark.skipif(
+    np.dtype(np.intp).itemsize < 8,
+    reason="32-bit builds are buggy"
+)
 class TestMultiline(util.F2PyTest):
     suffix = ".pyf"
     module_name = "multiline"
-    code = """
-python module {module}
+    code = f"""
+python module {module_name}
     usercode '''
 void foo(int* x) {{
     char dummy = ';';
@@ -25,22 +31,27 @@ class TestMultiline(util.F2PyTest):
             integer intent(out) :: x
         end subroutine foo
     end interface
-end python module {module}
-    """.format(module=module_name)
+end python module {module_name}
+    """
 
     def test_multiline(self):
-        assert_equal(self.module.foo(), 42)
+        assert self.module.foo() == 42
 
 
 @pytest.mark.skipif(
-    platform.system() == 'Darwin',
+    platform.system() == "Darwin",
     reason="Prone to error when run with numpy/f2py/tests on mac os, "
-           "but not when run in isolation")
+    "but not when run in isolation",
+)
+@pytest.mark.skipif(
+    np.dtype(np.intp).itemsize < 8,
+    reason="32-bit builds are buggy"
+)
 class TestCallstatement(util.F2PyTest):
     suffix = ".pyf"
     module_name = "callstatement"
-    code = """
-python module {module}
+    code = f"""
+python module {module_name}
     usercode '''
 void foo(int* x) {{
 }}
@@ -56,8 +67,8 @@ class TestCallstatement(util.F2PyTest):
             }}
         end subroutine foo
     end interface
-end python module {module}
-    """.format(module=module_name)
+end python module {module_name}
+    """
 
     def test_callstatement(self):
-        assert_equal(self.module.foo(), 42)
+        assert self.module.foo() == 42
diff --git a/numpy/f2py/tests/test_size.py b/numpy/f2py/tests/test_size.py
index b609fa77f711..bd2c349df585 100644
--- a/numpy/f2py/tests/test_size.py
+++ b/numpy/f2py/tests/test_size.py
@@ -1,49 +1,45 @@
 import os
 import pytest
+import numpy as np
 
-from numpy.testing import assert_equal
 from . import util
 
 
-def _path(*a):
-    return os.path.join(*((os.path.dirname(__file__),) + a))
-
-
 class TestSizeSumExample(util.F2PyTest):
-    sources = [_path('src', 'size', 'foo.f90')]
+    sources = [util.getpath("tests", "src", "size", "foo.f90")]
 
     @pytest.mark.slow
     def test_all(self):
         r = self.module.foo([[]])
-        assert_equal(r, [0], repr(r))
+        assert r == [0]
 
         r = self.module.foo([[1, 2]])
-        assert_equal(r, [3], repr(r))
+        assert r == [3]
 
         r = self.module.foo([[1, 2], [3, 4]])
-        assert_equal(r, [3, 7], repr(r))
+        assert np.allclose(r, [3, 7])
 
         r = self.module.foo([[1, 2], [3, 4], [5, 6]])
-        assert_equal(r, [3, 7, 11], repr(r))
+        assert np.allclose(r, [3, 7, 11])
 
     @pytest.mark.slow
     def test_transpose(self):
         r = self.module.trans([[]])
-        assert_equal(r.T, [[]], repr(r))
+        assert np.allclose(r.T, np.array([[]]))
 
         r = self.module.trans([[1, 2]])
-        assert_equal(r, [[1], [2]], repr(r))
+        assert np.allclose(r, [[1.], [2.]])
 
         r = self.module.trans([[1, 2, 3], [4, 5, 6]])
-        assert_equal(r, [[1, 4], [2, 5], [3, 6]], repr(r))
+        assert np.allclose(r, [[1, 4], [2, 5], [3, 6]])
 
     @pytest.mark.slow
     def test_flatten(self):
         r = self.module.flatten([[]])
-        assert_equal(r, [], repr(r))
+        assert np.allclose(r, [])
 
         r = self.module.flatten([[1, 2]])
-        assert_equal(r, [1, 2], repr(r))
+        assert np.allclose(r, [1, 2])
 
         r = self.module.flatten([[1, 2, 3], [4, 5, 6]])
-        assert_equal(r, [1, 2, 3, 4, 5, 6], repr(r))
+        assert np.allclose(r, [1, 2, 3, 4, 5, 6])
diff --git a/numpy/f2py/tests/test_string.py b/numpy/f2py/tests/test_string.py
index 7b27f8786ed6..9e937188c930 100644
--- a/numpy/f2py/tests/test_string.py
+++ b/numpy/f2py/tests/test_string.py
@@ -1,109 +1,43 @@
 import os
 import pytest
 import textwrap
-from numpy.testing import assert_array_equal
 import numpy as np
 from . import util
 
 
-def _path(*a):
-    return os.path.join(*((os.path.dirname(__file__),) + a))
-
-
 class TestString(util.F2PyTest):
-    sources = [_path('src', 'string', 'char.f90')]
+    sources = [util.getpath("tests", "src", "string", "char.f90")]
 
     @pytest.mark.slow
     def test_char(self):
-        strings = np.array(['ab', 'cd', 'ef'], dtype='c').T
-        inp, out = self.module.char_test.change_strings(strings,
-                                                        strings.shape[1])
-        assert_array_equal(inp, strings)
+        strings = np.array(["ab", "cd", "ef"], dtype="c").T
+        inp, out = self.module.char_test.change_strings(
+            strings, strings.shape[1])
+        assert inp == pytest.approx(strings)
         expected = strings.copy()
-        expected[1, :] = 'AAA'
-        assert_array_equal(out, expected)
+        expected[1, :] = "AAA"
+        assert out == pytest.approx(expected)
 
 
 class TestDocStringArguments(util.F2PyTest):
-    suffix = '.f'
-
-    code = """
-C FILE: STRING.F
-      SUBROUTINE FOO(A,B,C,D)
-      CHARACTER*5 A, B
-      CHARACTER*(*) C,D
-Cf2py intent(in) a,c
-Cf2py intent(inout) b,d
-      PRINT*, "A=",A
-      PRINT*, "B=",B
-      PRINT*, "C=",C
-      PRINT*, "D=",D
-      PRINT*, "CHANGE A,B,C,D"
-      A(1:1) = 'A'
-      B(1:1) = 'B'
-      C(1:1) = 'C'
-      D(1:1) = 'D'
-      PRINT*, "A=",A
-      PRINT*, "B=",B
-      PRINT*, "C=",C
-      PRINT*, "D=",D
-      END
-C END OF FILE STRING.F
-        """
+    sources = [util.getpath("tests", "src", "string", "string.f")]
 
     def test_example(self):
-        a = np.array(b'123\0\0')
-        b = np.array(b'123\0\0')
-        c = np.array(b'123')
-        d = np.array(b'123')
+        a = np.array(b"123\0\0")
+        b = np.array(b"123\0\0")
+        c = np.array(b"123")
+        d = np.array(b"123")
 
         self.module.foo(a, b, c, d)
 
-        assert a.tobytes() == b'123\0\0'
-        assert b.tobytes() == b'B23\0\0', (b.tobytes(),)
-        assert c.tobytes() == b'123'
-        assert d.tobytes() == b'D23'
+        assert a.tobytes() == b"123\0\0"
+        assert b.tobytes() == b"B23\0\0"
+        assert c.tobytes() == b"123"
+        assert d.tobytes() == b"D23"
 
 
 class TestFixedString(util.F2PyTest):
-    suffix = '.f90'
-
-    code = textwrap.dedent("""
-       function sint(s) result(i)
-          implicit none
-          character(len=*) :: s
-          integer :: j, i
-          i = 0
-          do j=len(s), 1, -1
-           if (.not.((i.eq.0).and.(s(j:j).eq.' '))) then
-             i = i + ichar(s(j:j)) * 10 ** (j - 1)
-           endif
-          end do
-          return
-        end function sint
-
-        function test_in_bytes4(a) result (i)
-          implicit none
-          integer :: sint
-          character(len=4) :: a
-          integer :: i
-          i = sint(a)
-          a(1:1) = 'A'
-          return
-        end function test_in_bytes4
-
-        function test_inout_bytes4(a) result (i)
-          implicit none
-          integer :: sint
-          character(len=4), intent(inout) :: a
-          integer :: i
-          if (a(1:1).ne.' ') then
-            a(1:1) = 'E'
-          endif
-          i = sint(a)
-          return
-        end function test_inout_bytes4
-        """)
+    sources = [util.getpath("tests", "src", "string", "fixed_string.f90")]
 
     @staticmethod
     def _sint(s, start=0, end=None):
@@ -122,41 +56,41 @@ def _sint(s, start=0, end=None):
             end = len(s)
         i = 0
         for j in range(start, min(end, len(s))):
-            i += s[j] * 10 ** j
+            i += s[j] * 10**j
         return i
 
-    def _get_input(self, intent='in'):
-        if intent in ['in']:
-            yield ''
-            yield '1'
-            yield '1234'
-            yield '12345'
-            yield b''
-            yield b'\0'
-            yield b'1'
-            yield b'\01'
-            yield b'1\0'
-            yield b'1234'
-            yield b'12345'
-        yield np.ndarray((), np.bytes_, buffer=b'')  # array(b'', dtype='|S0')
-        yield np.array(b'')                          # array(b'', dtype='|S1')
-        yield np.array(b'\0')
-        yield np.array(b'1')
-        yield np.array(b'1\0')
-        yield np.array(b'\01')
-        yield np.array(b'1234')
-        yield np.array(b'123\0')
-        yield np.array(b'12345')
+    def _get_input(self, intent="in"):
+        if intent in ["in"]:
+            yield ""
+            yield "1"
+            yield "1234"
+            yield "12345"
+            yield b""
+            yield b"\0"
+            yield b"1"
+            yield b"\01"
+            yield b"1\0"
+            yield b"1234"
+            yield b"12345"
+        yield np.ndarray((), np.bytes_, buffer=b"")  # array(b'', dtype='|S0')
+        yield np.array(b"")  # array(b'', dtype='|S1')
+        yield np.array(b"\0")
+        yield np.array(b"1")
+        yield np.array(b"1\0")
+        yield np.array(b"\01")
+        yield np.array(b"1234")
+        yield np.array(b"123\0")
+        yield np.array(b"12345")
 
     def test_intent_in(self):
         for s in self._get_input():
             r = self.module.test_in_bytes4(s)
             # also checks that s is not changed inplace
             expected = self._sint(s, end=4)
-            assert r == expected, (s)
+            assert r == expected, s
 
     def test_intent_inout(self):
-        for s in self._get_input(intent='inout'):
+        for s in self._get_input(intent="inout"):
             rest = self._sint(s, start=4)
             r = self.module.test_inout_bytes4(s)
             expected = self._sint(s, end=4)
diff --git a/numpy/f2py/tests/test_symbolic.py b/numpy/f2py/tests/test_symbolic.py
index 52cabac530d5..8452783111eb 100644
--- a/numpy/f2py/tests/test_symbolic.py
+++ b/numpy/f2py/tests/test_symbolic.py
@@ -1,35 +1,56 @@
-from numpy.testing import assert_raises
+import pytest
+
 from numpy.f2py.symbolic import (
-    Expr, Op, ArithOp, Language,
-    as_symbol, as_number, as_string, as_array, as_complex,
-    as_terms, as_factors, eliminate_quotes, insert_quotes,
-    fromstring, as_expr, as_apply,
-    as_numer_denom, as_ternary, as_ref, as_deref,
-    normalize, as_eq, as_ne, as_lt, as_gt, as_le, as_ge
-    )
+    Expr,
+    Op,
+    ArithOp,
+    Language,
+    as_symbol,
+    as_number,
+    as_string,
+    as_array,
+    as_complex,
+    as_terms,
+    as_factors,
+    eliminate_quotes,
+    insert_quotes,
+    fromstring,
+    as_expr,
+    as_apply,
+    as_numer_denom,
+    as_ternary,
+    as_ref,
+    as_deref,
+    normalize,
+    as_eq,
+    as_ne,
+    as_lt,
+    as_gt,
+    as_le,
+    as_ge,
+)
 from . import util
 
 
 class TestSymbolic(util.F2PyTest):
-
     def test_eliminate_quotes(self):
         def worker(s):
             r, d = eliminate_quotes(s)
             s1 = insert_quotes(r, d)
             assert s1 == s
 
-        for kind in ['', 'mykind_']:
+        for kind in ["", "mykind_"]:
             worker(kind + '"1234" // "ABCD"')
             worker(kind + '"1234" // ' + kind + '"ABCD"')
-            worker(kind + '"1234" // \'ABCD\'')
-            worker(kind + '"1234" // ' + kind + '\'ABCD\'')
+            worker(kind + "\"1234\" // 'ABCD'")
+            worker(kind + '"1234" // ' + kind + "'ABCD'")
             worker(kind + '"1\\"2\'AB\'34"')
-            worker('a = ' + kind + "'1\\'2\"AB\"34'")
+            worker("a = " + kind + "'1\\'2\"AB\"34'")
 
     def test_sanity(self):
-        x = as_symbol('x')
-        y = as_symbol('y')
-        z = as_symbol('z')
+        x = as_symbol("x")
+        y = as_symbol("y")
+        z = as_symbol("z")
 
         assert x.op == Op.SYMBOL
         assert repr(x) == "Expr(Op.SYMBOL, 'x')"
@@ -70,7 +91,7 @@ def test_sanity(self):
         assert s != s2
 
         a = as_array((n, m))
-        b = as_array((n,))
+        b = as_array((n, ))
         assert a.op == Op.ARRAY
         assert repr(a) == ("Expr(Op.ARRAY, (Expr(Op.INTEGER, (123, 4)),"
                            " Expr(Op.INTEGER, (456, 4))))")
@@ -108,88 +129,90 @@ def test_sanity(self):
         assert hash(e) is not None
 
     def test_tostring_fortran(self):
-        x = as_symbol('x')
-        y = as_symbol('y')
-        z = as_symbol('z')
+        x = as_symbol("x")
+        y = as_symbol("y")
+        z = as_symbol("z")
         n = as_number(123)
         m = as_number(456)
         a = as_array((n, m))
         c = as_complex(n, m)
 
-        assert str(x) == 'x'
-        assert str(n) == '123'
-        assert str(a) == '[123, 456]'
-        assert str(c) == '(123, 456)'
-
-        assert str(Expr(Op.TERMS, {x: 1})) == 'x'
-        assert str(Expr(Op.TERMS, {x: 2})) == '2 * x'
-        assert str(Expr(Op.TERMS, {x: -1})) == '-x'
-        assert str(Expr(Op.TERMS, {x: -2})) == '-2 * x'
-        assert str(Expr(Op.TERMS, {x: 1, y: 1})) == 'x + y'
-        assert str(Expr(Op.TERMS, {x: -1, y: -1})) == '-x - y'
-        assert str(Expr(Op.TERMS, {x: 2, y: 3})) == '2 * x + 3 * y'
-        assert str(Expr(Op.TERMS, {x: -2, y: 3})) == '-2 * x + 3 * y'
-        assert str(Expr(Op.TERMS, {x: 2, y: -3})) == '2 * x - 3 * y'
-
-        assert str(Expr(Op.FACTORS, {x: 1})) == 'x'
-        assert str(Expr(Op.FACTORS, {x: 2})) == 'x ** 2'
-        assert str(Expr(Op.FACTORS, {x: -1})) == 'x ** -1'
-        assert str(Expr(Op.FACTORS, {x: -2})) == 'x ** -2'
-        assert str(Expr(Op.FACTORS, {x: 1, y: 1})) == 'x * y'
-        assert str(Expr(Op.FACTORS, {x: 2, y: 3})) == 'x ** 2 * y ** 3'
+        assert str(x) == "x"
+        assert str(n) == "123"
+        assert str(a) == "[123, 456]"
+        assert str(c) == "(123, 456)"
+
+        assert str(Expr(Op.TERMS, {x: 1})) == "x"
+        assert str(Expr(Op.TERMS, {x: 2})) == "2 * x"
+        assert str(Expr(Op.TERMS, {x: -1})) == "-x"
+        assert str(Expr(Op.TERMS, {x: -2})) == "-2 * x"
+        assert str(Expr(Op.TERMS, {x: 1, y: 1})) == "x + y"
+        assert str(Expr(Op.TERMS, {x: -1, y: -1})) == "-x - y"
+        assert str(Expr(Op.TERMS, {x: 2, y: 3})) == "2 * x + 3 * y"
+        assert str(Expr(Op.TERMS, {x: -2, y: 3})) == "-2 * x + 3 * y"
+        assert str(Expr(Op.TERMS, {x: 2, y: -3})) == "2 * x - 3 * y"
+
+        assert str(Expr(Op.FACTORS, {x: 1})) == "x"
+        assert str(Expr(Op.FACTORS, {x: 2})) == "x ** 2"
+        assert str(Expr(Op.FACTORS, {x: -1})) == "x ** -1"
+        assert str(Expr(Op.FACTORS, {x: -2})) == "x ** -2"
+        assert str(Expr(Op.FACTORS, {x: 1, y: 1})) == "x * y"
+        assert str(Expr(Op.FACTORS, {x: 2, y: 3})) == "x ** 2 * y ** 3"
 
         v = Expr(Op.FACTORS, {x: 2, Expr(Op.TERMS, {x: 1, y: 1}): 3})
-        assert str(v) == 'x ** 2 * (x + y) ** 3', str(v)
+        assert str(v) == "x ** 2 * (x + y) ** 3", str(v)
         v = Expr(Op.FACTORS, {x: 2, Expr(Op.FACTORS, {x: 1, y: 1}): 3})
-        assert str(v) == 'x ** 2 * (x * y) ** 3', str(v)
+        assert str(v) == "x ** 2 * (x * y) ** 3", str(v)
 
-        assert str(Expr(Op.APPLY, ('f', (), {}))) == 'f()'
-        assert str(Expr(Op.APPLY, ('f', (x,), {}))) == 'f(x)'
-        assert str(Expr(Op.APPLY, ('f', (x, y), {}))) == 'f(x, y)'
-        assert str(Expr(Op.INDEXING, ('f', x))) == 'f[x]'
+        assert str(Expr(Op.APPLY, ("f", (), {}))) == "f()"
+        assert str(Expr(Op.APPLY, ("f", (x, ), {}))) == "f(x)"
+        assert str(Expr(Op.APPLY, ("f", (x, y), {}))) == "f(x, y)"
+        assert str(Expr(Op.INDEXING, ("f", x))) == "f[x]"
 
-        assert str(as_ternary(x, y, z)) == 'merge(y, z, x)'
-        assert str(as_eq(x, y)) == 'x .eq. y'
-        assert str(as_ne(x, y)) == 'x .ne. y'
-        assert str(as_lt(x, y)) == 'x .lt. y'
-        assert str(as_le(x, y)) == 'x .le. y'
-        assert str(as_gt(x, y)) == 'x .gt. y'
-        assert str(as_ge(x, y)) == 'x .ge. y'
+        assert str(as_ternary(x, y, z)) == "merge(y, z, x)"
+        assert str(as_eq(x, y)) == "x .eq. y"
+        assert str(as_ne(x, y)) == "x .ne. y"
+        assert str(as_lt(x, y)) == "x .lt. y"
+        assert str(as_le(x, y)) == "x .le. y"
+        assert str(as_gt(x, y)) == "x .gt. y"
+        assert str(as_ge(x, y)) == "x .ge. y"
 
     def test_tostring_c(self):
         language = Language.C
-        x = as_symbol('x')
-        y = as_symbol('y')
-        z = as_symbol('z')
+        x = as_symbol("x")
+        y = as_symbol("y")
+        z = as_symbol("z")
         n = as_number(123)
 
-        assert Expr(Op.FACTORS, {x: 2}).tostring(language=language) == 'x * x'
-        assert Expr(Op.FACTORS, {x + y: 2}).tostring(
-            language=language) == '(x + y) * (x + y)'
-        assert Expr(Op.FACTORS, {x: 12}).tostring(
-            language=language) == 'pow(x, 12)'
-
-        assert as_apply(ArithOp.DIV, x, y).tostring(
-            language=language) == 'x / y'
-        assert as_apply(ArithOp.DIV, x, x + y).tostring(
-            language=language) == 'x / (x + y)'
-        assert as_apply(ArithOp.DIV, x - y, x + y).tostring(
-            language=language) == '(x - y) / (x + y)'
-        assert (x + (x - y) / (x + y) + n).tostring(
-            language=language) == '123 + x + (x - y) / (x + y)'
-
-        assert as_ternary(x, y, z).tostring(language=language) == '(x ? y : z)'
-        assert as_eq(x, y).tostring(language=language) == 'x == y'
-        assert as_ne(x, y).tostring(language=language) == 'x != y'
-        assert as_lt(x, y).tostring(language=language) == 'x < y'
-        assert as_le(x, y).tostring(language=language) == 'x <= y'
-        assert as_gt(x, y).tostring(language=language) == 'x > y'
-        assert as_ge(x, y).tostring(language=language) == 'x >= y'
+        assert Expr(Op.FACTORS, {x: 2}).tostring(language=language) == "x * x"
+        assert (Expr(Op.FACTORS, {
+            x + y: 2
+        }).tostring(language=language) == "(x + y) * (x + y)")
+        assert Expr(Op.FACTORS, {
+            x: 12
+        }).tostring(language=language) == "pow(x, 12)"
+
+        assert as_apply(ArithOp.DIV, x,
+                        y).tostring(language=language) == "x / y"
+        assert (as_apply(ArithOp.DIV, x,
+                         x + y).tostring(language=language) == "x / (x + y)")
+        assert (as_apply(ArithOp.DIV, x - y, x +
+                         y).tostring(language=language) == "(x - y) / (x + y)")
+        assert (x + (x - y) / (x + y) +
+                n).tostring(language=language) == "123 + x + (x - y) / (x + y)"
+
+        assert as_ternary(x, y, z).tostring(language=language) == "(x?y:z)"
+        assert as_eq(x, y).tostring(language=language) == "x == y"
+        assert as_ne(x, y).tostring(language=language) == "x != y"
+        assert as_lt(x, y).tostring(language=language) == "x < y"
+        assert as_le(x, y).tostring(language=language) == "x <= y"
+        assert as_gt(x, y).tostring(language=language) == "x > y"
+        assert as_ge(x, y).tostring(language=language) == "x >= y"
 
     def test_operations(self):
-        x = as_symbol('x')
-        y = as_symbol('y')
-        z = as_symbol('z')
+        x = as_symbol("x")
+        y = as_symbol("y")
+        z = as_symbol("z")
 
         assert x + x == Expr(Op.TERMS, {x: 2})
         assert x - x == Expr(Op.INTEGER, (0, 4))
@@ -205,28 +228,35 @@ def test_operations(self):
         assert 2 * x + 3 * y == Expr(Op.TERMS, {x: 2, y: 3})
         assert (x + y) * 2 == Expr(Op.TERMS, {x: 2, y: 2})
 
-        assert x ** 2 == Expr(Op.FACTORS, {x: 2})
-        assert (x + y) ** 2 == Expr(Op.TERMS,
-                                    {Expr(Op.FACTORS, {x: 2}): 1,
-                                     Expr(Op.FACTORS, {y: 2}): 1,
-                                     Expr(Op.FACTORS, {x: 1, y: 1}): 2})
-        assert (x + y) * x == x ** 2 + x * y
-        assert (x + y) ** 2 == x ** 2 + 2 * x * y + y ** 2
-        assert (x + y) ** 2 + (x - y) ** 2 == 2 * x ** 2 + 2 * y ** 2
+        assert x**2 == Expr(Op.FACTORS, {x: 2})
+        assert (x + y)**2 == Expr(
+            Op.TERMS,
+            {
+                Expr(Op.FACTORS, {x: 2}): 1,
+                Expr(Op.FACTORS, {y: 2}): 1,
+                Expr(Op.FACTORS, {
+                    x: 1,
+                    y: 1
+                }): 2,
+            },
+        )
+        assert (x + y) * x == x**2 + x * y
+        assert (x + y)**2 == x**2 + 2 * x * y + y**2
+        assert (x + y)**2 + (x - y)**2 == 2 * x**2 + 2 * y**2
         assert (x + y) * z == x * z + y * z
         assert z * (x + y) == x * z + y * z
 
         assert (x / 2) == as_apply(ArithOp.DIV, x, as_number(2))
         assert (2 * x / 2) == x
-        assert (3 * x / 2) == as_apply(ArithOp.DIV, 3*x, as_number(2))
+        assert (3 * x / 2) == as_apply(ArithOp.DIV, 3 * x, as_number(2))
         assert (4 * x / 2) == 2 * x
-        assert (5 * x / 2) == as_apply(ArithOp.DIV, 5*x, as_number(2))
+        assert (5 * x / 2) == as_apply(ArithOp.DIV, 5 * x, as_number(2))
         assert (6 * x / 2) == 3 * x
-        assert ((3*5) * x / 6) == as_apply(ArithOp.DIV, 5*x, as_number(2))
-        assert (30*x**2*y**4 / (24*x**3*y**3)) == as_apply(ArithOp.DIV,
-                                                           5*y, 4*x)
-        assert ((15 * x / 6) / 5) == as_apply(
-            ArithOp.DIV, x, as_number(2)), ((15 * x / 6) / 5)
+        assert ((3 * 5) * x / 6) == as_apply(ArithOp.DIV, 5 * x, as_number(2))
+        assert (30 * x**2 * y**4 / (24 * x**3 * y**3)) == as_apply(
+            ArithOp.DIV, 5 * y, 4 * x)
+        assert ((15 * x / 6) / 5) == as_apply(ArithOp.DIV, x,
+                                              as_number(2)), (15 * x / 6) / 5
         assert (x / (5 / x)) == as_apply(ArithOp.DIV, x**2, as_number(5))
 
         assert (x / 2.0) == Expr(Op.TERMS, {x: 0.5})
@@ -238,127 +268,128 @@ def test_operations(self):
         assert s // x == Expr(Op.CONCAT, (s, x))
         assert x // s == Expr(Op.CONCAT, (x, s))
 
-        c = as_complex(1., 2.)
-        assert -c == as_complex(-1., -2.)
-        assert c + c == as_expr((1+2j)*2)
-        assert c * c == as_expr((1+2j)**2)
+        c = as_complex(1.0, 2.0)
+        assert -c == as_complex(-1.0, -2.0)
+        assert c + c == as_expr((1 + 2j) * 2)
+        assert c * c == as_expr((1 + 2j)**2)
 
     def test_substitute(self):
-        x = as_symbol('x')
-        y = as_symbol('y')
-        z = as_symbol('z')
+        x = as_symbol("x")
+        y = as_symbol("y")
+        z = as_symbol("z")
         a = as_array((x, y))
 
         assert x.substitute({x: y}) == y
         assert (x + y).substitute({x: z}) == y + z
         assert (x * y).substitute({x: z}) == y * z
-        assert (x ** 4).substitute({x: z}) == z ** 4
+        assert (x**4).substitute({x: z}) == z**4
         assert (x / y).substitute({x: z}) == z / y
         assert x.substitute({x: y + z}) == y + z
         assert a.substitute({x: y + z}) == as_array((y + z, y))
 
-        assert as_ternary(x, y, z).substitute(
-            {x: y + z}) == as_ternary(y + z, y, z)
-        assert as_eq(x, y).substitute(
-            {x: y + z}) == as_eq(y + z, y)
+        assert as_ternary(x, y,
+                          z).substitute({x: y + z}) == as_ternary(y + z, y, z)
+        assert as_eq(x, y).substitute({x: y + z}) == as_eq(y + z, y)
 
     def test_fromstring(self):
 
-        x = as_symbol('x')
-        y = as_symbol('y')
-        z = as_symbol('z')
-        f = as_symbol('f')
+        x = as_symbol("x")
+        y = as_symbol("y")
+        z = as_symbol("z")
+        f = as_symbol("f")
         s = as_string('"ABC"')
         t = as_string('"123"')
         a = as_array((x, y))
 
-        assert fromstring('x') == x
-        assert fromstring('+ x') == x
-        assert fromstring('-  x') == -x
-        assert fromstring('x + y') == x + y
-        assert fromstring('x + 1') == x + 1
-        assert fromstring('x * y') == x * y
-        assert fromstring('x * 2') == x * 2
-        assert fromstring('x / y') == x / y
-        assert fromstring('x ** 2',
-                          language=Language.Python) == x ** 2
-        assert fromstring('x ** 2 ** 3',
-                          language=Language.Python) == x ** 2 ** 3
-        assert fromstring('(x + y) * z') == (x + y) * z
-
-        assert fromstring('f(x)') == f(x)
-        assert fromstring('f(x,y)') == f(x, y)
-        assert fromstring('f[x]') == f[x]
-        assert fromstring('f[x][y]') == f[x][y]
+        assert fromstring("x") == x
+        assert fromstring("+ x") == x
+        assert fromstring("-  x") == -x
+        assert fromstring("x + y") == x + y
+        assert fromstring("x + 1") == x + 1
+        assert fromstring("x * y") == x * y
+        assert fromstring("x * 2") == x * 2
+        assert fromstring("x / y") == x / y
+        assert fromstring("x ** 2", language=Language.Python) == x**2
+        assert fromstring("x ** 2 ** 3", language=Language.Python) == x**2**3
+        assert fromstring("(x + y) * z") == (x + y) * z
+
+        assert fromstring("f(x)") == f(x)
+        assert fromstring("f(x,y)") == f(x, y)
+        assert fromstring("f[x]") == f[x]
+        assert fromstring("f[x][y]") == f[x][y]
 
         assert fromstring('"ABC"') == s
-        assert normalize(fromstring('"ABC" // "123" ',
-                                    language=Language.Fortran)) == s // t
+        assert (normalize(
+            fromstring('"ABC" // "123" ',
+                       language=Language.Fortran)) == s // t)
         assert fromstring('f("ABC")') == f(s)
-        assert fromstring('MYSTRKIND_"ABC"') == as_string('"ABC"', 'MYSTRKIND')
-
-        assert fromstring('(/x, y/)') == a, fromstring('(/x, y/)')
-        assert fromstring('f((/x, y/))') == f(a)
-        assert fromstring('(/(x+y)*z/)') == as_array(((x+y)*z,))
-
-        assert fromstring('123') == as_number(123)
-        assert fromstring('123_2') == as_number(123, 2)
-        assert fromstring('123_myintkind') == as_number(123, 'myintkind')
-
-        assert fromstring('123.0') == as_number(123.0, 4)
-        assert fromstring('123.0_4') == as_number(123.0, 4)
-        assert fromstring('123.0_8') == as_number(123.0, 8)
-        assert fromstring('123.0e0') == as_number(123.0, 4)
-        assert fromstring('123.0d0') == as_number(123.0, 8)
-        assert fromstring('123d0') == as_number(123.0, 8)
-        assert fromstring('123e-0') == as_number(123.0, 4)
-        assert fromstring('123d+0') == as_number(123.0, 8)
-        assert fromstring('123.0_myrealkind') == as_number(123.0, 'myrealkind')
-        assert fromstring('3E4') == as_number(30000.0, 4)
-
-        assert fromstring('(1, 2)') == as_complex(1, 2)
-        assert fromstring('(1e2, PI)') == as_complex(
-            as_number(100.0), as_symbol('PI'))
-
-        assert fromstring('[1, 2]') == as_array((as_number(1), as_number(2)))
-
-        assert fromstring('POINT(x, y=1)') == as_apply(
-            as_symbol('POINT'), x, y=as_number(1))
-        assert (fromstring('PERSON(name="John", age=50, shape=(/34, 23/))')
-                == as_apply(as_symbol('PERSON'),
-                            name=as_string('"John"'),
-                            age=as_number(50),
-                            shape=as_array((as_number(34), as_number(23)))))
-
-        assert fromstring('x?y:z') == as_ternary(x, y, z)
-
-        assert fromstring('*x') == as_deref(x)
-        assert fromstring('**x') == as_deref(as_deref(x))
-        assert fromstring('&x') == as_ref(x)
-        assert fromstring('(*x) * (*y)') == as_deref(x) * as_deref(y)
-        assert fromstring('(*x) * *y') == as_deref(x) * as_deref(y)
-        assert fromstring('*x * *y') == as_deref(x) * as_deref(y)
-        assert fromstring('*x**y') == as_deref(x) * as_deref(y)
-
-        assert fromstring('x == y') == as_eq(x, y)
-        assert fromstring('x != y') == as_ne(x, y)
-        assert fromstring('x < y') == as_lt(x, y)
-        assert fromstring('x > y') == as_gt(x, y)
-        assert fromstring('x <= y') == as_le(x, y)
-        assert fromstring('x >= y') == as_ge(x, y)
-
-        assert fromstring('x .eq. y', language=Language.Fortran) == as_eq(x, y)
-        assert fromstring('x .ne. y', language=Language.Fortran) == as_ne(x, y)
-        assert fromstring('x .lt. y', language=Language.Fortran) == as_lt(x, y)
-        assert fromstring('x .gt. y', language=Language.Fortran) == as_gt(x, y)
-        assert fromstring('x .le. y', language=Language.Fortran) == as_le(x, y)
-        assert fromstring('x .ge. y', language=Language.Fortran) == as_ge(x, y)
+        assert fromstring('MYSTRKIND_"ABC"') == as_string('"ABC"', "MYSTRKIND")
+
+        assert fromstring("(/x, y/)") == a, fromstring("(/x, y/)")
+        assert fromstring("f((/x, y/))") == f(a)
+        assert fromstring("(/(x+y)*z/)") == as_array(((x + y) * z, ))
+
+        assert fromstring("123") == as_number(123)
+        assert fromstring("123_2") == as_number(123, 2)
+        assert fromstring("123_myintkind") == as_number(123, "myintkind")
+
+        assert fromstring("123.0") == as_number(123.0, 4)
+        assert fromstring("123.0_4") == as_number(123.0, 4)
+        assert fromstring("123.0_8") == as_number(123.0, 8)
+        assert fromstring("123.0e0") == as_number(123.0, 4)
+        assert fromstring("123.0d0") == as_number(123.0, 8)
+        assert fromstring("123d0") == as_number(123.0, 8)
+        assert fromstring("123e-0") == as_number(123.0, 4)
+        assert fromstring("123d+0") == as_number(123.0, 8)
+        assert fromstring("123.0_myrealkind") == as_number(123.0, "myrealkind")
+        assert fromstring("3E4") == as_number(30000.0, 4)
+
+        assert fromstring("(1, 2)") == as_complex(1, 2)
+        assert fromstring("(1e2, PI)") == as_complex(as_number(100.0),
+                                                     as_symbol("PI"))
+
+        assert fromstring("[1, 2]") == as_array((as_number(1), as_number(2)))
+
+        assert fromstring("POINT(x, y=1)") == as_apply(as_symbol("POINT"),
+                                                       x,
+                                                       y=as_number(1))
+        assert fromstring(
+            'PERSON(name="John", age=50, shape=(/34, 23/))') == as_apply(
+                as_symbol("PERSON"),
+                name=as_string('"John"'),
+                age=as_number(50),
+                shape=as_array((as_number(34), as_number(23))),
+            )
+
+        assert fromstring("x?y:z") == as_ternary(x, y, z)
+
+        assert fromstring("*x") == as_deref(x)
+        assert fromstring("**x") == as_deref(as_deref(x))
+        assert fromstring("&x") == as_ref(x)
+        assert fromstring("(*x) * (*y)") == as_deref(x) * as_deref(y)
+        assert fromstring("(*x) * *y") == as_deref(x) * as_deref(y)
+        assert fromstring("*x * *y") == as_deref(x) * as_deref(y)
+        assert fromstring("*x**y") == as_deref(x) * as_deref(y)
+
+        assert fromstring("x == y") == as_eq(x, y)
+        assert fromstring("x != y") == as_ne(x, y)
+        assert fromstring("x < y") == as_lt(x, y)
+        assert fromstring("x > y") == as_gt(x, y)
+        assert fromstring("x <= y") == as_le(x, y)
+        assert fromstring("x >= y") == as_ge(x, y)
+
+        assert fromstring("x .eq. y", language=Language.Fortran) == as_eq(x, y)
+        assert fromstring("x .ne. y", language=Language.Fortran) == as_ne(x, y)
+        assert fromstring("x .lt. y", language=Language.Fortran) == as_lt(x, y)
+        assert fromstring("x .gt. y", language=Language.Fortran) == as_gt(x, y)
+        assert fromstring("x .le. y", language=Language.Fortran) == as_le(x, y)
+        assert fromstring("x .ge. y", language=Language.Fortran) == as_ge(x, y)
 
     def test_traverse(self):
-        x = as_symbol('x')
-        y = as_symbol('y')
-        z = as_symbol('z')
-        f = as_symbol('f')
+        x = as_symbol("x")
+        y = as_symbol("y")
+        z = as_symbol("z")
+        f = as_symbol("f")
 
         # Use traverse to substitute a symbol
         def replace_visit(s, r=z):
@@ -373,8 +404,9 @@ def replace_visit(s, r=z):
         assert (f[y]).traverse(replace_visit) == f[y]
         assert (f[z]).traverse(replace_visit) == f[z]
         assert (x + y + z).traverse(replace_visit) == (2 * z + y)
-        assert (x + f(y, x - z)).traverse(
-            replace_visit) == (z + f(y, as_number(0)))
+        assert (x +
+                f(y, x - z)).traverse(replace_visit) == (z +
+                                                         f(y, as_number(0)))
         assert as_eq(x, y).traverse(replace_visit) == as_eq(z, y)
 
         # Use traverse to collect symbols, method 1
@@ -416,28 +448,28 @@ def collect_symbols3(expr, symbols):
         assert symbols == {x}
 
     def test_linear_solve(self):
-        x = as_symbol('x')
-        y = as_symbol('y')
-        z = as_symbol('z')
+        x = as_symbol("x")
+        y = as_symbol("y")
+        z = as_symbol("z")
 
         assert x.linear_solve(x) == (as_number(1), as_number(0))
-        assert (x+1).linear_solve(x) == (as_number(1), as_number(1))
-        assert (2*x).linear_solve(x) == (as_number(2), as_number(0))
-        assert (2*x+3).linear_solve(x) == (as_number(2), as_number(3))
+        assert (x + 1).linear_solve(x) == (as_number(1), as_number(1))
+        assert (2 * x).linear_solve(x) == (as_number(2), as_number(0))
+        assert (2 * x + 3).linear_solve(x) == (as_number(2), as_number(3))
         assert as_number(3).linear_solve(x) == (as_number(0), as_number(3))
         assert y.linear_solve(x) == (as_number(0), y)
-        assert (y*z).linear_solve(x) == (as_number(0), y * z)
+        assert (y * z).linear_solve(x) == (as_number(0), y * z)
 
-        assert (x+y).linear_solve(x) == (as_number(1), y)
-        assert (z*x+y).linear_solve(x) == (z, y)
-        assert ((z+y)*x+y).linear_solve(x) == (z + y, y)
-        assert (z*y*x+y).linear_solve(x) == (z * y, y)
+        assert (x + y).linear_solve(x) == (as_number(1), y)
+        assert (z * x + y).linear_solve(x) == (z, y)
+        assert ((z + y) * x + y).linear_solve(x) == (z + y, y)
+        assert (z * y * x + y).linear_solve(x) == (z * y, y)
 
-        assert_raises(RuntimeError, lambda: (x*x).linear_solve(x))
+        pytest.raises(RuntimeError, lambda: (x * x).linear_solve(x))
 
     def test_as_numer_denom(self):
-        x = as_symbol('x')
-        y = as_symbol('y')
+        x = as_symbol("x")
+        y = as_symbol("y")
         n = as_number(123)
 
         assert as_numer_denom(x) == (x, as_number(1))
@@ -446,11 +478,11 @@ def test_as_numer_denom(self):
         assert as_numer_denom(x / y) == (x, y)
         assert as_numer_denom(x * y) == (x * y, as_number(1))
         assert as_numer_denom(n + x / y) == (x + n * y, y)
-        assert as_numer_denom(n + x / (y - x / n)) == (y * n ** 2, y * n - x)
+        assert as_numer_denom(n + x / (y - x / n)) == (y * n**2, y * n - x)
 
     def test_polynomial_atoms(self):
-        x = as_symbol('x')
-        y = as_symbol('y')
+        x = as_symbol("x")
+        y = as_symbol("y")
         n = as_number(123)
 
         assert x.polynomial_atoms() == {x}
@@ -459,4 +491,4 @@ def test_polynomial_atoms(self):
         assert (y(x)).polynomial_atoms() == {y(x)}
         assert (y(x) + x).polynomial_atoms() == {y(x), x}
         assert (y(x) * x[y]).polynomial_atoms() == {y(x), x[y]}
-        assert (y(x) ** x).polynomial_atoms() == {y(x)}
+        assert (y(x)**x).polynomial_atoms() == {y(x)}
diff --git a/numpy/f2py/tests/test_value_attrspec.py b/numpy/f2py/tests/test_value_attrspec.py
new file mode 100644
index 000000000000..83aaf6c9161e
--- /dev/null
+++ b/numpy/f2py/tests/test_value_attrspec.py
@@ -0,0 +1,14 @@
+import os
+import pytest
+
+from . import util
+
+class TestValueAttr(util.F2PyTest):
+    sources = [util.getpath("tests", "src", "value_attrspec", "gh21665.f90")]
+
+    # gh-21665
+    def test_long_long_map(self):
+        inp = 2
+        out = self.module.fortfuncs.square(inp)
+        exp_out = 4
+        assert out == exp_out
diff --git a/numpy/f2py/tests/util.py b/numpy/f2py/tests/util.py
index 1a6805e751cd..1534c4e7dfef 100644
--- a/numpy/f2py/tests/util.py
+++ b/numpy/f2py/tests/util.py
@@ -3,6 +3,7 @@
 
 - building and importing modules on test time, using a temporary location
 - detecting if compilers are present
+- determining paths to tests
 
 """
 import os
@@ -14,9 +15,12 @@
 import textwrap
 import re
 import pytest
+import contextlib
+import numpy
 
+from pathlib import Path
 from numpy.compat import asbytes, asstr
-from numpy.testing import temppath
+from numpy.testing import temppath, IS_WASM
 from importlib import import_module
 
 #
@@ -54,7 +58,7 @@ def get_module_dir():
 def get_temp_module_name():
     # Assume single-threaded, and the module dir usable only by this thread
     global _module_num
-    d = get_module_dir()
+    get_module_dir()
     name = "_test_ext_module_%d" % _module_num
     _module_num += 1
     if name in sys.modules:
@@ -78,9 +82,11 @@ def wrapper(*a, **kw):
         if isinstance(ret, Exception):
             raise ret
         return ret
+
     wrapper.__name__ = func.__name__
     return wrapper
 
+
 #
 # Building modules
 #
@@ -93,8 +99,7 @@ def build_module(source_files, options=[], skip=[], only=[], module_name=None):
 
     """
 
-    code = ("import sys; sys.path = %s; import numpy.f2py as f2py2e; "
-            "f2py2e.main()" % repr(sys.path))
+    code = f"import sys; sys.path = {sys.path!r}; import numpy.f2py; numpy.f2py.main()"
 
     d = get_module_dir()
 
@@ -109,29 +114,32 @@ def build_module(source_files, options=[], skip=[], only=[], module_name=None):
         dst_sources.append(dst)
 
         base, ext = os.path.splitext(dst)
-        if ext in ('.f90', '.f', '.c', '.pyf'):
+        if ext in (".f90", ".f", ".c", ".pyf"):
             f2py_sources.append(dst)
 
+    assert f2py_sources
+
     # Prepare options
     if module_name is None:
         module_name = get_temp_module_name()
-    f2py_opts = ['-c', '-m', module_name] + options + f2py_sources
+    f2py_opts = ["-c", "-m", module_name] + options + f2py_sources
     if skip:
-        f2py_opts += ['skip:'] + skip
+        f2py_opts += ["skip:"] + skip
     if only:
-        f2py_opts += ['only:'] + only
+        f2py_opts += ["only:"] + only
 
     # Build
     cwd = os.getcwd()
     try:
         os.chdir(d)
-        cmd = [sys.executable, '-c', code] + f2py_opts
-        p = subprocess.Popen(cmd, stdout=subprocess.PIPE,
+        cmd = [sys.executable, "-c", code] + f2py_opts
+        p = subprocess.Popen(cmd,
+                             stdout=subprocess.PIPE,
                              stderr=subprocess.STDOUT)
         out, err = p.communicate()
         if p.returncode != 0:
-            raise RuntimeError("Running f2py failed: %s\n%s"
-                               % (cmd[4:], asstr(out)))
+            raise RuntimeError("Running f2py failed: %s\n%s" %
+                               (cmd[4:], asstr(out)))
     finally:
         os.chdir(cwd)
 
@@ -144,20 +152,28 @@ def build_module(source_files, options=[], skip=[], only=[], module_name=None):
 
 
 @_memoize
-def build_code(source_code, options=[], skip=[], only=[], suffix=None,
+def build_code(source_code,
+               options=[],
+               skip=[],
+               only=[],
+               suffix=None,
                module_name=None):
     """
     Compile and import Fortran code using f2py.
 
     """
     if suffix is None:
-        suffix = '.f'
+        suffix = ".f"
     with temppath(suffix=suffix) as path:
-        with open(path, 'w') as f:
+        with open(path, "w") as f:
             f.write(source_code)
-        return build_module([path], options=options, skip=skip, only=only,
+        return build_module([path],
+                            options=options,
+                            skip=skip,
+                            only=only,
                             module_name=module_name)
 
+
 #
 # Check if compilers are available at all...
 #
@@ -171,13 +187,16 @@ def _get_compiler_status():
         return _compiler_status
 
     _compiler_status = (False, False, False)
+    if IS_WASM:
+        # Can't run compiler from inside WASM.
+        return _compiler_status
 
     # XXX: this is really ugly. But I don't know how to invoke Distutils
     #      in a safer way...
-    code = textwrap.dedent("""\
+    code = textwrap.dedent(f"""\
         import os
         import sys
-        sys.path = %(syspath)s
+        sys.path = {repr(sys.path)}
 
         def configuration(parent_name='',top_path=None):
             global config
@@ -189,7 +208,7 @@ def configuration(parent_name='',top_path=None):
         setup(configuration=configuration)
 
         config_cmd = config.get_config_cmd()
-        have_c = config_cmd.try_compile('void foo() {}')
+        have_c = config_cmd.try_compile('void foo() {{}}')
         print('COMPILERS:%%d,%%d,%%d' %% (have_c,
                                           config.have_f77c(),
                                           config.have_f90c()))
@@ -199,23 +218,27 @@ def configuration(parent_name='',top_path=None):
 
     tmpdir = tempfile.mkdtemp()
     try:
-        script = os.path.join(tmpdir, 'setup.py')
+        script = os.path.join(tmpdir, "setup.py")
 
-        with open(script, 'w') as f:
+        with open(script, "w") as f:
             f.write(code)
 
-        cmd = [sys.executable, 'setup.py', 'config']
-        p = subprocess.Popen(cmd, stdout=subprocess.PIPE,
+        cmd = [sys.executable, "setup.py", "config"]
+        p = subprocess.Popen(cmd,
+                             stdout=subprocess.PIPE,
                              stderr=subprocess.STDOUT,
                              cwd=tmpdir)
         out, err = p.communicate()
     finally:
         shutil.rmtree(tmpdir)
 
-    m = re.search(br'COMPILERS:(\d+),(\d+),(\d+)', out)
+    m = re.search(br"COMPILERS:(\d+),(\d+),(\d+)", out)
     if m:
-        _compiler_status = (bool(int(m.group(1))), bool(int(m.group(2))),
-                            bool(int(m.group(3))))
+        _compiler_status = (
+            bool(int(m.group(1))),
+            bool(int(m.group(2))),
+            bool(int(m.group(3))),
+        )
     # Finished
     return _compiler_status
 
@@ -231,6 +254,7 @@ def has_f77_compiler():
 def has_f90_compiler():
     return _get_compiler_status()[2]
 
+
 #
 # Building with distutils
 #
@@ -256,38 +280,38 @@ def build_module_distutils(source_files, config_code, module_name, **kw):
     # Build script
     config_code = textwrap.dedent(config_code).replace("\n", "\n    ")
 
-    code = textwrap.dedent("""\
-        import os
-        import sys
-        sys.path = %(syspath)s
-
-        def configuration(parent_name='',top_path=None):
-            from numpy.distutils.misc_util import Configuration
-            config = Configuration('', parent_name, top_path)
-            %(config_code)s
-            return config
+    code = fr"""
+import os
+import sys
+sys.path = {repr(sys.path)}
 
-        if __name__ == "__main__":
-            from numpy.distutils.core import setup
-            setup(configuration=configuration)
-        """) % dict(config_code=config_code, syspath=repr(sys.path))
+def configuration(parent_name='',top_path=None):
+    from numpy.distutils.misc_util import Configuration
+    config = Configuration('', parent_name, top_path)
+    {config_code}
+    return config
 
-    script = os.path.join(d, get_temp_module_name() + '.py')
+if __name__ == "__main__":
+    from numpy.distutils.core import setup
+    setup(configuration=configuration)
+    """
+    script = os.path.join(d, get_temp_module_name() + ".py")
     dst_sources.append(script)
-    with open(script, 'wb') as f:
+    with open(script, "wb") as f:
         f.write(asbytes(code))
 
     # Build
     cwd = os.getcwd()
     try:
         os.chdir(d)
-        cmd = [sys.executable, script, 'build_ext', '-i']
-        p = subprocess.Popen(cmd, stdout=subprocess.PIPE,
+        cmd = [sys.executable, script, "build_ext", "-i"]
+        p = subprocess.Popen(cmd,
+                             stdout=subprocess.PIPE,
                              stderr=subprocess.STDOUT)
         out, err = p.communicate()
         if p.returncode != 0:
-            raise RuntimeError("Running distutils build failed: %s\n%s"
-                               % (cmd[4:], asstr(out)))
+            raise RuntimeError("Running distutils build failed: %s\n%s" %
+                               (cmd[4:], asstr(out)))
     finally:
         os.chdir(cwd)
 
@@ -299,6 +323,7 @@ def configuration(parent_name='',top_path=None):
     __import__(module_name)
     return sys.modules[module_name]
 
+
 #
 # Unittest convenience
 #
@@ -310,13 +335,17 @@ class F2PyTest:
     options = []
     skip = []
     only = []
-    suffix = '.f'
+    suffix = ".f"
     module = None
-    module_name = None
 
-    def setup(self):
-        if sys.platform == 'win32':
-            pytest.skip('Fails with MinGW64 Gfortran (Issue #9673)')
+    @property
+    def module_name(self):
+        cls = type(self)
+        return f'_{cls.__module__.rsplit(".",1)[-1]}_{cls.__name__}_ext_module'
+
+    def setup_method(self):
+        if sys.platform == "win32":
+            pytest.skip("Fails with MinGW64 Gfortran (Issue #9673)")
 
         if self.module is not None:
             return
@@ -333,24 +362,58 @@ def setup(self):
 
         needs_f77 = False
         needs_f90 = False
+        needs_pyf = False
         for fn in codes:
-            if fn.endswith('.f'):
+            if str(fn).endswith(".f"):
                 needs_f77 = True
-            elif fn.endswith('.f90'):
+            elif str(fn).endswith(".f90"):
                 needs_f90 = True
+            elif str(fn).endswith(".pyf"):
+                needs_pyf = True
         if needs_f77 and not has_f77_compiler():
             pytest.skip("No Fortran 77 compiler available")
         if needs_f90 and not has_f90_compiler():
             pytest.skip("No Fortran 90 compiler available")
+        if needs_pyf and not (has_f90_compiler() or has_f77_compiler()):
+            pytest.skip("No Fortran compiler available")
 
         # Build the module
         if self.code is not None:
-            self.module = build_code(self.code, options=self.options,
-                                     skip=self.skip, only=self.only,
-                                     suffix=self.suffix,
-                                     module_name=self.module_name)
+            self.module = build_code(
+                self.code,
+                options=self.options,
+                skip=self.skip,
+                only=self.only,
+                suffix=self.suffix,
+                module_name=self.module_name,
+            )
 
         if self.sources is not None:
-            self.module = build_module(self.sources, options=self.options,
-                                       skip=self.skip, only=self.only,
-                                       module_name=self.module_name)
+            self.module = build_module(
+                self.sources,
+                options=self.options,
+                skip=self.skip,
+                only=self.only,
+                module_name=self.module_name,
+            )
+
+
+#
+# Helper functions
+#
+
+
+def getpath(*a):
+    # Package root
+    d = Path(numpy.f2py.__file__).parent.resolve()
+    return d.joinpath(*a)
+
+
+@contextlib.contextmanager
+def switchdir(path):
+    curpath = Path.cwd()
+    os.chdir(path)
+    try:
+        yield
+    finally:
+        os.chdir(curpath)
diff --git a/numpy/fft/__init__.pyi b/numpy/fft/__init__.pyi
index 510e576d3806..5518aac16b00 100644
--- a/numpy/fft/__init__.pyi
+++ b/numpy/fft/__init__.pyi
@@ -1,5 +1,3 @@
-from typing import Any, List
-
 from numpy._pytesttester import PytestTester
 
 from numpy.fft._pocketfft import (
@@ -26,6 +24,6 @@ from numpy.fft.helper import (
     rfftfreq as rfftfreq,
 )
 
-__all__: List[str]
-__path__: List[str]
+__all__: list[str]
+__path__: list[str]
 test: PytestTester
diff --git a/numpy/fft/_pocketfft.c b/numpy/fft/_pocketfft.c
index 1eb2eba18c46..86de57bd3e8b 100644
--- a/numpy/fft/_pocketfft.c
+++ b/numpy/fft/_pocketfft.c
@@ -22,8 +22,6 @@
 #include 
 #include 
 
-#define restrict NPY_RESTRICT
-
 #define RALLOC(type,num) \
   ((type *)malloc((num)*sizeof(type)))
 #define DEALLOC(ptr) \
diff --git a/numpy/fft/_pocketfft.pyi b/numpy/fft/_pocketfft.pyi
index 86cf6a60d84e..2bd8b0ba34af 100644
--- a/numpy/fft/_pocketfft.pyi
+++ b/numpy/fft/_pocketfft.pyi
@@ -1,15 +1,12 @@
-from typing import (
-    Literal as L,
-    List,
-    Sequence,
-)
+from collections.abc import Sequence
+from typing import Literal as L
 
 from numpy import complex128, float64
-from numpy.typing import ArrayLike, NDArray, _ArrayLikeNumber_co
+from numpy._typing import ArrayLike, NDArray, _ArrayLikeNumber_co
 
 _NormKind = L[None, "backward", "ortho", "forward"]
 
-__all__: List[str]
+__all__: list[str]
 
 def fft(
     a: ArrayLike,
diff --git a/numpy/fft/helper.pyi b/numpy/fft/helper.pyi
index d75826f4e03e..9b65251900a3 100644
--- a/numpy/fft/helper.pyi
+++ b/numpy/fft/helper.pyi
@@ -1,21 +1,18 @@
-from typing import List, Any, TypeVar, overload
+from typing import Any, TypeVar, overload
 
-from numpy import generic, dtype, integer, floating, complexfloating
-from numpy.typing import (
+from numpy import generic, integer, floating, complexfloating
+from numpy._typing import (
     NDArray,
     ArrayLike,
     _ShapeLike,
-    _SupportsArray,
-    _FiniteNestedSequence,
+    _ArrayLike,
     _ArrayLikeFloat_co,
     _ArrayLikeComplex_co,
 )
 
 _SCT = TypeVar("_SCT", bound=generic)
 
-_ArrayLike = _FiniteNestedSequence[_SupportsArray[dtype[_SCT]]]
-
-__all__: List[str]
+__all__: list[str]
 
 @overload
 def fftshift(x: _ArrayLike[_SCT], axes: None | _ShapeLike = ...) -> NDArray[_SCT]: ...
@@ -30,21 +27,21 @@ def ifftshift(x: ArrayLike, axes: None | _ShapeLike = ...) -> NDArray[Any]: ...
 @overload
 def fftfreq(
     n: int | integer[Any],
-    d: _ArrayLikeFloat_co,
+    d: _ArrayLikeFloat_co = ...,
 ) -> NDArray[floating[Any]]: ...
 @overload
 def fftfreq(
     n: int | integer[Any],
-    d: _ArrayLikeComplex_co,
+    d: _ArrayLikeComplex_co = ...,
 ) -> NDArray[complexfloating[Any, Any]]: ...
 
 @overload
 def rfftfreq(
     n: int | integer[Any],
-    d: _ArrayLikeFloat_co,
+    d: _ArrayLikeFloat_co = ...,
 ) -> NDArray[floating[Any]]: ...
 @overload
 def rfftfreq(
     n: int | integer[Any],
-    d: _ArrayLikeComplex_co,
+    d: _ArrayLikeComplex_co = ...,
 ) -> NDArray[complexfloating[Any, Any]]: ...
diff --git a/numpy/fft/tests/test_pocketfft.py b/numpy/fft/tests/test_pocketfft.py
index 392644237e0b..122a9fac93ec 100644
--- a/numpy/fft/tests/test_pocketfft.py
+++ b/numpy/fft/tests/test_pocketfft.py
@@ -2,7 +2,7 @@
 import pytest
 from numpy.random import random
 from numpy.testing import (
-        assert_array_equal, assert_raises, assert_allclose
+        assert_array_equal, assert_raises, assert_allclose, IS_WASM
         )
 import threading
 import queue
@@ -268,6 +268,7 @@ def test_fft_with_order(dtype, order, fft):
         raise ValueError()
 
 
+@pytest.mark.skipif(IS_WASM, reason="Cannot start thread")
 class TestFFTThreadSafe:
     threads = 16
     input_shape = (800, 200)
diff --git a/numpy/lib/__init__.py b/numpy/lib/__init__.py
index ad88ba3478e6..58166d4b1d0f 100644
--- a/numpy/lib/__init__.py
+++ b/numpy/lib/__init__.py
@@ -21,6 +21,24 @@
 from . import scimath as emath
 
 # Private submodules
+# load module names. See https://github.com/networkx/networkx/issues/5838
+from . import type_check
+from . import index_tricks
+from . import function_base
+from . import nanfunctions
+from . import shape_base
+from . import stride_tricks
+from . import twodim_base
+from . import ufunclike
+from . import histograms
+from . import polynomial
+from . import utils
+from . import arraysetops
+from . import npyio
+from . import arrayterator
+from . import arraypad
+from . import _version
+
 from .type_check import *
 from .index_tricks import *
 from .function_base import *
diff --git a/numpy/lib/__init__.pyi b/numpy/lib/__init__.pyi
index ae23b2ec4980..d3553bbcca7b 100644
--- a/numpy/lib/__init__.pyi
+++ b/numpy/lib/__init__.pyi
@@ -1,5 +1,5 @@
 import math as math
-from typing import Any, List
+from typing import Any
 
 from numpy._pytesttester import PytestTester
 
@@ -14,7 +14,7 @@ from numpy.lib import (
     format as format,
     mixins as mixins,
     scimath as scimath,
-    stride_tricks as stride_stricks,
+    stride_tricks as stride_tricks,
 )
 
 from numpy.lib._version import (
@@ -64,7 +64,6 @@ from numpy.lib.function_base import (
     digitize as digitize,
     cov as cov,
     corrcoef as corrcoef,
-    msort as msort,
     median as median,
     sinc as sinc,
     hamming as hamming,
@@ -231,14 +230,15 @@ from numpy.lib.utils import (
     lookfor as lookfor,
     byte_bounds as byte_bounds,
     safe_eval as safe_eval,
+    show_runtime as show_runtime,
 )
 
 from numpy.core.multiarray import (
     tracemalloc_domain as tracemalloc_domain,
 )
 
-__all__: List[str]
-__path__: List[str]
+__all__: list[str]
+__path__: list[str]
 test: PytestTester
 
 __version__ = version
diff --git a/numpy/lib/_datasource.py b/numpy/lib/_datasource.py
index 8201d3772887..b7778234e859 100644
--- a/numpy/lib/_datasource.py
+++ b/numpy/lib/_datasource.py
@@ -280,8 +280,9 @@ def _iswritemode(self, mode):
     def _splitzipext(self, filename):
         """Split zip extension from filename and return filename.
 
-        *Returns*:
-            base, zip_ext : {tuple}
+        Returns
+        -------
+        base, zip_ext : {tuple}
 
         """
 
diff --git a/numpy/lib/_version.pyi b/numpy/lib/_version.pyi
index 3581d639bcdd..1c82c99b686e 100644
--- a/numpy/lib/_version.pyi
+++ b/numpy/lib/_version.pyi
@@ -1,6 +1,4 @@
-from typing import Union, List
-
-__all__: List[str]
+__all__: list[str]
 
 class NumpyVersion:
     vstring: str
@@ -11,9 +9,9 @@ class NumpyVersion:
     pre_release: str
     is_devversion: bool
     def __init__(self, vstring: str) -> None: ...
-    def __lt__(self, other: Union[str, NumpyVersion]) -> bool: ...
-    def __le__(self, other: Union[str, NumpyVersion]) -> bool: ...
-    def __eq__(self, other: Union[str, NumpyVersion]) -> bool: ...  # type: ignore[override]
-    def __ne__(self, other: Union[str, NumpyVersion]) -> bool: ...  # type: ignore[override]
-    def __gt__(self, other: Union[str, NumpyVersion]) -> bool: ...
-    def __ge__(self, other: Union[str, NumpyVersion]) -> bool: ...
+    def __lt__(self, other: str | NumpyVersion) -> bool: ...
+    def __le__(self, other: str | NumpyVersion) -> bool: ...
+    def __eq__(self, other: str | NumpyVersion) -> bool: ...  # type: ignore[override]
+    def __ne__(self, other: str | NumpyVersion) -> bool: ...  # type: ignore[override]
+    def __gt__(self, other: str | NumpyVersion) -> bool: ...
+    def __ge__(self, other: str | NumpyVersion) -> bool: ...
diff --git a/numpy/lib/arraypad.py b/numpy/lib/arraypad.py
index 8830b814743c..28123246dc23 100644
--- a/numpy/lib/arraypad.py
+++ b/numpy/lib/arraypad.py
@@ -537,11 +537,12 @@ def pad(array, pad_width, mode='constant', **kwargs):
         The array to pad.
     pad_width : {sequence, array_like, int}
         Number of values padded to the edges of each axis.
-        ((before_1, after_1), ... (before_N, after_N)) unique pad widths
+        ``((before_1, after_1), ... (before_N, after_N))`` unique pad widths
         for each axis.
-        ((before, after),) yields same before and after pad for each axis.
-        (pad,) or int is a shortcut for before = after = pad width for all
-        axes.
+        ``(before, after)`` or ``((before, after),)`` yields same before
+        and after pad for each axis.
+        ``(pad,)`` or ``int`` is a shortcut for before = after = pad width
+        for all axes.
     mode : str or function, optional
         One of the following string values or a user supplied function.
 
@@ -586,14 +587,14 @@ def pad(array, pad_width, mode='constant', **kwargs):
         Used in 'maximum', 'mean', 'median', and 'minimum'.  Number of
         values at edge of each axis used to calculate the statistic value.
 
-        ((before_1, after_1), ... (before_N, after_N)) unique statistic
+        ``((before_1, after_1), ... (before_N, after_N))`` unique statistic
         lengths for each axis.
 
-        ((before, after),) yields same before and after statistic lengths
-        for each axis.
+        ``(before, after)`` or ``((before, after),)`` yields same before
+        and after statistic lengths for each axis.
 
-        (stat_length,) or int is a shortcut for before = after = statistic
-        length for all axes.
+        ``(stat_length,)`` or ``int`` is a shortcut for
+        ``before = after = statistic`` length for all axes.
 
         Default is ``None``, to use the entire axis.
     constant_values : sequence or scalar, optional
@@ -603,11 +604,11 @@ def pad(array, pad_width, mode='constant', **kwargs):
         ``((before_1, after_1), ... (before_N, after_N))`` unique pad constants
         for each axis.
 
-        ``((before, after),)`` yields same before and after constants for each
-        axis.
+        ``(before, after)`` or ``((before, after),)`` yields same before
+        and after constants for each axis.
 
-        ``(constant,)`` or ``constant`` is a shortcut for ``before = after = constant`` for
-        all axes.
+        ``(constant,)`` or ``constant`` is a shortcut for
+        ``before = after = constant`` for all axes.
 
         Default is 0.
     end_values : sequence or scalar, optional
@@ -617,11 +618,11 @@ def pad(array, pad_width, mode='constant', **kwargs):
         ``((before_1, after_1), ... (before_N, after_N))`` unique end values
         for each axis.
 
-        ``((before, after),)`` yields same before and after end values for each
-        axis.
+        ``(before, after)`` or ``((before, after),)`` yields same before
+        and after end values for each axis.
 
-        ``(constant,)`` or ``constant`` is a shortcut for ``before = after = constant`` for
-        all axes.
+        ``(constant,)`` or ``constant`` is a shortcut for
+        ``before = after = constant`` for all axes.
 
         Default is 0.
     reflect_type : {'even', 'odd'}, optional
diff --git a/numpy/lib/arraypad.pyi b/numpy/lib/arraypad.pyi
index d7c5f48445fa..1ac6fc7d91c8 100644
--- a/numpy/lib/arraypad.pyi
+++ b/numpy/lib/arraypad.pyi
@@ -1,22 +1,18 @@
 from typing import (
     Literal as L,
     Any,
-    Dict,
-    List,
     overload,
-    Tuple,
     TypeVar,
     Protocol,
 )
 
-from numpy import ndarray, dtype, generic
+from numpy import generic
 
-from numpy.typing import (
+from numpy._typing import (
     ArrayLike,
     NDArray,
     _ArrayLikeInt,
-    _FiniteNestedSequence,
-    _SupportsArray,
+    _ArrayLike,
 )
 
 _SCT = TypeVar("_SCT", bound=generic)
@@ -25,9 +21,9 @@ class _ModeFunc(Protocol):
     def __call__(
         self,
         vector: NDArray[Any],
-        iaxis_pad_width: Tuple[int, int],
+        iaxis_pad_width: tuple[int, int],
         iaxis: int,
-        kwargs: Dict[str, Any],
+        kwargs: dict[str, Any],
         /,
     ) -> None: ...
 
@@ -45,9 +41,7 @@ _ModeKind = L[
     "empty",
 ]
 
-_ArrayLike = _FiniteNestedSequence[_SupportsArray[dtype[_SCT]]]
-
-__all__: List[str]
+__all__: list[str]
 
 # TODO: In practice each keyword argument is exclusive to one or more
 # specific modes. Consider adding more overloads to express this in the future.
diff --git a/numpy/lib/arraysetops.py b/numpy/lib/arraysetops.py
index bd56b6975669..300bbda26ceb 100644
--- a/numpy/lib/arraysetops.py
+++ b/numpy/lib/arraysetops.py
@@ -131,13 +131,13 @@ def _unpack_tuple(x):
 
 
 def _unique_dispatcher(ar, return_index=None, return_inverse=None,
-                       return_counts=None, axis=None):
+                       return_counts=None, axis=None, *, equal_nan=None):
     return (ar,)
 
 
 @array_function_dispatch(_unique_dispatcher)
 def unique(ar, return_index=False, return_inverse=False,
-           return_counts=False, axis=None):
+           return_counts=False, axis=None, *, equal_nan=True):
     """
     Find the unique elements of an array.
 
@@ -162,9 +162,6 @@ def unique(ar, return_index=False, return_inverse=False,
     return_counts : bool, optional
         If True, also return the number of times each unique item appears
         in `ar`.
-
-        .. versionadded:: 1.9.0
-
     axis : int or None, optional
         The axis to operate on. If None, `ar` will be flattened. If an integer,
         the subarrays indexed by the given axis will be flattened and treated
@@ -175,6 +172,11 @@ def unique(ar, return_index=False, return_inverse=False,
 
         .. versionadded:: 1.13.0
 
+    equal_nan : bool, optional
+        If True, collapses multiple NaN values in the return array into one.
+
+        .. versionadded:: 1.24
+
     Returns
     -------
     unique : ndarray
@@ -269,7 +271,8 @@ def unique(ar, return_index=False, return_inverse=False,
     """
     ar = np.asanyarray(ar)
     if axis is None:
-        ret = _unique1d(ar, return_index, return_inverse, return_counts)
+        ret = _unique1d(ar, return_index, return_inverse, return_counts, 
+                        equal_nan=equal_nan)
         return _unpack_tuple(ret)
 
     # axis was specified and not None
@@ -312,13 +315,13 @@ def reshape_uniq(uniq):
         return uniq
 
     output = _unique1d(consolidated, return_index,
-                       return_inverse, return_counts)
+                       return_inverse, return_counts, equal_nan=equal_nan)
     output = (reshape_uniq(output[0]),) + output[1:]
     return _unpack_tuple(output)
 
 
 def _unique1d(ar, return_index=False, return_inverse=False,
-              return_counts=False):
+              return_counts=False, *, equal_nan=True):
     """
     Find the unique elements of an array, ignoring shape.
     """
@@ -334,7 +337,8 @@ def _unique1d(ar, return_index=False, return_inverse=False,
         aux = ar
     mask = np.empty(aux.shape, dtype=np.bool_)
     mask[:1] = True
-    if aux.shape[0] > 0 and aux.dtype.kind in "cfmM" and np.isnan(aux[-1]):
+    if (equal_nan and aux.shape[0] > 0 and aux.dtype.kind in "cfmM" and
+            np.isnan(aux[-1])):
         if aux.dtype.kind == "c":  # for complex all NaNs are considered equivalent
             aux_firstnan = np.searchsorted(np.isnan(aux), True, side='left')
         else:
@@ -512,12 +516,13 @@ def setxor1d(ar1, ar2, assume_unique=False):
     return aux[flag[1:] & flag[:-1]]
 
 
-def _in1d_dispatcher(ar1, ar2, assume_unique=None, invert=None):
+def _in1d_dispatcher(ar1, ar2, assume_unique=None, invert=None, *,
+                     kind=None):
     return (ar1, ar2)
 
 
 @array_function_dispatch(_in1d_dispatcher)
-def in1d(ar1, ar2, assume_unique=False, invert=False):
+def in1d(ar1, ar2, assume_unique=False, invert=False, *, kind=None):
     """
     Test whether each element of a 1-D array is also present in a second array.
 
@@ -540,6 +545,26 @@ def in1d(ar1, ar2, assume_unique=False, invert=False):
         False where an element of `ar1` is in `ar2` and True otherwise).
         Default is False. ``np.in1d(a, b, invert=True)`` is equivalent
         to (but is faster than) ``np.invert(in1d(a, b))``.
+    kind : {None, 'sort', 'table'}, optional
+        The algorithm to use. This will not affect the final result,
+        but will affect the speed and memory use. The default, None,
+        will select automatically based on memory considerations.
+
+        * If 'sort', will use a mergesort-based approach. This will have
+          a memory usage of roughly 6 times the sum of the sizes of
+          `ar1` and `ar2`, not accounting for size of dtypes.
+        * If 'table', will use a lookup table approach similar
+          to a counting sort. This is only available for boolean and
+          integer arrays. This will have a memory usage of the
+          size of `ar1` plus the max-min value of `ar2`. `assume_unique`
+          has no effect when the 'table' option is used.
+        * If None, will automatically choose 'table' if
+          the required memory allocation is less than or equal to
+          6 times the sum of the sizes of `ar1` and `ar2`,
+          otherwise will use 'sort'. This is done to not use
+          a large amount of memory by default, even though
+          'table' may be faster in most cases. If 'table' is chosen,
+          `assume_unique` will have no effect.
 
         .. versionadded:: 1.8.0
 
@@ -565,6 +590,13 @@ def in1d(ar1, ar2, assume_unique=False, invert=False):
     ``asarray(ar2)`` is an object array rather than the expected array of
     contained values.
 
+    Using ``kind='table'`` tends to be faster than `kind='sort'` if the
+    following relationship is true:
+    ``log10(len(ar2)) > (log10(max(ar2)-min(ar2)) - 2.27) / 0.927``,
+    but may use greater memory. The default value for `kind` will
+    be automatically selected based only on memory usage, so one may
+    manually set ``kind='table'`` if memory constraints can be relaxed.
+
     .. versionadded:: 1.4.0
 
     Examples
@@ -590,6 +622,99 @@ def in1d(ar1, ar2, assume_unique=False, invert=False):
     if ar2.dtype == object:
         ar2 = ar2.reshape(-1, 1)
 
+    if kind not in {None, 'sort', 'table'}:
+        raise ValueError(
+            f"Invalid kind: '{kind}'. Please use None, 'sort' or 'table'.")
+
+    # Can use the table method if all arrays are integers or boolean:
+    is_int_arrays = all(ar.dtype.kind in ("u", "i", "b") for ar in (ar1, ar2))
+    use_table_method = is_int_arrays and kind in {None, 'table'}
+
+    if use_table_method:
+        if ar2.size == 0:
+            if invert:
+                return np.ones_like(ar1, dtype=bool)
+            else:
+                return np.zeros_like(ar1, dtype=bool)
+
+        # Convert booleans to uint8 so we can use the fast integer algorithm
+        if ar1.dtype == bool:
+            ar1 = ar1.astype(np.uint8)
+        if ar2.dtype == bool:
+            ar2 = ar2.astype(np.uint8)
+
+        ar2_min = np.min(ar2)
+        ar2_max = np.max(ar2)
+
+        ar2_range = int(ar2_max) - int(ar2_min)
+
+        # Constraints on whether we can actually use the table method:
+        #  1. Assert memory usage is not too large
+        below_memory_constraint = ar2_range <= 6 * (ar1.size + ar2.size)
+        #  2. Check overflows for (ar2 - ar2_min); dtype=ar2.dtype
+        range_safe_from_overflow = ar2_range <= np.iinfo(ar2.dtype).max
+        #  3. Check overflows for (ar1 - ar2_min); dtype=ar1.dtype
+        if ar1.size > 0:
+            ar1_min = np.min(ar1)
+            ar1_max = np.max(ar1)
+
+            # After masking, the range of ar1 is guaranteed to be
+            # within the range of ar2:
+            ar1_upper = min(int(ar1_max), int(ar2_max))
+            ar1_lower = max(int(ar1_min), int(ar2_min))
+
+            range_safe_from_overflow &= all((
+                ar1_upper - int(ar2_min) <= np.iinfo(ar1.dtype).max,
+                ar1_lower - int(ar2_min) >= np.iinfo(ar1.dtype).min
+            ))
+
+        # Optimal performance is for approximately
+        # log10(size) > (log10(range) - 2.27) / 0.927.
+        # However, here we set the requirement that by default
+        # the intermediate array can only be 6x
+        # the combined memory allocation of the original
+        # arrays. See discussion on 
+        # https://github.com/numpy/numpy/pull/12065.
+
+        if (
+            range_safe_from_overflow and 
+            (below_memory_constraint or kind == 'table')
+        ):
+
+            if invert:
+                outgoing_array = np.ones_like(ar1, dtype=bool)
+            else:
+                outgoing_array = np.zeros_like(ar1, dtype=bool)
+
+            # Make elements 1 where the integer exists in ar2
+            if invert:
+                isin_helper_ar = np.ones(ar2_range + 1, dtype=bool)
+                isin_helper_ar[ar2 - ar2_min] = 0
+            else:
+                isin_helper_ar = np.zeros(ar2_range + 1, dtype=bool)
+                isin_helper_ar[ar2 - ar2_min] = 1
+
+            # Mask out elements we know won't work
+            basic_mask = (ar1 <= ar2_max) & (ar1 >= ar2_min)
+            outgoing_array[basic_mask] = isin_helper_ar[ar1[basic_mask] -
+                                                        ar2_min]
+
+            return outgoing_array
+        elif kind == 'table':  # not range_safe_from_overflow
+            raise RuntimeError(
+                "You have specified kind='table', "
+                "but the range of values in `ar2` or `ar1` exceed the "
+                "maximum integer of the datatype. "
+                "Please set `kind` to None or 'sort'."
+            )
+    elif kind == 'table':
+        raise ValueError(
+            "The 'table' method is only "
+            "supported for boolean or integer arrays. "
+            "Please select 'sort' or None for kind."
+        )
+
+
     # Check if one of the arrays may contain arbitrary objects
     contains_object = ar1.dtype.hasobject or ar2.dtype.hasobject
 
@@ -633,14 +758,16 @@ def in1d(ar1, ar2, assume_unique=False, invert=False):
         return ret[rev_idx]
 
 
-def _isin_dispatcher(element, test_elements, assume_unique=None, invert=None):
+def _isin_dispatcher(element, test_elements, assume_unique=None, invert=None,
+                     *, kind=None):
     return (element, test_elements)
 
 
 @array_function_dispatch(_isin_dispatcher)
-def isin(element, test_elements, assume_unique=False, invert=False):
+def isin(element, test_elements, assume_unique=False, invert=False, *,
+         kind=None):
     """
-    Calculates `element in test_elements`, broadcasting over `element` only.
+    Calculates ``element in test_elements``, broadcasting over `element` only.
     Returns a boolean array of the same shape as `element` that is True
     where an element of `element` is in `test_elements` and False otherwise.
 
@@ -660,6 +787,27 @@ def isin(element, test_elements, assume_unique=False, invert=False):
         calculating `element not in test_elements`. Default is False.
         ``np.isin(a, b, invert=True)`` is equivalent to (but faster
         than) ``np.invert(np.isin(a, b))``.
+    kind : {None, 'sort', 'table'}, optional
+        The algorithm to use. This will not affect the final result,
+        but will affect the speed and memory use. The default, None,
+        will select automatically based on memory considerations.
+
+        * If 'sort', will use a mergesort-based approach. This will have
+          a memory usage of roughly 6 times the sum of the sizes of
+          `ar1` and `ar2`, not accounting for size of dtypes.
+        * If 'table', will use a lookup table approach similar
+          to a counting sort. This is only available for boolean and
+          integer arrays. This will have a memory usage of the
+          size of `ar1` plus the max-min value of `ar2`. `assume_unique`
+          has no effect when the 'table' option is used.
+        * If None, will automatically choose 'table' if
+          the required memory allocation is less than or equal to
+          6 times the sum of the sizes of `ar1` and `ar2`,
+          otherwise will use 'sort'. This is done to not use
+          a large amount of memory by default, even though
+          'table' may be faster in most cases. If 'table' is chosen,
+          `assume_unique` will have no effect.
+
 
     Returns
     -------
@@ -687,6 +835,13 @@ def isin(element, test_elements, assume_unique=False, invert=False):
     of the `array` constructor's way of handling non-sequence collections.
     Converting the set to a list usually gives the desired behavior.
 
+    Using ``kind='table'`` tends to be faster than `kind='sort'` if the
+    following relationship is true:
+    ``log10(len(ar2)) > (log10(max(ar2)-min(ar2)) - 2.27) / 0.927``,
+    but may use greater memory. The default value for `kind` will
+    be automatically selected based only on memory usage, so one may
+    manually set ``kind='table'`` if memory constraints can be relaxed.
+
     .. versionadded:: 1.13.0
 
     Examples
@@ -733,7 +888,7 @@ def isin(element, test_elements, assume_unique=False, invert=False):
     """
     element = np.asarray(element)
     return in1d(element, test_elements, assume_unique=assume_unique,
-                invert=invert).reshape(element.shape)
+                invert=invert, kind=kind).reshape(element.shape)
 
 
 def _union1d_dispatcher(ar1, ar2):
diff --git a/numpy/lib/arraysetops.pyi b/numpy/lib/arraysetops.pyi
index 6f13ec74b82a..aa1310a3210c 100644
--- a/numpy/lib/arraysetops.pyi
+++ b/numpy/lib/arraysetops.pyi
@@ -1,16 +1,12 @@
 from typing import (
     Literal as L,
     Any,
-    List,
-    Union,
     TypeVar,
-    Tuple,
     overload,
     SupportsIndex,
 )
 
 from numpy import (
-    dtype,
     generic,
     number,
     bool_,
@@ -41,11 +37,10 @@ from numpy import (
     void,
 )
 
-from numpy.typing import (
+from numpy._typing import (
     ArrayLike,
     NDArray,
-    _FiniteNestedSequence,
-    _SupportsArray,
+    _ArrayLike,
     _ArrayLikeBool_co,
     _ArrayLikeDT64_co,
     _ArrayLikeTD64_co,
@@ -90,9 +85,7 @@ _SCTNoCast = TypeVar(
     void,
 )
 
-_ArrayLike = _FiniteNestedSequence[_SupportsArray[dtype[_SCT]]]
-
-__all__: List[str]
+__all__: list[str]
 
 @overload
 def ediff1d(
@@ -132,6 +125,8 @@ def unique(
     return_inverse: L[False] = ...,
     return_counts: L[False] = ...,
     axis: None | SupportsIndex = ...,
+    *,
+    equal_nan: bool = ...,
 ) -> NDArray[_SCT]: ...
 @overload
 def unique(
@@ -140,6 +135,8 @@ def unique(
     return_inverse: L[False] = ...,
     return_counts: L[False] = ...,
     axis: None | SupportsIndex = ...,
+    *,
+    equal_nan: bool = ...,
 ) -> NDArray[Any]: ...
 @overload
 def unique(
@@ -148,7 +145,9 @@ def unique(
     return_inverse: L[False] = ...,
     return_counts: L[False] = ...,
     axis: None | SupportsIndex = ...,
-) -> Tuple[NDArray[_SCT], NDArray[intp]]: ...
+    *,
+    equal_nan: bool = ...,
+) -> tuple[NDArray[_SCT], NDArray[intp]]: ...
 @overload
 def unique(
     ar: ArrayLike,
@@ -156,7 +155,9 @@ def unique(
     return_inverse: L[False] = ...,
     return_counts: L[False] = ...,
     axis: None | SupportsIndex = ...,
-) -> Tuple[NDArray[Any], NDArray[intp]]: ...
+    *,
+    equal_nan: bool = ...,
+) -> tuple[NDArray[Any], NDArray[intp]]: ...
 @overload
 def unique(
     ar: _ArrayLike[_SCT],
@@ -164,7 +165,9 @@ def unique(
     return_inverse: L[True] = ...,
     return_counts: L[False] = ...,
     axis: None | SupportsIndex = ...,
-) -> Tuple[NDArray[_SCT], NDArray[intp]]: ...
+    *,
+    equal_nan: bool = ...,
+) -> tuple[NDArray[_SCT], NDArray[intp]]: ...
 @overload
 def unique(
     ar: ArrayLike,
@@ -172,7 +175,9 @@ def unique(
     return_inverse: L[True] = ...,
     return_counts: L[False] = ...,
     axis: None | SupportsIndex = ...,
-) -> Tuple[NDArray[Any], NDArray[intp]]: ...
+    *,
+    equal_nan: bool = ...,
+) -> tuple[NDArray[Any], NDArray[intp]]: ...
 @overload
 def unique(
     ar: _ArrayLike[_SCT],
@@ -180,7 +185,9 @@ def unique(
     return_inverse: L[False] = ...,
     return_counts: L[True] = ...,
     axis: None | SupportsIndex = ...,
-) -> Tuple[NDArray[_SCT], NDArray[intp]]: ...
+    *,
+    equal_nan: bool = ...,
+) -> tuple[NDArray[_SCT], NDArray[intp]]: ...
 @overload
 def unique(
     ar: ArrayLike,
@@ -188,7 +195,9 @@ def unique(
     return_inverse: L[False] = ...,
     return_counts: L[True] = ...,
     axis: None | SupportsIndex = ...,
-) -> Tuple[NDArray[Any], NDArray[intp]]: ...
+    *,
+    equal_nan: bool = ...,
+) -> tuple[NDArray[Any], NDArray[intp]]: ...
 @overload
 def unique(
     ar: _ArrayLike[_SCT],
@@ -196,7 +205,9 @@ def unique(
     return_inverse: L[True] = ...,
     return_counts: L[False] = ...,
     axis: None | SupportsIndex = ...,
-) -> Tuple[NDArray[_SCT], NDArray[intp], NDArray[intp]]: ...
+    *,
+    equal_nan: bool = ...,
+) -> tuple[NDArray[_SCT], NDArray[intp], NDArray[intp]]: ...
 @overload
 def unique(
     ar: ArrayLike,
@@ -204,7 +215,9 @@ def unique(
     return_inverse: L[True] = ...,
     return_counts: L[False] = ...,
     axis: None | SupportsIndex = ...,
-) -> Tuple[NDArray[Any], NDArray[intp], NDArray[intp]]: ...
+    *,
+    equal_nan: bool = ...,
+) -> tuple[NDArray[Any], NDArray[intp], NDArray[intp]]: ...
 @overload
 def unique(
     ar: _ArrayLike[_SCT],
@@ -212,7 +225,9 @@ def unique(
     return_inverse: L[False] = ...,
     return_counts: L[True] = ...,
     axis: None | SupportsIndex = ...,
-) -> Tuple[NDArray[_SCT], NDArray[intp], NDArray[intp]]: ...
+    *,
+    equal_nan: bool = ...,
+) -> tuple[NDArray[_SCT], NDArray[intp], NDArray[intp]]: ...
 @overload
 def unique(
     ar: ArrayLike,
@@ -220,7 +235,9 @@ def unique(
     return_inverse: L[False] = ...,
     return_counts: L[True] = ...,
     axis: None | SupportsIndex = ...,
-) -> Tuple[NDArray[Any], NDArray[intp], NDArray[intp]]: ...
+    *,
+    equal_nan: bool = ...,
+) -> tuple[NDArray[Any], NDArray[intp], NDArray[intp]]: ...
 @overload
 def unique(
     ar: _ArrayLike[_SCT],
@@ -228,7 +245,9 @@ def unique(
     return_inverse: L[True] = ...,
     return_counts: L[True] = ...,
     axis: None | SupportsIndex = ...,
-) -> Tuple[NDArray[_SCT], NDArray[intp], NDArray[intp]]: ...
+    *,
+    equal_nan: bool = ...,
+) -> tuple[NDArray[_SCT], NDArray[intp], NDArray[intp]]: ...
 @overload
 def unique(
     ar: ArrayLike,
@@ -236,7 +255,9 @@ def unique(
     return_inverse: L[True] = ...,
     return_counts: L[True] = ...,
     axis: None | SupportsIndex = ...,
-) -> Tuple[NDArray[Any], NDArray[intp], NDArray[intp]]: ...
+    *,
+    equal_nan: bool = ...,
+) -> tuple[NDArray[Any], NDArray[intp], NDArray[intp]]: ...
 @overload
 def unique(
     ar: _ArrayLike[_SCT],
@@ -244,7 +265,9 @@ def unique(
     return_inverse: L[True] = ...,
     return_counts: L[True] = ...,
     axis: None | SupportsIndex = ...,
-) -> Tuple[NDArray[_SCT], NDArray[intp], NDArray[intp], NDArray[intp]]: ...
+    *,
+    equal_nan: bool = ...,
+) -> tuple[NDArray[_SCT], NDArray[intp], NDArray[intp], NDArray[intp]]: ...
 @overload
 def unique(
     ar: ArrayLike,
@@ -252,7 +275,9 @@ def unique(
     return_inverse: L[True] = ...,
     return_counts: L[True] = ...,
     axis: None | SupportsIndex = ...,
-) -> Tuple[NDArray[Any], NDArray[intp], NDArray[intp], NDArray[intp]]: ...
+    *,
+    equal_nan: bool = ...,
+) -> tuple[NDArray[Any], NDArray[intp], NDArray[intp], NDArray[intp]]: ...
 
 @overload
 def intersect1d(
@@ -274,14 +299,14 @@ def intersect1d(
     ar2: _ArrayLike[_SCTNoCast],
     assume_unique: bool = ...,
     return_indices: L[True] = ...,
-) -> Tuple[NDArray[_SCTNoCast], NDArray[intp], NDArray[intp]]: ...
+) -> tuple[NDArray[_SCTNoCast], NDArray[intp], NDArray[intp]]: ...
 @overload
 def intersect1d(
     ar1: ArrayLike,
     ar2: ArrayLike,
     assume_unique: bool = ...,
     return_indices: L[True] = ...,
-) -> Tuple[NDArray[Any], NDArray[intp], NDArray[intp]]: ...
+) -> tuple[NDArray[Any], NDArray[intp], NDArray[intp]]: ...
 
 @overload
 def setxor1d(
diff --git a/numpy/lib/arrayterator.pyi b/numpy/lib/arrayterator.pyi
index 82c66920640f..aa192fb7c40f 100644
--- a/numpy/lib/arrayterator.pyi
+++ b/numpy/lib/arrayterator.pyi
@@ -1,16 +1,13 @@
+from collections.abc import Generator
 from typing import (
-    List,
     Any,
     TypeVar,
-    Generator,
-    List,
     Union,
-    Tuple,
     overload,
 )
 
 from numpy import ndarray, dtype, generic
-from numpy.typing import DTypeLike
+from numpy._typing import DTypeLike
 
 # TODO: Set a shape bound once we've got proper shape support
 _Shape = TypeVar("_Shape", bound=Any)
@@ -19,10 +16,10 @@ _ScalarType = TypeVar("_ScalarType", bound=generic)
 
 _Index = Union[
     Union[ellipsis, int, slice],
-    Tuple[Union[ellipsis, int, slice], ...],
+    tuple[Union[ellipsis, int, slice], ...],
 ]
 
-__all__: List[str]
+__all__: list[str]
 
 # NOTE: In reality `Arrayterator` does not actually inherit from `ndarray`,
 # but its ``__getattr__` method does wrap around the former and thus has
@@ -31,12 +28,12 @@ __all__: List[str]
 class Arrayterator(ndarray[_Shape, _DType]):
     var: ndarray[_Shape, _DType]  # type: ignore[assignment]
     buf_size: None | int
-    start: List[int]
-    stop: List[int]
-    step: List[int]
+    start: list[int]
+    stop: list[int]
+    step: list[int]
 
     @property  # type: ignore[misc]
-    def shape(self) -> Tuple[int, ...]: ...
+    def shape(self) -> tuple[int, ...]: ...
     @property
     def flat(  # type: ignore[override]
         self: ndarray[Any, dtype[_ScalarType]]
diff --git a/numpy/lib/format.py b/numpy/lib/format.py
index 3967b43eefc2..54fd0b0bc936 100644
--- a/numpy/lib/format.py
+++ b/numpy/lib/format.py
@@ -177,6 +177,8 @@
 MAGIC_LEN = len(MAGIC_PREFIX) + 2
 ARRAY_ALIGN = 64 # plausible values are powers of 2 between 16 and 4096
 BUFFER_SIZE = 2**18  # size of buffer for reading npz files in bytes
+# allow growth within the address space of a 64 bit machine along one axis
+GROWTH_AXIS_MAX_DIGITS = 21  # = len(str(8*2**64-1)) hypothetical int1 dtype
 
 # difference between version 1.0 and 2.0 is a 4 byte (I) header length
 # instead of 2 bytes (H) allowing storage of large structured arrays
@@ -186,6 +188,10 @@
     (3, 0): (' 0 else 0)
+    
     if version is None:
         header = _wrap_header_guess_version(header)
     else:
@@ -466,7 +480,7 @@ def write_array_header_2_0(fp, d):
     """
     _write_array_header(fp, d, (2, 0))
 
-def read_array_header_1_0(fp):
+def read_array_header_1_0(fp, max_header_size=_MAX_HEADER_SIZE):
     """
     Read an array header from a filelike object using the 1.0 file format
     version.
@@ -488,6 +502,10 @@ def read_array_header_1_0(fp):
         contiguous before writing it out.
     dtype : dtype
         The dtype of the file's data.
+    max_header_size : int, optional
+        Maximum allowed size of the header.  Large headers may not be safe
+        to load securely and thus require explicitly passing a larger value.
+        See :py:meth:`ast.literal_eval()` for details.
 
     Raises
     ------
@@ -495,9 +513,10 @@ def read_array_header_1_0(fp):
         If the data is invalid.
 
     """
-    return _read_array_header(fp, version=(1, 0))
+    return _read_array_header(
+            fp, version=(1, 0), max_header_size=max_header_size)
 
-def read_array_header_2_0(fp):
+def read_array_header_2_0(fp, max_header_size=_MAX_HEADER_SIZE):
     """
     Read an array header from a filelike object using the 2.0 file format
     version.
@@ -510,6 +529,10 @@ def read_array_header_2_0(fp):
     ----------
     fp : filelike object
         A file object or something with a `.read()` method like a file.
+    max_header_size : int, optional
+        Maximum allowed size of the header.  Large headers may not be safe
+        to load securely and thus require explicitly passing a larger value.
+        See :py:meth:`ast.literal_eval()` for details.
 
     Returns
     -------
@@ -528,7 +551,8 @@ def read_array_header_2_0(fp):
         If the data is invalid.
 
     """
-    return _read_array_header(fp, version=(2, 0))
+    return _read_array_header(
+            fp, version=(2, 0), max_header_size=max_header_size)
 
 
 def _filter_header(s):
@@ -566,7 +590,7 @@ def _filter_header(s):
     return tokenize.untokenize(tokens)
 
 
-def _read_array_header(fp, version):
+def _read_array_header(fp, version, max_header_size=_MAX_HEADER_SIZE):
     """
     see read_array_header_1_0
     """
@@ -582,6 +606,14 @@ def _read_array_header(fp, version):
     header_length = struct.unpack(hlength_type, hlength_str)[0]
     header = _read_bytes(fp, header_length, "array header")
     header = header.decode(encoding)
+    if len(header) > max_header_size:
+        raise ValueError(
+            f"Header info length ({len(header)}) is large and may not be safe "
+            "to load securely.\n"
+            "To allow loading, adjust `max_header_size` or fully trust "
+            "the `.npy` file using `allow_pickle=True`.\n"
+            "For safety against large resource use or crashes, sandboxing "
+            "may be necessary.")
 
     # The header is a pretty-printed string representation of a literal
     # Python dictionary with trailing newlines padded to a ARRAY_ALIGN byte
@@ -695,7 +727,8 @@ def write_array(fp, array, version=None, allow_pickle=True, pickle_kwargs=None):
                 fp.write(chunk.tobytes('C'))
 
 
-def read_array(fp, allow_pickle=False, pickle_kwargs=None):
+def read_array(fp, allow_pickle=False, pickle_kwargs=None, *,
+               max_header_size=_MAX_HEADER_SIZE):
     """
     Read an array from an NPY file.
 
@@ -714,6 +747,12 @@ def read_array(fp, allow_pickle=False, pickle_kwargs=None):
         Additional keyword arguments to pass to pickle.load. These are only
         useful when loading object arrays saved on Python 2 when using
         Python 3.
+    max_header_size : int, optional
+        Maximum allowed size of the header.  Large headers may not be safe
+        to load securely and thus require explicitly passing a larger value.
+        See :py:meth:`ast.literal_eval()` for details.
+        This option is ignored when `allow_pickle` is passed.  In that case
+        the file is by definition trusted and the limit is unnecessary.
 
     Returns
     -------
@@ -727,9 +766,15 @@ def read_array(fp, allow_pickle=False, pickle_kwargs=None):
         an object array.
 
     """
+    if allow_pickle:
+        # Effectively ignore max_header_size, since `allow_pickle` indicates
+        # that the input is fully trusted.
+        max_header_size = 2**64
+
     version = read_magic(fp)
     _check_version(version)
-    shape, fortran_order, dtype = _read_array_header(fp, version)
+    shape, fortran_order, dtype = _read_array_header(
+            fp, version, max_header_size=max_header_size)
     if len(shape) == 0:
         count = 1
     else:
@@ -789,7 +834,8 @@ def read_array(fp, allow_pickle=False, pickle_kwargs=None):
 
 
 def open_memmap(filename, mode='r+', dtype=None, shape=None,
-                fortran_order=False, version=None):
+                fortran_order=False, version=None, *,
+                max_header_size=_MAX_HEADER_SIZE):
     """
     Open a .npy file as a memory-mapped array.
 
@@ -820,6 +866,10 @@ def open_memmap(filename, mode='r+', dtype=None, shape=None,
         If the mode is a "write" mode, then this is the version of the file
         format used to create the file.  None means use the oldest
         supported version that is able to store the data.  Default: None
+    max_header_size : int, optional
+        Maximum allowed size of the header.  Large headers may not be safe
+        to load securely and thus require explicitly passing a larger value.
+        See :py:meth:`ast.literal_eval()` for details.
 
     Returns
     -------
@@ -867,7 +917,8 @@ def open_memmap(filename, mode='r+', dtype=None, shape=None,
             version = read_magic(fp)
             _check_version(version)
 
-            shape, fortran_order, dtype = _read_array_header(fp, version)
+            shape, fortran_order, dtype = _read_array_header(
+                    fp, version, max_header_size=max_header_size)
             if dtype.hasobject:
                 msg = "Array can't be memory-mapped: Python objects in dtype."
                 raise ValueError(msg)
diff --git a/numpy/lib/format.pyi b/numpy/lib/format.pyi
index 092245daf01f..a4468f52f464 100644
--- a/numpy/lib/format.pyi
+++ b/numpy/lib/format.pyi
@@ -1,8 +1,8 @@
-from typing import Any, List, Set, Literal, Final
+from typing import Any, Literal, Final
 
-__all__: List[str]
+__all__: list[str]
 
-EXPECTED_KEYS: Final[Set[str]]
+EXPECTED_KEYS: Final[set[str]]
 MAGIC_PREFIX: Final[bytes]
 MAGIC_LEN: Literal[8]
 ARRAY_ALIGN: Literal[64]
diff --git a/numpy/lib/function_base.py b/numpy/lib/function_base.py
index a215f63d3040..84b96d54ec33 100644
--- a/numpy/lib/function_base.py
+++ b/numpy/lib/function_base.py
@@ -168,7 +168,7 @@ def rot90(m, k=1, axes=(0, 1)):
         Array of two or more dimensions.
     k : integer
         Number of times the array is rotated by 90 degrees.
-    axes: (2,) array_like
+    axes : (2,) array_like
         The array is rotated in the plane defined by the axes.
         Axes must be different.
 
@@ -388,12 +388,14 @@ def iterable(y):
     return True
 
 
-def _average_dispatcher(a, axis=None, weights=None, returned=None):
+def _average_dispatcher(a, axis=None, weights=None, returned=None, *,
+                        keepdims=None):
     return (a, weights)
 
 
 @array_function_dispatch(_average_dispatcher)
-def average(a, axis=None, weights=None, returned=False):
+def average(a, axis=None, weights=None, returned=False, *,
+            keepdims=np._NoValue):
     """
     Compute the weighted average along the specified axis.
 
@@ -428,6 +430,14 @@ def average(a, axis=None, weights=None, returned=False):
         is returned, otherwise only the average is returned.
         If `weights=None`, `sum_of_weights` is equivalent to the number of
         elements over which the average is taken.
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the original `a`.
+        *Note:* `keepdims` will not work with instances of `numpy.matrix`
+        or other classes whose methods do not support `keepdims`.
+
+        .. versionadded:: 1.23.0
 
     Returns
     -------
@@ -471,7 +481,7 @@ def average(a, axis=None, weights=None, returned=False):
     >>> np.average(np.arange(1, 11), weights=np.arange(10, 0, -1))
     4.0
 
-    >>> data = np.arange(6).reshape((3,2))
+    >>> data = np.arange(6).reshape((3, 2))
     >>> data
     array([[0, 1],
            [2, 3],
@@ -488,12 +498,26 @@ def average(a, axis=None, weights=None, returned=False):
     >>> avg = np.average(a, weights=w)
     >>> print(avg.dtype)
     complex256
+
+    With ``keepdims=True``, the following result has shape (3, 1).
+
+    >>> np.average(data, axis=1, keepdims=True)
+    array([[0.5],
+           [2.5],
+           [4.5]])
     """
     a = np.asanyarray(a)
 
+    if keepdims is np._NoValue:
+        # Don't pass on the keepdims argument if one wasn't given.
+        keepdims_kw = {}
+    else:
+        keepdims_kw = {'keepdims': keepdims}
+
     if weights is None:
-        avg = a.mean(axis)
-        scl = avg.dtype.type(a.size/avg.size)
+        avg = a.mean(axis, **keepdims_kw)
+        avg_as_array = np.asanyarray(avg)
+        scl = avg_as_array.dtype.type(a.size/avg_as_array.size)
     else:
         wgt = np.asanyarray(weights)
 
@@ -519,16 +543,17 @@ def average(a, axis=None, weights=None, returned=False):
             wgt = np.broadcast_to(wgt, (a.ndim-1)*(1,) + wgt.shape)
             wgt = wgt.swapaxes(-1, axis)
 
-        scl = wgt.sum(axis=axis, dtype=result_dtype)
+        scl = wgt.sum(axis=axis, dtype=result_dtype, **keepdims_kw)
         if np.any(scl == 0.0):
             raise ZeroDivisionError(
                 "Weights sum to zero, can't be normalized")
 
-        avg = np.multiply(a, wgt, dtype=result_dtype).sum(axis)/scl
+        avg = avg_as_array = np.multiply(a, wgt,
+                          dtype=result_dtype).sum(axis, **keepdims_kw) / scl
 
     if returned:
-        if scl.shape != avg.shape:
-            scl = np.broadcast_to(scl, avg.shape).copy()
+        if scl.shape != avg_as_array.shape:
+            scl = np.broadcast_to(scl, avg_as_array.shape).copy()
         return avg, scl
     else:
         return avg
@@ -906,7 +931,7 @@ def copy(a, order='K', subok=False):
     >>> b[0] = 3
     >>> b
     array([3, 2, 3])
-    
+
     Note that np.copy is a shallow copy and will not copy object
     elements within arrays. This is mainly important for arrays
     containing Python objects. The new array will contain the
@@ -1656,7 +1681,7 @@ def unwrap(p, discont=None, axis=-1, *, period=2*pi):
         larger than ``period/2``.
     axis : int, optional
         Axis along which unwrap will operate, default is the last axis.
-    period: float, optional
+    period : float, optional
         Size of the range over which the input wraps. By default, it is
         ``2 pi``.
 
@@ -2696,7 +2721,7 @@ def corrcoef(x, y=None, rowvar=True, bias=np._NoValue, ddof=np._NoValue, *,
     relationship between the correlation coefficient matrix, `R`, and the
     covariance matrix, `C`, is
 
-    .. math:: R_{ij} = \\frac{ C_{ij} } { \\sqrt{ C_{ii} * C_{jj} } }
+    .. math:: R_{ij} = \\frac{ C_{ij} } { \\sqrt{ C_{ii} C_{jj} } }
 
     The values of `R` are between -1 and 1, inclusive.
 
@@ -2974,15 +2999,14 @@ def bartlett(M):
               \\frac{M-1}{2} - \\left|n - \\frac{M-1}{2}\\right|
               \\right)
 
-    Most references to the Bartlett window come from the signal
-    processing literature, where it is used as one of many windowing
-    functions for smoothing values.  Note that convolution with this
-    window produces linear interpolation.  It is also known as an
-    apodization (which means"removing the foot", i.e. smoothing
-    discontinuities at the beginning and end of the sampled signal) or
-    tapering function. The fourier transform of the Bartlett is the product
-    of two sinc functions.
-    Note the excellent discussion in Kanasewich.
+    Most references to the Bartlett window come from the signal processing
+    literature, where it is used as one of many windowing functions for
+    smoothing values.  Note that convolution with this window produces linear
+    interpolation.  It is also known as an apodization (which means "removing
+    the foot", i.e. smoothing discontinuities at the beginning and end of the
+    sampled signal) or tapering function. The Fourier transform of the
+    Bartlett window is the product of two sinc functions. Note the excellent
+    discussion in Kanasewich [2]_.
 
     References
     ----------
@@ -3075,7 +3099,7 @@ def hanning(M):
     -----
     The Hanning window is defined as
 
-    .. math::  w(n) = 0.5 - 0.5cos\\left(\\frac{2\\pi{n}}{M-1}\\right)
+    .. math::  w(n) = 0.5 - 0.5\\cos\\left(\\frac{2\\pi{n}}{M-1}\\right)
                \\qquad 0 \\leq n \\leq M-1
 
     The Hanning was named for Julius von Hann, an Austrian meteorologist.
@@ -3179,7 +3203,7 @@ def hamming(M):
     -----
     The Hamming window is defined as
 
-    .. math::  w(n) = 0.54 - 0.46cos\\left(\\frac{2\\pi{n}}{M-1}\\right)
+    .. math::  w(n) = 0.54 - 0.46\\cos\\left(\\frac{2\\pi{n}}{M-1}\\right)
                \\qquad 0 \\leq n \\leq M-1
 
     The Hamming was named for R. W. Hamming, an associate of J. W. Tukey
@@ -3539,20 +3563,22 @@ def sinc(x):
     r"""
     Return the normalized sinc function.
 
-    The sinc function is :math:`\sin(\pi x)/(\pi x)`.
+    The sinc function is equal to :math:`\sin(\pi x)/(\pi x)` for any argument
+    :math:`x\ne 0`. ``sinc(0)`` takes the limit value 1, making ``sinc`` not
+    only everywhere continuous but also infinitely differentiable.
 
     .. note::
 
         Note the normalization factor of ``pi`` used in the definition.
         This is the most commonly used definition in signal processing.
         Use ``sinc(x / np.pi)`` to obtain the unnormalized sinc function
-        :math:`\sin(x)/(x)` that is more common in mathematics.
+        :math:`\sin(x)/x` that is more common in mathematics.
 
     Parameters
     ----------
     x : ndarray
-        Array (possibly multi-dimensional) of values for which to to
-        calculate ``sinc(x)``.
+        Array (possibly multi-dimensional) of values for which to calculate
+        ``sinc(x)``.
 
     Returns
     -------
@@ -3561,8 +3587,6 @@ def sinc(x):
 
     Notes
     -----
-    ``sinc(0)`` is the limit value 1.
-
     The name sinc is short for "sine cardinal" or "sinus cardinalis".
 
     The sinc function is used in various signal processing applications,
@@ -3624,6 +3648,10 @@ def msort(a):
     """
     Return a copy of an array sorted along the first axis.
 
+    .. deprecated:: 1.24
+
+       msort is deprecated, use ``np.sort(a, axis=0)`` instead.
+
     Parameters
     ----------
     a : array_like
@@ -3642,13 +3670,26 @@ def msort(a):
     -----
     ``np.msort(a)`` is equivalent to  ``np.sort(a, axis=0)``.
 
+    Examples
+    --------
+    >>> a = np.array([[1, 4], [3, 1]])
+    >>> np.msort(a)  # sort along the first axis
+    array([[1, 1],
+           [3, 4]])
+
     """
+    # 2022-10-20 1.24
+    warnings.warn(
+        "msort is deprecated, use np.sort(a, axis=0) instead",
+        DeprecationWarning,
+        stacklevel=3,
+    )
     b = array(a, subok=True, copy=True)
     b.sort(0)
     return b
 
 
-def _ureduce(a, func, **kwargs):
+def _ureduce(a, func, keepdims=False, **kwargs):
     """
     Internal Function.
     Call `func` with `a` as first argument swapping the axes to use extended
@@ -3676,13 +3717,20 @@ def _ureduce(a, func, **kwargs):
     """
     a = np.asanyarray(a)
     axis = kwargs.get('axis', None)
+    out = kwargs.get('out', None)
+
+    if keepdims is np._NoValue:
+        keepdims = False
+
+    nd = a.ndim
     if axis is not None:
-        keepdim = list(a.shape)
-        nd = a.ndim
         axis = _nx.normalize_axis_tuple(axis, nd)
 
-        for ax in axis:
-            keepdim[ax] = 1
+        if keepdims:
+            if out is not None:
+                index_out = tuple(
+                    0 if i in axis else slice(None) for i in range(nd))
+                kwargs['out'] = out[(Ellipsis, ) + index_out]
 
         if len(axis) == 1:
             kwargs['axis'] = axis[0]
@@ -3695,12 +3743,27 @@ def _ureduce(a, func, **kwargs):
             # merge reduced axis
             a = a.reshape(a.shape[:nkeep] + (-1,))
             kwargs['axis'] = -1
-        keepdim = tuple(keepdim)
     else:
-        keepdim = (1,) * a.ndim
+        if keepdims:
+            if out is not None:
+                index_out = (0, ) * nd
+                kwargs['out'] = out[(Ellipsis, ) + index_out]
 
     r = func(a, **kwargs)
-    return r, keepdim
+
+    if out is not None:
+        return out
+
+    if keepdims:
+        if axis is None:
+            index_r = (np.newaxis, ) * nd
+        else:
+            index_r = tuple(
+                np.newaxis if i in axis else slice(None)
+                for i in range(nd))
+        r = r[(Ellipsis, ) + index_r]
+
+    return r
 
 
 def _median_dispatcher(
@@ -3790,12 +3853,8 @@ def median(a, axis=None, out=None, overwrite_input=False, keepdims=False):
     >>> assert not np.all(a==b)
 
     """
-    r, k = _ureduce(a, func=_median, axis=axis, out=out,
+    return _ureduce(a, func=_median, keepdims=keepdims, axis=axis, out=out,
                     overwrite_input=overwrite_input)
-    if keepdims:
-        return r.reshape(k)
-    else:
-        return r
 
 
 def _median(a, axis=None, out=None, overwrite_input=False):
@@ -3911,7 +3970,7 @@ def percentile(a,
         8. 'median_unbiased'
         9. 'normal_unbiased'
 
-        The first three methods are discontiuous.  NumPy further defines the
+        The first three methods are discontinuous.  NumPy further defines the
         following discontinuous variations of the default 'linear' (7.) option:
 
         * 'lower'
@@ -3956,7 +4015,7 @@ def percentile(a,
 
     Notes
     -----
-    Given a vector ``V`` of length ``N``, the q-th percentile of ``V`` is
+    Given a vector ``V`` of length ``n``, the q-th percentile of ``V`` is
     the value ``q/100`` of the way from the minimum to the maximum in a
     sorted copy of ``V``. The values and distances of the two nearest
     neighbors as well as the `method` parameter will determine the
@@ -3965,37 +4024,43 @@ def percentile(a,
     same as the minimum if ``q=0`` and the same as the maximum if
     ``q=100``.
 
-    This optional `method` parameter specifies the method to use when the
-    desired quantile lies between two data points ``i < j``.
-    If ``g`` is the fractional part of the index surrounded by ``i`` and
-    alpha and beta are correction constants modifying i and j.
+    The optional `method` parameter specifies the method to use when the
+    desired percentile lies between two indexes ``i`` and ``j = i + 1``.
+    In that case, we first determine ``i + g``, a virtual index that lies
+    between ``i`` and ``j``, where  ``i`` is the floor and ``g`` is the
+    fractional part of the index. The final result is, then, an interpolation
+    of ``a[i]`` and ``a[j]`` based on ``g``. During the computation of ``g``,
+    ``i`` and ``j`` are modified using correction constants ``alpha`` and
+    ``beta`` whose choices depend on the ``method`` used. Finally, note that
+    since Python uses 0-based indexing, the code subtracts another 1 from the
+    index internally.
 
-    Below, 'q' is the quantile value, 'n' is the sample size and
-    alpha and beta are constants.
-    The following formula gives an interpolation "i + g" of where the quantile
-    would be in the sorted sample.
-    With 'i' being the floor and 'g' the fractional part of the result.
+    The following formula determines the virtual index ``i + g``, the location 
+    of the percentile in the sorted sample:
 
     .. math::
-        i + g = (q - alpha) / ( n - alpha - beta + 1 )
+        i + g = (q / 100) * ( n - alpha - beta + 1 ) + alpha
 
     The different methods then work as follows
 
     inverted_cdf:
         method 1 of H&F [1]_.
         This method gives discontinuous results:
+
         * if g > 0 ; then take j
         * if g = 0 ; then take i
 
     averaged_inverted_cdf:
         method 2 of H&F [1]_.
         This method give discontinuous results:
+
         * if g > 0 ; then take j
         * if g = 0 ; then average between bounds
 
     closest_observation:
         method 3 of H&F [1]_.
         This method give discontinuous results:
+
         * if g > 0 ; then take j
         * if g = 0 and index is odd ; then take j
         * if g = 0 and index is even ; then take i
@@ -4003,24 +4068,28 @@ def percentile(a,
     interpolated_inverted_cdf:
         method 4 of H&F [1]_.
         This method give continuous results using:
+
         * alpha = 0
         * beta = 1
 
     hazen:
         method 5 of H&F [1]_.
         This method give continuous results using:
+
         * alpha = 1/2
         * beta = 1/2
 
     weibull:
         method 6 of H&F [1]_.
         This method give continuous results using:
+
         * alpha = 0
         * beta = 0
 
     linear:
         method 7 of H&F [1]_.
         This method give continuous results using:
+
         * alpha = 1
         * beta = 1
 
@@ -4029,6 +4098,7 @@ def percentile(a,
         This method is probably the best method if the sample
         distribution function is unknown (see reference).
         This method give continuous results using:
+
         * alpha = 1/3
         * beta = 1/3
 
@@ -4037,6 +4107,7 @@ def percentile(a,
         This method is probably the best method if the sample
         distribution function is known to be normal.
         This method give continuous results using:
+
         * alpha = 3/8
         * beta = 3/8
 
@@ -4190,7 +4261,7 @@ def quantile(a,
         8. 'median_unbiased'
         9. 'normal_unbiased'
 
-        The first three methods are discontiuous.  NumPy further defines the
+        The first three methods are discontinuous.  NumPy further defines the
         following discontinuous variations of the default 'linear' (7.) option:
 
         * 'lower'
@@ -4233,64 +4304,81 @@ def quantile(a,
 
     Notes
     -----
-    Given a vector ``V`` of length ``N``, the q-th quantile of ``V`` is the
-    value ``q`` of the way from the minimum to the maximum in a sorted copy of
-    ``V``. The values and distances of the two nearest neighbors as well as the
-    `method` parameter will determine the quantile if the normalized
-    ranking does not match the location of ``q`` exactly. This function is the
-    same as the median if ``q=0.5``, the same as the minimum if ``q=0.0`` and
-    the same as the maximum if ``q=1.0``.
-
-    This optional `method` parameter specifies the method to use when the
-    desired quantile lies between two data points ``i < j``.
-    If ``g`` is the fractional part of the index surrounded by ``i`` and
-    alpha and beta are correction constants modifying i and j.
+    Given a vector ``V`` of length ``n``, the q-th quantile of ``V`` is
+    the value ``q`` of the way from the minimum to the maximum in a
+    sorted copy of ``V``. The values and distances of the two nearest
+    neighbors as well as the `method` parameter will determine the
+    quantile if the normalized ranking does not match the location of
+    ``q`` exactly. This function is the same as the median if ``q=0.5``, the
+    same as the minimum if ``q=0.0`` and the same as the maximum if
+    ``q=1.0``.
+
+    The optional `method` parameter specifies the method to use when the
+    desired quantile lies between two indexes ``i`` and ``j = i + 1``.
+    In that case, we first determine ``i + g``, a virtual index that lies
+    between ``i`` and ``j``, where  ``i`` is the floor and ``g`` is the
+    fractional part of the index. The final result is, then, an interpolation
+    of ``a[i]`` and ``a[j]`` based on ``g``. During the computation of ``g``,
+    ``i`` and ``j`` are modified using correction constants ``alpha`` and
+    ``beta`` whose choices depend on the ``method`` used. Finally, note that
+    since Python uses 0-based indexing, the code subtracts another 1 from the
+    index internally.
+
+    The following formula determines the virtual index ``i + g``, the location 
+    of the quantile in the sorted sample:
 
     .. math::
-        i + g = (q - alpha) / ( n - alpha - beta + 1 )
+        i + g = q * ( n - alpha - beta + 1 ) + alpha
 
     The different methods then work as follows
 
     inverted_cdf:
         method 1 of H&F [1]_.
         This method gives discontinuous results:
+
         * if g > 0 ; then take j
         * if g = 0 ; then take i
 
     averaged_inverted_cdf:
         method 2 of H&F [1]_.
-        This method give discontinuous results:
+        This method gives discontinuous results:
+
         * if g > 0 ; then take j
         * if g = 0 ; then average between bounds
 
     closest_observation:
         method 3 of H&F [1]_.
-        This method give discontinuous results:
+        This method gives discontinuous results:
+
         * if g > 0 ; then take j
         * if g = 0 and index is odd ; then take j
         * if g = 0 and index is even ; then take i
 
     interpolated_inverted_cdf:
         method 4 of H&F [1]_.
-        This method give continuous results using:
+        This method gives continuous results using:
+
         * alpha = 0
         * beta = 1
 
     hazen:
         method 5 of H&F [1]_.
-        This method give continuous results using:
+        This method gives continuous results using:
+
         * alpha = 1/2
         * beta = 1/2
 
     weibull:
         method 6 of H&F [1]_.
-        This method give continuous results using:
+        This method gives continuous results using:
+
         * alpha = 0
         * beta = 0
 
     linear:
         method 7 of H&F [1]_.
-        This method give continuous results using:
+        This method gives continuous results using:
+
         * alpha = 1
         * beta = 1
 
@@ -4298,7 +4386,8 @@ def quantile(a,
         method 8 of H&F [1]_.
         This method is probably the best method if the sample
         distribution function is unknown (see reference).
-        This method give continuous results using:
+        This method gives continuous results using:
+
         * alpha = 1/3
         * beta = 1/3
 
@@ -4306,7 +4395,8 @@ def quantile(a,
         method 9 of H&F [1]_.
         This method is probably the best method if the sample
         distribution function is known to be normal.
-        This method give continuous results using:
+        This method gives continuous results using:
+
         * alpha = 3/8
         * beta = 3/8
 
@@ -4380,17 +4470,14 @@ def _quantile_unchecked(a,
                         method="linear",
                         keepdims=False):
     """Assumes that q is in [0, 1], and is an ndarray"""
-    r, k = _ureduce(a,
+    return _ureduce(a,
                     func=_quantile_ureduce_func,
                     q=q,
+                    keepdims=keepdims,
                     axis=axis,
                     out=out,
                     overwrite_input=overwrite_input,
                     method=method)
-    if keepdims:
-        return r.reshape(q.shape + k)
-    else:
-        return r
 
 
 def _quantile_is_valid(q):
@@ -4411,7 +4498,7 @@ def _check_interpolation_as_method(method, interpolation, fname):
         f"the `interpolation=` argument to {fname} was renamed to "
         "`method=`, which has additional options.\n"
         "Users of the modes 'nearest', 'lower', 'higher', or "
-        "'midpoint' are encouraged to review the method they. "
+        "'midpoint' are encouraged to review the method they used. "
         "(Deprecated NumPy 1.22)",
         DeprecationWarning, stacklevel=4)
     if method != "linear":
@@ -4713,10 +4800,10 @@ def trapz(y, x=None, dx=1.0, axis=-1):
     Returns
     -------
     trapz : float or ndarray
-        Definite integral of 'y' = n-dimensional array as approximated along
-        a single axis by the trapezoidal rule. If 'y' is a 1-dimensional array,
-        then the result is a float. If 'n' is greater than 1, then the result
-        is an 'n-1' dimensional array.
+        Definite integral of `y` = n-dimensional array as approximated along
+        a single axis by the trapezoidal rule. If `y` is a 1-dimensional array,
+        then the result is a float. If `n` is greater than 1, then the result
+        is an `n`-1 dimensional array.
 
     See Also
     --------
@@ -4847,9 +4934,9 @@ def meshgrid(*xi, copy=True, sparse=False, indexing='xy'):
     Returns
     -------
     X1, X2,..., XN : ndarray
-        For vectors `x1`, `x2`,..., 'xn' with lengths ``Ni=len(xi)`` ,
-        return ``(N1, N2, N3,...Nn)`` shaped arrays if indexing='ij'
-        or ``(N2, N1, N3,...Nn)`` shaped arrays if indexing='xy'
+        For vectors `x1`, `x2`,..., `xn` with lengths ``Ni=len(xi)``,
+        returns ``(N1, N2, N3,..., Nn)`` shaped arrays if indexing='ij'
+        or ``(N2, N1, N3,..., Nn)`` shaped arrays if indexing='xy'
         with the elements of `xi` repeated to fill the matrix along
         the first dimension for `x1`, the second for `x2` and so on.
 
@@ -4881,6 +4968,7 @@ def meshgrid(*xi, copy=True, sparse=False, indexing='xy'):
     mgrid : Construct a multi-dimensional "meshgrid" using indexing notation.
     ogrid : Construct an open multi-dimensional "meshgrid" using indexing
             notation.
+    how-to-index
 
     Examples
     --------
@@ -4894,20 +4982,29 @@ def meshgrid(*xi, copy=True, sparse=False, indexing='xy'):
     >>> yv
     array([[0.,  0.,  0.],
            [1.,  1.,  1.]])
-    >>> xv, yv = np.meshgrid(x, y, sparse=True)  # make sparse output arrays
+
+    The result of `meshgrid` is a coordinate grid:
+
+    >>> import matplotlib.pyplot as plt
+    >>> plt.plot(xv, yv, marker='o', color='k', linestyle='none')
+    >>> plt.show()
+
+    You can create sparse output arrays to save memory and computation time.
+
+    >>> xv, yv = np.meshgrid(x, y, sparse=True)
     >>> xv
     array([[0. ,  0.5,  1. ]])
     >>> yv
     array([[0.],
            [1.]])
 
-    `meshgrid` is very useful to evaluate functions on a grid.  If the
-    function depends on all coordinates, you can use the parameter
-    ``sparse=True`` to save memory and computation time.
+    `meshgrid` is very useful to evaluate functions on a grid. If the
+    function depends on all coordinates, both dense and sparse outputs can be
+    used.
 
     >>> x = np.linspace(-5, 5, 101)
     >>> y = np.linspace(-5, 5, 101)
-    >>> # full coorindate arrays
+    >>> # full coordinate arrays
     >>> xx, yy = np.meshgrid(x, y)
     >>> zz = np.sqrt(xx**2 + yy**2)
     >>> xx.shape, yy.shape, zz.shape
@@ -4920,7 +5017,6 @@ def meshgrid(*xi, copy=True, sparse=False, indexing='xy'):
     >>> np.array_equal(zz, zs)
     True
 
-    >>> import matplotlib.pyplot as plt
     >>> h = plt.contourf(x, y, zs)
     >>> plt.axis('scaled')
     >>> plt.colorbar()
@@ -4998,7 +5094,7 @@ def delete(arr, obj, axis=None):
     >>> mask[[0,2,4]] = False
     >>> result = arr[mask,...]
 
-    Is equivalent to `np.delete(arr, [0,2,4], axis=0)`, but allows further
+    Is equivalent to ``np.delete(arr, [0,2,4], axis=0)``, but allows further
     use of `mask`.
 
     Examples
@@ -5094,6 +5190,22 @@ def delete(arr, obj, axis=None):
             return new
 
     if isinstance(obj, (int, integer)) and not isinstance(obj, bool):
+        single_value = True
+    else:
+        single_value = False
+        _obj = obj
+        obj = np.asarray(obj)
+        # `size == 0` to allow empty lists similar to indexing, but (as there)
+        # is really too generic:
+        if obj.size == 0 and not isinstance(_obj, np.ndarray):
+            obj = obj.astype(intp)
+        elif obj.size == 1 and obj.dtype.kind in "ui":
+            # For a size 1 integer array we can use the single-value path
+            # (most dtypes, except boolean, should just fail later).
+            obj = obj.item()
+            single_value = True
+
+    if single_value:
         # optimization for a single value
         if (obj < -N or obj >= N):
             raise IndexError(
@@ -5110,11 +5222,6 @@ def delete(arr, obj, axis=None):
         slobj2[axis] = slice(obj+1, None)
         new[tuple(slobj)] = arr[tuple(slobj2)]
     else:
-        _obj = obj
-        obj = np.asarray(obj)
-        if obj.size == 0 and not isinstance(_obj, np.ndarray):
-            obj = obj.astype(intp)
-
         if obj.dtype == bool:
             if obj.shape != (N,):
                 raise ValueError('boolean array argument obj to delete '
@@ -5182,9 +5289,9 @@ def insert(arr, obj, values, axis=None):
 
     Notes
     -----
-    Note that for higher dimensional inserts `obj=0` behaves very different
-    from `obj=[0]` just like `arr[:,0,:] = values` is different from
-    `arr[:,[0],:] = values`.
+    Note that for higher dimensional inserts ``obj=0`` behaves very different
+    from ``obj=[0]`` just like ``arr[:,0,:] = values`` is different from
+    ``arr[:,[0],:] = values``.
 
     Examples
     --------
diff --git a/numpy/lib/function_base.pyi b/numpy/lib/function_base.pyi
index 7e227f9da52d..687e4ab1708b 100644
--- a/numpy/lib/function_base.pyi
+++ b/numpy/lib/function_base.pyi
@@ -1,19 +1,12 @@
 import sys
+from collections.abc import Sequence, Iterator, Callable, Iterable
 from typing import (
     Literal as L,
-    List,
-    Type,
-    Sequence,
-    Tuple,
-    Union,
     Any,
     TypeVar,
-    Iterator,
     overload,
-    Callable,
     Protocol,
     SupportsIndex,
-    Iterable,
     SupportsInt,
 )
 
@@ -25,7 +18,6 @@ else:
 from numpy import (
     vectorize as vectorize,
     ufunc,
-    dtype,
     generic,
     floating,
     complexfloating,
@@ -38,15 +30,14 @@ from numpy import (
     _OrderKACF,
 )
 
-from numpy.typing import (
+from numpy._typing import (
     NDArray,
     ArrayLike,
     DTypeLike,
     _ShapeLike,
     _ScalarLike_co,
-    _SupportsDType,
-    _FiniteNestedSequence,
-    _SupportsArray,
+    _DTypeLike,
+    _ArrayLike,
     _ArrayLikeInt_co,
     _ArrayLikeFloat_co,
     _ArrayLikeComplex_co,
@@ -73,13 +64,7 @@ _T_co = TypeVar("_T_co", covariant=True)
 _SCT = TypeVar("_SCT", bound=generic)
 _ArrayType = TypeVar("_ArrayType", bound=NDArray[Any])
 
-_2Tuple = Tuple[_T, _T]
-_ArrayLike = _FiniteNestedSequence[_SupportsArray[dtype[_SCT]]]
-_DTypeLike = Union[
-    dtype[_SCT],
-    Type[_SCT],
-    _SupportsDType[dtype[_SCT]],
-]
+_2Tuple = tuple[_T, _T]
 
 class _TrimZerosSequence(Protocol[_T_co]):
     def __len__(self) -> int: ...
@@ -90,7 +75,7 @@ class _SupportsWriteFlush(Protocol):
     def write(self, s: str, /) -> object: ...
     def flush(self) -> object: ...
 
-__all__: List[str]
+__all__: list[str]
 
 # NOTE: This is in reality a re-export of `np.core.umath._add_newdoc_ufunc`
 def add_newdoc_ufunc(ufunc: ufunc, new_docstring: str, /) -> None: ...
@@ -99,13 +84,13 @@ def add_newdoc_ufunc(ufunc: ufunc, new_docstring: str, /) -> None: ...
 def rot90(
     m: _ArrayLike[_SCT],
     k: int = ...,
-    axes: Tuple[int, int] = ...,
+    axes: tuple[int, int] = ...,
 ) -> NDArray[_SCT]: ...
 @overload
 def rot90(
     m: ArrayLike,
     k: int = ...,
-    axes: Tuple[int, int] = ...,
+    axes: tuple[int, int] = ...,
 ) -> NDArray[Any]: ...
 
 @overload
@@ -125,6 +110,7 @@ def average(
     axis: None = ...,
     weights: None | _ArrayLikeFloat_co= ...,
     returned: L[False] = ...,
+    keepdims: L[False] = ...,
 ) -> floating[Any]: ...
 @overload
 def average(
@@ -132,6 +118,7 @@ def average(
     axis: None = ...,
     weights: None | _ArrayLikeComplex_co = ...,
     returned: L[False] = ...,
+    keepdims: L[False] = ...,
 ) -> complexfloating[Any, Any]: ...
 @overload
 def average(
@@ -139,6 +126,7 @@ def average(
     axis: None = ...,
     weights: None | Any = ...,
     returned: L[False] = ...,
+    keepdims: L[False] = ...,
 ) -> Any: ...
 @overload
 def average(
@@ -146,6 +134,7 @@ def average(
     axis: None = ...,
     weights: None | _ArrayLikeFloat_co= ...,
     returned: L[True] = ...,
+    keepdims: L[False] = ...,
 ) -> _2Tuple[floating[Any]]: ...
 @overload
 def average(
@@ -153,6 +142,7 @@ def average(
     axis: None = ...,
     weights: None | _ArrayLikeComplex_co = ...,
     returned: L[True] = ...,
+    keepdims: L[False] = ...,
 ) -> _2Tuple[complexfloating[Any, Any]]: ...
 @overload
 def average(
@@ -160,6 +150,7 @@ def average(
     axis: None = ...,
     weights: None | Any = ...,
     returned: L[True] = ...,
+    keepdims: L[False] = ...,
 ) -> _2Tuple[Any]: ...
 @overload
 def average(
@@ -167,6 +158,7 @@ def average(
     axis: None | _ShapeLike = ...,
     weights: None | Any = ...,
     returned: L[False] = ...,
+    keepdims: bool = ...,
 ) -> Any: ...
 @overload
 def average(
@@ -174,6 +166,7 @@ def average(
     axis: None | _ShapeLike = ...,
     weights: None | Any = ...,
     returned: L[True] = ...,
+    keepdims: bool = ...,
 ) -> _2Tuple[Any]: ...
 
 @overload
@@ -201,6 +194,8 @@ def asarray_chkfinite(
     order: _OrderKACF = ...,
 ) -> NDArray[Any]: ...
 
+# TODO: Use PEP 612 `ParamSpec` once mypy supports `Concatenate`
+# xref python/mypy#8645
 @overload
 def piecewise(
     x: _ArrayLike[_SCT],
@@ -294,11 +289,13 @@ def interp(
 ) -> NDArray[complex128]: ...
 
 @overload
-def angle(z: _ArrayLikeFloat_co, deg: bool = ...) -> floating[Any]: ...
+def angle(z: _ComplexLike_co, deg: bool = ...) -> floating[Any]: ...
+@overload
+def angle(z: object_, deg: bool = ...) -> Any: ...
 @overload
-def angle(z: _ArrayLikeComplex_co, deg: bool = ...) -> complexfloating[Any, Any]: ...
+def angle(z: _ArrayLikeComplex_co, deg: bool = ...) -> NDArray[floating[Any]]: ...
 @overload
-def angle(z: _ArrayLikeObject_co, deg: bool = ...) -> Any: ...
+def angle(z: _ArrayLikeObject_co, deg: bool = ...) -> NDArray[object_]: ...
 
 @overload
 def unwrap(
@@ -444,12 +441,8 @@ def sinc(x: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ...
 @overload
 def sinc(x: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ...
 
-@overload
-def msort(a: _ArrayType) -> _ArrayType: ...
-@overload
-def msort(a: _ArrayLike[_SCT]) -> NDArray[_SCT]: ...
-@overload
-def msort(a: ArrayLike) -> NDArray[Any]: ...
+# NOTE: Deprecated
+# def msort(a: ArrayLike) -> NDArray[Any]: ...
 
 @overload
 def median(
@@ -654,7 +647,7 @@ def meshgrid(
     copy: bool = ...,
     sparse: bool = ...,
     indexing: L["xy", "ij"] = ...,
-) -> List[NDArray[Any]]: ...
+) -> list[NDArray[Any]]: ...
 
 @overload
 def delete(
diff --git a/numpy/lib/histograms.py b/numpy/lib/histograms.py
index b6909bc1d9e0..0dfa7b4c1819 100644
--- a/numpy/lib/histograms.py
+++ b/numpy/lib/histograms.py
@@ -506,8 +506,8 @@ def histogram_bin_edges(a, bins=10, range=None, weights=None):
             with non-normal datasets.
 
         'scott'
-            Less robust estimator that that takes into account data
-            variability and data size.
+            Less robust estimator that takes into account data variability
+            and data size.
 
         'stone'
             Estimator based on leave-one-out cross-validation estimate of
@@ -562,7 +562,7 @@ def histogram_bin_edges(a, bins=10, range=None, weights=None):
     below, :math:`h` is the binwidth and :math:`n_h` is the number of
     bins. All estimators that compute bin counts are recast to bin width
     using the `ptp` of the data. The final bin count is obtained from
-    ``np.round(np.ceil(range / h))``. The final bin width is often less 
+    ``np.round(np.ceil(range / h))``. The final bin width is often less
     than what is returned by the estimators below.
 
     'auto' (maximum of the 'sturges' and 'fd' estimators)
@@ -581,7 +581,7 @@ def histogram_bin_edges(a, bins=10, range=None, weights=None):
         datasets. The IQR is very robust to outliers.
 
     'scott'
-        .. math:: h = \sigma \sqrt[3]{\frac{24 * \sqrt{\pi}}{n}}
+        .. math:: h = \sigma \sqrt[3]{\frac{24 \sqrt{\pi}}{n}}
 
         The binwidth is proportional to the standard deviation of the
         data and inversely proportional to cube root of ``x.size``. Can
@@ -598,7 +598,7 @@ def histogram_bin_edges(a, bins=10, range=None, weights=None):
         does not take into account data variability.
 
     'sturges'
-        .. math:: n_h = \log _{2}n+1
+        .. math:: n_h = \log _{2}(n) + 1
 
         The number of bins is the base 2 log of ``a.size``.  This
         estimator assumes normality of data and is too conservative for
@@ -607,9 +607,9 @@ def histogram_bin_edges(a, bins=10, range=None, weights=None):
 
     'doane'
         .. math:: n_h = 1 + \log_{2}(n) +
-                        \log_{2}(1 + \frac{|g_1|}{\sigma_{g_1}})
+                        \log_{2}\left(1 + \frac{|g_1|}{\sigma_{g_1}}\right)
 
-            g_1 = mean[(\frac{x - \mu}{\sigma})^3]
+            g_1 = mean\left[\left(\frac{x - \mu}{\sigma}\right)^3\right]
 
             \sigma_{g_1} = \sqrt{\frac{6(n - 2)}{(n + 1)(n + 3)}}
 
@@ -671,13 +671,12 @@ def histogram_bin_edges(a, bins=10, range=None, weights=None):
 
 
 def _histogram_dispatcher(
-        a, bins=None, range=None, normed=None, weights=None, density=None):
+        a, bins=None, range=None, density=None, weights=None):
     return (a, bins, weights)
 
 
 @array_function_dispatch(_histogram_dispatcher)
-def histogram(a, bins=10, range=None, normed=None, weights=None,
-              density=None):
+def histogram(a, bins=10, range=None, density=None, weights=None):
     r"""
     Compute the histogram of a dataset.
 
@@ -704,16 +703,6 @@ def histogram(a, bins=10, range=None, normed=None, weights=None,
         computation as well. While bin width is computed to be optimal
         based on the actual data within `range`, the bin count will fill
         the entire range including portions containing no data.
-    normed : bool, optional
-
-        .. deprecated:: 1.6.0
-
-        This is equivalent to the `density` argument, but produces incorrect
-        results for unequal bin widths. It should not be used.
-
-        .. versionchanged:: 1.15.0
-            DeprecationWarnings are actually emitted.
-
     weights : array_like, optional
         An array of weights, of the same shape as `a`.  Each value in
         `a` only contributes its associated weight towards the bin count
@@ -728,8 +717,6 @@ def histogram(a, bins=10, range=None, normed=None, weights=None,
         histogram values will not be equal to 1 unless bins of unity
         width are chosen; it is not a probability *mass* function.
 
-        Overrides the ``normed`` keyword if given.
-
     Returns
     -------
     hist : array
@@ -891,46 +878,15 @@ def histogram(a, bins=10, range=None, normed=None, weights=None,
 
         n = np.diff(cum_n)
 
-    # density overrides the normed keyword
-    if density is not None:
-        if normed is not None:
-            # 2018-06-13, numpy 1.15.0 (this was not noisily deprecated in 1.6)
-            warnings.warn(
-                    "The normed argument is ignored when density is provided. "
-                    "In future passing both will result in an error.",
-                    DeprecationWarning, stacklevel=3)
-        normed = None
-
     if density:
         db = np.array(np.diff(bin_edges), float)
         return n/db/n.sum(), bin_edges
-    elif normed:
-        # 2018-06-13, numpy 1.15.0 (this was not noisily deprecated in 1.6)
-        warnings.warn(
-                "Passing `normed=True` on non-uniform bins has always been "
-                "broken, and computes neither the probability density "
-                "function nor the probability mass function. "
-                "The result is only correct if the bins are uniform, when "
-                "density=True will produce the same result anyway. "
-                "The argument will be removed in a future version of "
-                "numpy.",
-                np.VisibleDeprecationWarning, stacklevel=3)
-
-        # this normalization is incorrect, but
-        db = np.array(np.diff(bin_edges), float)
-        return n/(n*db).sum(), bin_edges
-    else:
-        if normed is not None:
-            # 2018-06-13, numpy 1.15.0 (this was not noisily deprecated in 1.6)
-            warnings.warn(
-                    "Passing normed=False is deprecated, and has no effect. "
-                    "Consider passing the density argument instead.",
-                    DeprecationWarning, stacklevel=3)
-        return n, bin_edges
+
+    return n, bin_edges
 
 
-def _histogramdd_dispatcher(sample, bins=None, range=None, normed=None,
-                            weights=None, density=None):
+def _histogramdd_dispatcher(sample, bins=None, range=None, density=None,
+                            weights=None):
     if hasattr(sample, 'shape'):  # same condition as used in histogramdd
         yield sample
     else:
@@ -941,14 +897,13 @@ def _histogramdd_dispatcher(sample, bins=None, range=None, normed=None,
 
 
 @array_function_dispatch(_histogramdd_dispatcher)
-def histogramdd(sample, bins=10, range=None, normed=None, weights=None,
-                density=None):
+def histogramdd(sample, bins=10, range=None, density=None, weights=None):
     """
     Compute the multidimensional histogram of some data.
 
     Parameters
     ----------
-    sample : (N, D) array, or (D, N) array_like
+    sample : (N, D) array, or (N, D) array_like
         The data to be histogrammed.
 
         Note the unusual interpretation of sample when an array_like:
@@ -979,20 +934,16 @@ def histogramdd(sample, bins=10, range=None, normed=None, weights=None,
         If False, the default, returns the number of samples in each bin.
         If True, returns the probability *density* function at the bin,
         ``bin_count / sample_count / bin_volume``.
-    normed : bool, optional
-        An alias for the density argument that behaves identically. To avoid
-        confusion with the broken normed argument to `histogram`, `density`
-        should be preferred.
     weights : (N,) array_like, optional
         An array of values `w_i` weighing each sample `(x_i, y_i, z_i, ...)`.
-        Weights are normalized to 1 if normed is True. If normed is False,
+        Weights are normalized to 1 if density is True. If density is False,
         the values of the returned histogram are equal to the sum of the
         weights belonging to the samples falling into each bin.
 
     Returns
     -------
     H : ndarray
-        The multidimensional histogram of sample x. See normed and weights
+        The multidimensional histogram of sample x. See density and weights
         for the different possible semantics.
     edges : list
         A list of D arrays describing the bin edges for each dimension.
@@ -1019,7 +970,7 @@ def histogramdd(sample, bins=10, range=None, normed=None, weights=None,
         sample = np.atleast_2d(sample).T
         N, D = sample.shape
 
-    nbin = np.empty(D, int)
+    nbin = np.empty(D, np.intp)
     edges = D*[None]
     dedges = D*[None]
     if weights is not None:
@@ -1050,13 +1001,13 @@ def histogramdd(sample, bins=10, range=None, normed=None, weights=None,
             smin, smax = _get_outer_edges(sample[:,i], range[i])
             try:
                 n = operator.index(bins[i])
-            
+
             except TypeError as e:
                 raise TypeError(
                 	"`bins[{}]` must be an integer, when a scalar".format(i)
                 ) from e
-                
-            edges[i] = np.linspace(smin, smax, n + 1)    
+
+            edges[i] = np.linspace(smin, smax, n + 1)
         elif np.ndim(bins[i]) == 1:
             edges[i] = np.asarray(bins[i])
             if np.any(edges[i][:-1] > edges[i][1:]):
@@ -1104,16 +1055,6 @@ def histogramdd(sample, bins=10, range=None, normed=None, weights=None,
     core = D*(slice(1, -1),)
     hist = hist[core]
 
-    # handle the aliasing normed argument
-    if normed is None:
-        if density is None:
-            density = False
-    elif density is None:
-        # an explicit normed argument was passed, alias it to the new name
-        density = normed
-    else:
-        raise TypeError("Cannot specify both 'normed' and 'density'")
-
     if density:
         # calculate the probability density function
         s = hist.sum()
diff --git a/numpy/lib/histograms.pyi b/numpy/lib/histograms.pyi
index 2ceb60793c7e..ce02718adcd5 100644
--- a/numpy/lib/histograms.pyi
+++ b/numpy/lib/histograms.pyi
@@ -1,13 +1,11 @@
+from collections.abc import Sequence
 from typing import (
     Literal as L,
-    List,
-    Tuple,
     Any,
     SupportsIndex,
-    Sequence,
 )
 
-from numpy.typing import (
+from numpy._typing import (
     NDArray,
     ArrayLike,
 )
@@ -23,29 +21,27 @@ _BinKind = L[
     "sturges",
 ]
 
-__all__: List[str]
+__all__: list[str]
 
 def histogram_bin_edges(
     a: ArrayLike,
     bins: _BinKind | SupportsIndex | ArrayLike = ...,
-    range: None | Tuple[float, float] = ...,
+    range: None | tuple[float, float] = ...,
     weights: None | ArrayLike = ...,
 ) -> NDArray[Any]: ...
 
 def histogram(
     a: ArrayLike,
     bins: _BinKind | SupportsIndex | ArrayLike = ...,
-    range: None | Tuple[float, float] = ...,
-    normed: None = ...,
-    weights: None | ArrayLike = ...,
+    range: None | tuple[float, float] = ...,
     density: bool = ...,
-) -> Tuple[NDArray[Any], NDArray[Any]]: ...
+    weights: None | ArrayLike = ...,
+) -> tuple[NDArray[Any], NDArray[Any]]: ...
 
 def histogramdd(
     sample: ArrayLike,
     bins: SupportsIndex | ArrayLike = ...,
-    range: Sequence[Tuple[float, float]] = ...,
-    normed: None | bool = ...,
-    weights: None | ArrayLike = ...,
+    range: Sequence[tuple[float, float]] = ...,
     density: None | bool = ...,
-) -> Tuple[NDArray[Any], List[NDArray[Any]]]: ...
+    weights: None | ArrayLike = ...,
+) -> tuple[NDArray[Any], list[NDArray[Any]]]: ...
diff --git a/numpy/lib/index_tricks.py b/numpy/lib/index_tricks.py
index 2a4402c89e48..95d5e3edeb8d 100644
--- a/numpy/lib/index_tricks.py
+++ b/numpy/lib/index_tricks.py
@@ -148,24 +148,25 @@ def __init__(self, sparse=False):
     def __getitem__(self, key):
         try:
             size = []
-            typ = int
-            for kk in key:
-                step = kk.step
-                start = kk.start
+            # Mimic the behavior of `np.arange` and use a data type
+            # which is at least as large as `np.int_`
+            num_list = [0]
+            for k in range(len(key)):
+                step = key[k].step
+                start = key[k].start
+                stop = key[k].stop
                 if start is None:
                     start = 0
                 if step is None:
                     step = 1
                 if isinstance(step, (_nx.complexfloating, complex)):
-                    size.append(int(abs(step)))
-                    typ = float
+                    step = abs(step)
+                    size.append(int(step))
                 else:
                     size.append(
-                        int(math.ceil((kk.stop - start) / (step * 1.0))))
-                if (isinstance(step, (_nx.floating, float)) or
-                        isinstance(start, (_nx.floating, float)) or
-                        isinstance(kk.stop, (_nx.floating, float))):
-                    typ = float
+                        int(math.ceil((stop - start) / (step*1.0))))
+                num_list += [start, stop, step]
+            typ = _nx.result_type(*num_list)
             if self.sparse:
                 nn = [_nx.arange(_x, dtype=_t)
                       for _x, _t in zip(size, (typ,)*len(size))]
@@ -197,11 +198,13 @@ def __getitem__(self, key):
             if start is None:
                 start = 0
             if isinstance(step, (_nx.complexfloating, complex)):
-                step = abs(step)
-                length = int(step)
+                # Prevent the (potential) creation of integer arrays
+                step_float = abs(step)
+                step = length = int(step_float)
                 if step != 1:
                     step = (key.stop-start)/float(step-1)
-                return _nx.arange(0, length, 1, float)*step + start
+                typ = _nx.result_type(start, stop, step_float)
+                return _nx.arange(0, length, 1, dtype=typ)*step + start
             else:
                 return _nx.arange(start, stop, step)
 
@@ -227,13 +230,15 @@ class MGridClass(nd_grid):
 
     See Also
     --------
-    numpy.lib.index_tricks.nd_grid : class of `ogrid` and `mgrid` objects
+    lib.index_tricks.nd_grid : class of `ogrid` and `mgrid` objects
     ogrid : like mgrid but returns open (not fleshed out) mesh grids
+    meshgrid: return coordinate matrices from coordinate vectors
     r_ : array concatenator
+    :ref:`how-to-partition`
 
     Examples
     --------
-    >>> np.mgrid[0:5,0:5]
+    >>> np.mgrid[0:5, 0:5]
     array([[[0, 0, 0, 0, 0],
             [1, 1, 1, 1, 1],
             [2, 2, 2, 2, 2],
@@ -280,7 +285,9 @@ class OGridClass(nd_grid):
     --------
     np.lib.index_tricks.nd_grid : class of `ogrid` and `mgrid` objects
     mgrid : like `ogrid` but returns dense (or fleshed out) mesh grids
+    meshgrid: return coordinate matrices from coordinate vectors
     r_ : array concatenator
+    :ref:`how-to-partition`
 
     Examples
     --------
@@ -621,7 +628,7 @@ class ndindex:
     Parameters
     ----------
     shape : ints, or a single tuple of ints
-        The size of each dimension of the array can be passed as 
+        The size of each dimension of the array can be passed as
         individual parameters or as the elements of a tuple.
 
     See Also
@@ -631,7 +638,7 @@ class ndindex:
     Examples
     --------
     Dimensions as individual arguments
-    
+
     >>> for index in np.ndindex(3, 2, 1):
     ...     print(index)
     (0, 0, 0)
@@ -642,7 +649,7 @@ class ndindex:
     (2, 1, 0)
 
     Same dimensions - but in a tuple ``(3, 2, 1)``
-    
+
     >>> for index in np.ndindex((3, 2, 1)):
     ...     print(index)
     (0, 0, 0)
diff --git a/numpy/lib/index_tricks.pyi b/numpy/lib/index_tricks.pyi
index d16faf81a0bb..c9251abd15b3 100644
--- a/numpy/lib/index_tricks.pyi
+++ b/numpy/lib/index_tricks.pyi
@@ -1,12 +1,9 @@
+from collections.abc import Sequence
 from typing import (
     Any,
-    Tuple,
     TypeVar,
     Generic,
     overload,
-    List,
-    Union,
-    Sequence,
     Literal,
     SupportsIndex,
 )
@@ -29,7 +26,7 @@ from numpy import (
     _OrderCF,
     _ModeKind,
 )
-from numpy.typing import (
+from numpy._typing import (
     # Arrays
     ArrayLike,
     _NestedSequence,
@@ -53,25 +50,25 @@ from numpy.core.multiarray import (
 _T = TypeVar("_T")
 _DType = TypeVar("_DType", bound=dtype[Any])
 _BoolType = TypeVar("_BoolType", Literal[True], Literal[False])
-_TupType = TypeVar("_TupType", bound=Tuple[Any, ...])
+_TupType = TypeVar("_TupType", bound=tuple[Any, ...])
 _ArrayType = TypeVar("_ArrayType", bound=ndarray[Any, Any])
 
-__all__: List[str]
+__all__: list[str]
 
 @overload
-def ix_(*args: _FiniteNestedSequence[_SupportsDType[_DType]]) -> Tuple[ndarray[Any, _DType], ...]: ...
+def ix_(*args: _FiniteNestedSequence[_SupportsDType[_DType]]) -> tuple[ndarray[Any, _DType], ...]: ...
 @overload
-def ix_(*args: str | _NestedSequence[str]) -> Tuple[NDArray[str_], ...]: ...
+def ix_(*args: str | _NestedSequence[str]) -> tuple[NDArray[str_], ...]: ...
 @overload
-def ix_(*args: bytes | _NestedSequence[bytes]) -> Tuple[NDArray[bytes_], ...]: ...
+def ix_(*args: bytes | _NestedSequence[bytes]) -> tuple[NDArray[bytes_], ...]: ...
 @overload
-def ix_(*args: bool | _NestedSequence[bool]) -> Tuple[NDArray[bool_], ...]: ...
+def ix_(*args: bool | _NestedSequence[bool]) -> tuple[NDArray[bool_], ...]: ...
 @overload
-def ix_(*args: int | _NestedSequence[int]) -> Tuple[NDArray[int_], ...]: ...
+def ix_(*args: int | _NestedSequence[int]) -> tuple[NDArray[int_], ...]: ...
 @overload
-def ix_(*args: float | _NestedSequence[float]) -> Tuple[NDArray[float_], ...]: ...
+def ix_(*args: float | _NestedSequence[float]) -> tuple[NDArray[float_], ...]: ...
 @overload
-def ix_(*args: complex | _NestedSequence[complex]) -> Tuple[NDArray[complex_], ...]: ...
+def ix_(*args: complex | _NestedSequence[complex]) -> tuple[NDArray[complex_], ...]: ...
 
 class nd_grid(Generic[_BoolType]):
     sparse: _BoolType
@@ -79,13 +76,13 @@ class nd_grid(Generic[_BoolType]):
     @overload
     def __getitem__(
         self: nd_grid[Literal[False]],
-        key: Union[slice, Sequence[slice]],
+        key: slice | Sequence[slice],
     ) -> NDArray[Any]: ...
     @overload
     def __getitem__(
         self: nd_grid[Literal[True]],
-        key: Union[slice, Sequence[slice]],
-    ) -> List[NDArray[Any]]: ...
+        key: slice | Sequence[slice],
+    ) -> list[NDArray[Any]]: ...
 
 class MGridClass(nd_grid[Literal[False]]):
     def __init__(self) -> None: ...
@@ -151,7 +148,7 @@ class IndexExpression(Generic[_BoolType]):
     @overload
     def __getitem__(self, item: _TupType) -> _TupType: ...  # type: ignore[misc]
     @overload
-    def __getitem__(self: IndexExpression[Literal[True]], item: _T) -> Tuple[_T]: ...
+    def __getitem__(self: IndexExpression[Literal[True]], item: _T) -> tuple[_T]: ...
     @overload
     def __getitem__(self: IndexExpression[Literal[False]], item: _T) -> _T: ...
 
@@ -159,7 +156,7 @@ index_exp: IndexExpression[Literal[True]]
 s_: IndexExpression[Literal[False]]
 
 def fill_diagonal(a: ndarray[Any, Any], val: Any, wrap: bool = ...) -> None: ...
-def diag_indices(n: int, ndim: int = ...) -> Tuple[NDArray[int_], ...]: ...
-def diag_indices_from(arr: ArrayLike) -> Tuple[NDArray[int_], ...]: ...
+def diag_indices(n: int, ndim: int = ...) -> tuple[NDArray[int_], ...]: ...
+def diag_indices_from(arr: ArrayLike) -> tuple[NDArray[int_], ...]: ...
 
 # NOTE: see `numpy/__init__.pyi` for `ndenumerate` and `ndindex`
diff --git a/numpy/lib/mixins.pyi b/numpy/lib/mixins.pyi
index f137bb5bcf4b..c5744213372c 100644
--- a/numpy/lib/mixins.pyi
+++ b/numpy/lib/mixins.pyi
@@ -1,62 +1,74 @@
-from typing import List
 from abc import ABCMeta, abstractmethod
+from typing import Literal as L, Any
 
-__all__: List[str]
+from numpy import ufunc
+
+__all__: list[str]
 
 # NOTE: `NDArrayOperatorsMixin` is not formally an abstract baseclass,
 # even though it's reliant on subclasses implementing `__array_ufunc__`
 
+# NOTE: The accepted input- and output-types of the various dunders are
+# completely dependent on how `__array_ufunc__` is implemented.
+# As such, only little type safety can be provided here.
+
 class NDArrayOperatorsMixin(metaclass=ABCMeta):
     @abstractmethod
-    def __array_ufunc__(self, ufunc, method, *inputs, **kwargs): ...
-    def __lt__(self, other): ...
-    def __le__(self, other): ...
-    def __eq__(self, other): ...
-    def __ne__(self, other): ...
-    def __gt__(self, other): ...
-    def __ge__(self, other): ...
-    def __add__(self, other): ...
-    def __radd__(self, other): ...
-    def __iadd__(self, other): ...
-    def __sub__(self, other): ...
-    def __rsub__(self, other): ...
-    def __isub__(self, other): ...
-    def __mul__(self, other): ...
-    def __rmul__(self, other): ...
-    def __imul__(self, other): ...
-    def __matmul__(self, other): ...
-    def __rmatmul__(self, other): ...
-    def __imatmul__(self, other): ...
-    def __truediv__(self, other): ...
-    def __rtruediv__(self, other): ...
-    def __itruediv__(self, other): ...
-    def __floordiv__(self, other): ...
-    def __rfloordiv__(self, other): ...
-    def __ifloordiv__(self, other): ...
-    def __mod__(self, other): ...
-    def __rmod__(self, other): ...
-    def __imod__(self, other): ...
-    def __divmod__(self, other): ...
-    def __rdivmod__(self, other): ...
-    def __pow__(self, other): ...
-    def __rpow__(self, other): ...
-    def __ipow__(self, other): ...
-    def __lshift__(self, other): ...
-    def __rlshift__(self, other): ...
-    def __ilshift__(self, other): ...
-    def __rshift__(self, other): ...
-    def __rrshift__(self, other): ...
-    def __irshift__(self, other): ...
-    def __and__(self, other): ...
-    def __rand__(self, other): ...
-    def __iand__(self, other): ...
-    def __xor__(self, other): ...
-    def __rxor__(self, other): ...
-    def __ixor__(self, other): ...
-    def __or__(self, other): ...
-    def __ror__(self, other): ...
-    def __ior__(self, other): ...
-    def __neg__(self): ...
-    def __pos__(self): ...
-    def __abs__(self): ...
-    def __invert__(self): ...
+    def __array_ufunc__(
+        self,
+        ufunc: ufunc,
+        method: L["__call__", "reduce", "reduceat", "accumulate", "outer", "inner"],
+        *inputs: Any,
+        **kwargs: Any,
+    ) -> Any: ...
+    def __lt__(self, other: Any) -> Any: ...
+    def __le__(self, other: Any) -> Any: ...
+    def __eq__(self, other: Any) -> Any: ...
+    def __ne__(self, other: Any) -> Any: ...
+    def __gt__(self, other: Any) -> Any: ...
+    def __ge__(self, other: Any) -> Any: ...
+    def __add__(self, other: Any) -> Any: ...
+    def __radd__(self, other: Any) -> Any: ...
+    def __iadd__(self, other: Any) -> Any: ...
+    def __sub__(self, other: Any) -> Any: ...
+    def __rsub__(self, other: Any) -> Any: ...
+    def __isub__(self, other: Any) -> Any: ...
+    def __mul__(self, other: Any) -> Any: ...
+    def __rmul__(self, other: Any) -> Any: ...
+    def __imul__(self, other: Any) -> Any: ...
+    def __matmul__(self, other: Any) -> Any: ...
+    def __rmatmul__(self, other: Any) -> Any: ...
+    def __imatmul__(self, other: Any) -> Any: ...
+    def __truediv__(self, other: Any) -> Any: ...
+    def __rtruediv__(self, other: Any) -> Any: ...
+    def __itruediv__(self, other: Any) -> Any: ...
+    def __floordiv__(self, other: Any) -> Any: ...
+    def __rfloordiv__(self, other: Any) -> Any: ...
+    def __ifloordiv__(self, other: Any) -> Any: ...
+    def __mod__(self, other: Any) -> Any: ...
+    def __rmod__(self, other: Any) -> Any: ...
+    def __imod__(self, other: Any) -> Any: ...
+    def __divmod__(self, other: Any) -> Any: ...
+    def __rdivmod__(self, other: Any) -> Any: ...
+    def __pow__(self, other: Any) -> Any: ...
+    def __rpow__(self, other: Any) -> Any: ...
+    def __ipow__(self, other: Any) -> Any: ...
+    def __lshift__(self, other: Any) -> Any: ...
+    def __rlshift__(self, other: Any) -> Any: ...
+    def __ilshift__(self, other: Any) -> Any: ...
+    def __rshift__(self, other: Any) -> Any: ...
+    def __rrshift__(self, other: Any) -> Any: ...
+    def __irshift__(self, other: Any) -> Any: ...
+    def __and__(self, other: Any) -> Any: ...
+    def __rand__(self, other: Any) -> Any: ...
+    def __iand__(self, other: Any) -> Any: ...
+    def __xor__(self, other: Any) -> Any: ...
+    def __rxor__(self, other: Any) -> Any: ...
+    def __ixor__(self, other: Any) -> Any: ...
+    def __or__(self, other: Any) -> Any: ...
+    def __ror__(self, other: Any) -> Any: ...
+    def __ior__(self, other: Any) -> Any: ...
+    def __neg__(self) -> Any: ...
+    def __pos__(self) -> Any: ...
+    def __abs__(self) -> Any: ...
+    def __invert__(self) -> Any: ...
diff --git a/numpy/lib/nanfunctions.py b/numpy/lib/nanfunctions.py
index d7ea1ca65b7d..ae2dfa1657ff 100644
--- a/numpy/lib/nanfunctions.py
+++ b/numpy/lib/nanfunctions.py
@@ -188,9 +188,8 @@ def _divide_by_count(a, b, out=None):
     """
     Compute a/b ignoring invalid results. If `a` is an array the division
     is done in place. If `a` is a scalar, then its type is preserved in the
-    output. If out is None, then then a is used instead so that the
-    division is in place. Note that this is only called with `a` an inexact
-    type.
+    output. If out is None, then a is used instead so that the division
+    is in place. Note that this is only called with `a` an inexact type.
 
     Parameters
     ----------
@@ -1215,12 +1214,9 @@ def nanmedian(a, axis=None, out=None, overwrite_input=False, keepdims=np._NoValu
     if a.size == 0:
         return np.nanmean(a, axis, out=out, keepdims=keepdims)
 
-    r, k = function_base._ureduce(a, func=_nanmedian, axis=axis, out=out,
+    return function_base._ureduce(a, func=_nanmedian, keepdims=keepdims,
+                                  axis=axis, out=out,
                                   overwrite_input=overwrite_input)
-    if keepdims and keepdims is not np._NoValue:
-        return r.reshape(k)
-    else:
-        return r
 
 
 def _nanpercentile_dispatcher(
@@ -1286,7 +1282,7 @@ def nanpercentile(
         8. 'median_unbiased'
         9. 'normal_unbiased'
 
-        The first three methods are discontiuous.  NumPy further defines the
+        The first three methods are discontinuous.  NumPy further defines the
         following discontinuous variations of the default 'linear' (7.) option:
 
         * 'lower'
@@ -1446,7 +1442,7 @@ def nanquantile(
         8. 'median_unbiased'
         9. 'normal_unbiased'
 
-        The first three methods are discontiuous.  NumPy further defines the
+        The first three methods are discontinuous.  NumPy further defines the
         following discontinuous variations of the default 'linear' (7.) option:
 
         * 'lower'
@@ -1557,17 +1553,14 @@ def _nanquantile_unchecked(
     # so deal them upfront
     if a.size == 0:
         return np.nanmean(a, axis, out=out, keepdims=keepdims)
-    r, k = function_base._ureduce(a,
+    return function_base._ureduce(a,
                                   func=_nanquantile_ureduce_func,
                                   q=q,
+                                  keepdims=keepdims,
                                   axis=axis,
                                   out=out,
                                   overwrite_input=overwrite_input,
                                   method=method)
-    if keepdims and keepdims is not np._NoValue:
-        return r.reshape(q.shape + k)
-    else:
-        return r
 
 
 def _nanquantile_ureduce_func(a, q, axis=None, out=None, overwrite_input=False,
diff --git a/numpy/lib/nanfunctions.pyi b/numpy/lib/nanfunctions.pyi
index 54b4a7e260a7..8642055fedd2 100644
--- a/numpy/lib/nanfunctions.pyi
+++ b/numpy/lib/nanfunctions.pyi
@@ -1,5 +1,3 @@
-from typing import List
-
 from numpy.core.fromnumeric import (
     amin,
     amax,
@@ -20,7 +18,7 @@ from numpy.lib.function_base import (
     quantile,
 )
 
-__all__: List[str]
+__all__: list[str]
 
 # NOTE: In reaility these functions are not aliases but distinct functions
 # with identical signatures.
diff --git a/numpy/lib/npyio.py b/numpy/lib/npyio.py
index 6c34e95fef9a..3d6951416e2f 100644
--- a/numpy/lib/npyio.py
+++ b/numpy/lib/npyio.py
@@ -5,6 +5,7 @@
 import warnings
 import weakref
 import contextlib
+import operator
 from operator import itemgetter, index as opindex, methodcaller
 from collections.abc import Mapping
 
@@ -13,6 +14,7 @@
 from ._datasource import DataSource
 from numpy.core import overrides
 from numpy.core.multiarray import packbits, unpackbits
+from numpy.core._multiarray_umath import _load_from_filelike
 from numpy.core.overrides import set_array_function_like_doc, set_module
 from ._iotools import (
     LineSplitter, NameValidator, StringConverter, ConverterError,
@@ -137,6 +139,12 @@ class NpzFile(Mapping):
         Additional keyword arguments to pass on to pickle.load.
         These are only useful when loading object arrays saved on
         Python 2 when using Python 3.
+    max_header_size : int, optional
+        Maximum allowed size of the header.  Large headers may not be safe
+        to load securely and thus require explicitly passing a larger value.
+        See :py:meth:`ast.literal_eval()` for details.
+        This option is ignored when `allow_pickle` is passed.  In that case
+        the file is by definition trusted and the limit is unnecessary.
 
     Parameters
     ----------
@@ -157,7 +165,7 @@ class NpzFile(Mapping):
     >>> _ = outfile.seek(0)
 
     >>> npz = np.load(outfile)
-    >>> isinstance(npz, np.lib.io.NpzFile)
+    >>> isinstance(npz, np.lib.npyio.NpzFile)
     True
     >>> sorted(npz.files)
     ['x', 'y']
@@ -172,13 +180,15 @@ class NpzFile(Mapping):
     fid = None
 
     def __init__(self, fid, own_fid=False, allow_pickle=False,
-                 pickle_kwargs=None):
+                 pickle_kwargs=None, *,
+                 max_header_size=format._MAX_HEADER_SIZE):
         # Import is postponed to here since zipfile depends on gzip, an
         # optional component of the so-called standard library.
         _zip = zipfile_factory(fid)
         self._files = _zip.namelist()
         self.files = []
         self.allow_pickle = allow_pickle
+        self.max_header_size = max_header_size
         self.pickle_kwargs = pickle_kwargs
         for x in self._files:
             if x.endswith('.npy'):
@@ -242,36 +252,17 @@ def __getitem__(self, key):
                 bytes = self.zip.open(key)
                 return format.read_array(bytes,
                                          allow_pickle=self.allow_pickle,
-                                         pickle_kwargs=self.pickle_kwargs)
+                                         pickle_kwargs=self.pickle_kwargs,
+                                         max_header_size=self.max_header_size)
             else:
                 return self.zip.read(key)
         else:
             raise KeyError("%s is not a file in the archive" % key)
 
-    # deprecate the python 2 dict apis that we supported by accident in
-    # python 3. We forgot to implement itervalues() at all in earlier
-    # versions of numpy, so no need to deprecated it here.
-
-    def iteritems(self):
-        # Numpy 1.15, 2018-02-20
-        warnings.warn(
-            "NpzFile.iteritems is deprecated in python 3, to match the "
-            "removal of dict.itertems. Use .items() instead.",
-            DeprecationWarning, stacklevel=2)
-        return self.items()
-
-    def iterkeys(self):
-        # Numpy 1.15, 2018-02-20
-        warnings.warn(
-            "NpzFile.iterkeys is deprecated in python 3, to match the "
-            "removal of dict.iterkeys. Use .keys() instead.",
-            DeprecationWarning, stacklevel=2)
-        return self.keys()
-
 
 @set_module('numpy')
 def load(file, mmap_mode=None, allow_pickle=False, fix_imports=True,
-         encoding='ASCII'):
+         encoding='ASCII', *, max_header_size=format._MAX_HEADER_SIZE):
     """
     Load arrays or pickled objects from ``.npy``, ``.npz`` or pickled files.
 
@@ -285,7 +276,8 @@ def load(file, mmap_mode=None, allow_pickle=False, fix_imports=True,
     ----------
     file : file-like object, string, or pathlib.Path
         The file to read. File-like objects must support the
-        ``seek()`` and ``read()`` methods. Pickled files require that the
+        ``seek()`` and ``read()`` methods and must always
+        be opened in binary mode.  Pickled files require that the
         file-like object support the ``readline()`` method as well.
     mmap_mode : {None, 'r+', 'r', 'w+', 'c'}, optional
         If not None, then memory-map the file, using the given mode (see
@@ -314,6 +306,12 @@ def load(file, mmap_mode=None, allow_pickle=False, fix_imports=True,
         npy/npz files containing object arrays. Values other than 'latin1',
         'ASCII', and 'bytes' are not allowed, as they can corrupt numerical
         data. Default: 'ASCII'
+    max_header_size : int, optional
+        Maximum allowed size of the header.  Large headers may not be safe
+        to load securely and thus require explicitly passing a larger value.
+        See :py:meth:`ast.literal_eval()` for details.
+        This option is ignored when `allow_pickle` is passed.  In that case
+        the file is by definition trusted and the limit is unnecessary.
 
     Returns
     -------
@@ -420,15 +418,20 @@ def load(file, mmap_mode=None, allow_pickle=False, fix_imports=True,
             # Potentially transfer file ownership to NpzFile
             stack.pop_all()
             ret = NpzFile(fid, own_fid=own_fid, allow_pickle=allow_pickle,
-                          pickle_kwargs=pickle_kwargs)
+                          pickle_kwargs=pickle_kwargs,
+                          max_header_size=max_header_size)
             return ret
         elif magic == format.MAGIC_PREFIX:
             # .npy file
             if mmap_mode:
-                return format.open_memmap(file, mode=mmap_mode)
+                if allow_pickle:
+                    max_header_size = 2**64
+                return format.open_memmap(file, mode=mmap_mode,
+                                          max_header_size=max_header_size)
             else:
                 return format.read_array(fid, allow_pickle=allow_pickle,
-                                         pickle_kwargs=pickle_kwargs)
+                                         pickle_kwargs=pickle_kwargs,
+                                         max_header_size=max_header_size)
         else:
             # Try a pickle
             if not allow_pickle:
@@ -720,122 +723,370 @@ def _savez(file, args, kwds, compress, allow_pickle=True, pickle_kwargs=None):
     zipf.close()
 
 
-def _floatconv(x):
-    try:
-        return float(x)  # The fastest path.
-    except ValueError:
-        if '0x' in x:  # Don't accidentally convert "a" ("0xa") to 10.
-            try:
-                return float.fromhex(x)
-            except ValueError:
-                pass
-        raise  # Raise the original exception, which makes more sense.
+def _ensure_ndmin_ndarray_check_param(ndmin):
+    """Just checks if the param ndmin is supported on
+        _ensure_ndmin_ndarray. It is intended to be used as
+        verification before running anything expensive.
+        e.g. loadtxt, genfromtxt
+    """
+    # Check correctness of the values of `ndmin`
+    if ndmin not in [0, 1, 2]:
+        raise ValueError(f"Illegal value of ndmin keyword: {ndmin}")
+
+def _ensure_ndmin_ndarray(a, *, ndmin: int):
+    """This is a helper function of loadtxt and genfromtxt to ensure
+        proper minimum dimension as requested
+
+        ndim : int. Supported values 1, 2, 3
+                    ^^ whenever this changes, keep in sync with
+                       _ensure_ndmin_ndarray_check_param
+    """
+    # Verify that the array has at least dimensions `ndmin`.
+    # Tweak the size and shape of the arrays - remove extraneous dimensions
+    if a.ndim > ndmin:
+        a = np.squeeze(a)
+    # and ensure we have the minimum number of dimensions asked for
+    # - has to be in this order for the odd case ndmin=1, a.squeeze().ndim=0
+    if a.ndim < ndmin:
+        if ndmin == 1:
+            a = np.atleast_1d(a)
+        elif ndmin == 2:
+            a = np.atleast_2d(a).T
+
+    return a
 
 
-_CONVERTERS = [  # These converters only ever get strs (not bytes) as input.
-    (np.bool_, lambda x: bool(int(x))),
-    (np.uint64, np.uint64),
-    (np.int64, np.int64),
-    (np.integer, lambda x: int(float(x))),
-    (np.longdouble, np.longdouble),
-    (np.floating, _floatconv),
-    (complex, lambda x: complex(x.replace('+-', '-'))),
-    (np.bytes_, methodcaller('encode', 'latin-1')),
-    (np.unicode_, str),
-]
+# amount of lines loadtxt reads in one chunk, can be overridden for testing
+_loadtxt_chunksize = 50000
+
+
+def _loadtxt_dispatcher(
+        fname, dtype=None, comments=None, delimiter=None,
+        converters=None, skiprows=None, usecols=None, unpack=None,
+        ndmin=None, encoding=None, max_rows=None, *, like=None):
+    return (like,)
 
 
-def _getconv(dtype):
+def _check_nonneg_int(value, name="argument"):
+    try:
+        operator.index(value)
+    except TypeError:
+        raise TypeError(f"{name} must be an integer") from None
+    if value < 0:
+        raise ValueError(f"{name} must be nonnegative")
+
+
+def _preprocess_comments(iterable, comments, encoding):
+    """
+    Generator that consumes a line iterated iterable and strips out the
+    multiple (or multi-character) comments from lines.
+    This is a pre-processing step to achieve feature parity with loadtxt
+    (we assume that this feature is a nieche feature).
     """
-    Find the correct dtype converter. Adapted from matplotlib.
+    for line in iterable:
+        if isinstance(line, bytes):
+            # Need to handle conversion here, or the splitting would fail
+            line = line.decode(encoding)
+
+        for c in comments:
+            line = line.split(c, 1)[0]
+
+        yield line
+
+
+# The number of rows we read in one go if confronted with a parametric dtype
+_loadtxt_chunksize = 50000
+
+
+def _read(fname, *, delimiter=',', comment='#', quote='"',
+          imaginary_unit='j', usecols=None, skiplines=0,
+          max_rows=None, converters=None, ndmin=None, unpack=False,
+          dtype=np.float64, encoding="bytes"):
+    r"""
+    Read a NumPy array from a text file.
+
+    Parameters
+    ----------
+    fname : str or file object
+        The filename or the file to be read.
+    delimiter : str, optional
+        Field delimiter of the fields in line of the file.
+        Default is a comma, ','.  If None any sequence of whitespace is
+        considered a delimiter.
+    comment : str or sequence of str or None, optional
+        Character that begins a comment.  All text from the comment
+        character to the end of the line is ignored.
+        Multiple comments or multiple-character comment strings are supported,
+        but may be slower and `quote` must be empty if used.
+        Use None to disable all use of comments.
+    quote : str or None, optional
+        Character that is used to quote string fields. Default is '"'
+        (a double quote). Use None to disable quote support.
+    imaginary_unit : str, optional
+        Character that represent the imaginay unit `sqrt(-1)`.
+        Default is 'j'.
+    usecols : array_like, optional
+        A one-dimensional array of integer column numbers.  These are the
+        columns from the file to be included in the array.  If this value
+        is not given, all the columns are used.
+    skiplines : int, optional
+        Number of lines to skip before interpreting the data in the file.
+    max_rows : int, optional
+        Maximum number of rows of data to read.  Default is to read the
+        entire file.
+    converters : dict or callable, optional
+        A function to parse all columns strings into the desired value, or
+        a dictionary mapping column number to a parser function.
+        E.g. if column 0 is a date string: ``converters = {0: datestr2num}``.
+        Converters can also be used to provide a default value for missing
+        data, e.g. ``converters = lambda s: float(s.strip() or 0)`` will
+        convert empty fields to 0.
+        Default: None
+    ndmin : int, optional
+        Minimum dimension of the array returned.
+        Allowed values are 0, 1 or 2.  Default is 0.
+    unpack : bool, optional
+        If True, the returned array is transposed, so that arguments may be
+        unpacked using ``x, y, z = read(...)``.  When used with a structured
+        data-type, arrays are returned for each field.  Default is False.
+    dtype : numpy data type
+        A NumPy dtype instance, can be a structured dtype to map to the
+        columns of the file.
+    encoding : str, optional
+        Encoding used to decode the inputfile. The special value 'bytes'
+        (the default) enables backwards-compatible behavior for `converters`,
+        ensuring that inputs to the converter functions are encoded
+        bytes objects. The special value 'bytes' has no additional effect if
+        ``converters=None``. If encoding is ``'bytes'`` or ``None``, the
+        default system encoding is used.
+
+    Returns
+    -------
+    ndarray
+        NumPy array.
 
-    Even when a lambda is returned, it is defined at the toplevel, to allow
-    testing for equality and enabling optimization for single-type data.
+    Examples
+    --------
+    First we create a file for the example.
+
+    >>> s1 = '1.0,2.0,3.0\n4.0,5.0,6.0\n'
+    >>> with open('example1.csv', 'w') as f:
+    ...     f.write(s1)
+    >>> a1 = read_from_filename('example1.csv')
+    >>> a1
+    array([[1., 2., 3.],
+           [4., 5., 6.]])
+
+    The second example has columns with different data types, so a
+    one-dimensional array with a structured data type is returned.
+    The tab character is used as the field delimiter.
+
+    >>> s2 = '1.0\t10\talpha\n2.3\t25\tbeta\n4.5\t16\tgamma\n'
+    >>> with open('example2.tsv', 'w') as f:
+    ...     f.write(s2)
+    >>> a2 = read_from_filename('example2.tsv', delimiter='\t')
+    >>> a2
+    array([(1. , 10, b'alpha'), (2.3, 25, b'beta'), (4.5, 16, b'gamma')],
+          dtype=[('f0', ' 1:
-                for dim in dt.shape[-2::-1]:
-                    packing = [(dim*packing[0][0], packing*dim)]
-            return ([dt.base] * int(np.prod(dt.shape)),
-                    functools.partial(_loadtxt_pack_items, packing))
+    # Handle special 'bytes' keyword for encoding
+    byte_converters = False
+    if encoding == 'bytes':
+        encoding = None
+        byte_converters = True
+
+    if dtype is None:
+        raise TypeError("a dtype must be provided.")
+    dtype = np.dtype(dtype)
+
+    read_dtype_via_object_chunks = None
+    if dtype.kind in 'SUM' and (
+            dtype == "S0" or dtype == "U0" or dtype == "M8" or dtype == 'm8'):
+        # This is a legacy "flexible" dtype.  We do not truly support
+        # parametric dtypes currently (no dtype discovery step in the core),
+        # but have to support these for backward compatibility.
+        read_dtype_via_object_chunks = dtype
+        dtype = np.dtype(object)
+
+    if usecols is not None:
+        # Allow usecols to be a single int or a sequence of ints, the C-code
+        # handles the rest
+        try:
+            usecols = list(usecols)
+        except TypeError:
+            usecols = [usecols]
+
+    _ensure_ndmin_ndarray_check_param(ndmin)
+
+    if comment is None:
+        comments = None
     else:
-        types = []
-        packing = []
-        for field in dt.names:
-            tp, bytes = dt.fields[field]
-            flat_dt, flat_packer = _loadtxt_flatten_dtype_internal(tp)
-            types.extend(flat_dt)
-            flat_packing = flat_packer.args[0] if flat_packer else None
-            # Avoid extra nesting for subarrays
-            if tp.ndim > 0:
-                packing.extend(flat_packing)
-            else:
-                packing.append((len(flat_dt), flat_packing))
-        return (types, functools.partial(_loadtxt_pack_items, packing))
-
-
-def _loadtxt_pack_items(packing, items):
-    """Pack items into nested lists based on re-packing info."""
-    if packing is None:
-        return items[0]
-    elif packing is tuple:
-        return tuple(items)
-    elif packing is list:
-        return list(items)
+        # assume comments are a sequence of strings
+        if "" in comment:
+            raise ValueError(
+                "comments cannot be an empty string. Use comments=None to "
+                "disable comments."
+            )
+        comments = tuple(comment)
+        comment = None
+        if len(comments) == 0:
+            comments = None  # No comments at all
+        elif len(comments) == 1:
+            # If there is only one comment, and that comment has one character,
+            # the normal parsing can deal with it just fine.
+            if isinstance(comments[0], str) and len(comments[0]) == 1:
+                comment = comments[0]
+                comments = None
+        else:
+            # Input validation if there are multiple comment characters
+            if delimiter in comments:
+                raise TypeError(
+                    f"Comment characters '{comments}' cannot include the "
+                    f"delimiter '{delimiter}'"
+                )
+
+    # comment is now either a 1 or 0 character string or a tuple:
+    if comments is not None:
+        # Note: An earlier version support two character comments (and could
+        #       have been extended to multiple characters, we assume this is
+        #       rare enough to not optimize for.
+        if quote is not None:
+            raise ValueError(
+                "when multiple comments or a multi-character comment is "
+                "given, quotes are not supported.  In this case quotechar "
+                "must be set to None.")
+
+    if len(imaginary_unit) != 1:
+        raise ValueError('len(imaginary_unit) must be 1.')
+
+    _check_nonneg_int(skiplines)
+    if max_rows is not None:
+        _check_nonneg_int(max_rows)
     else:
-        start = 0
-        ret = []
-        for length, subpacking in packing:
-            ret.append(
-                _loadtxt_pack_items(subpacking, items[start:start+length]))
-            start += length
-        return tuple(ret)
+        # Passing -1 to the C code means "read the entire file".
+        max_rows = -1
 
+    fh_closing_ctx = contextlib.nullcontext()
+    filelike = False
+    try:
+        if isinstance(fname, os.PathLike):
+            fname = os.fspath(fname)
+        if isinstance(fname, str):
+            fh = np.lib._datasource.open(fname, 'rt', encoding=encoding)
+            if encoding is None:
+                encoding = getattr(fh, 'encoding', 'latin1')
 
-# amount of lines loadtxt reads in one chunk, can be overridden for testing
-_loadtxt_chunksize = 50000
+            fh_closing_ctx = contextlib.closing(fh)
+            data = fh
+            filelike = True
+        else:
+            if encoding is None:
+                encoding = getattr(fname, 'encoding', 'latin1')
+            data = iter(fname)
+    except TypeError as e:
+        raise ValueError(
+            f"fname must be a string, filehandle, list of strings,\n"
+            f"or generator. Got {type(fname)} instead.") from e
 
+    with fh_closing_ctx:
+        if comments is not None:
+            if filelike:
+                data = iter(data)
+                filelike = False
+            data = _preprocess_comments(data, comments, encoding)
+
+        if read_dtype_via_object_chunks is None:
+            arr = _load_from_filelike(
+                data, delimiter=delimiter, comment=comment, quote=quote,
+                imaginary_unit=imaginary_unit,
+                usecols=usecols, skiplines=skiplines, max_rows=max_rows,
+                converters=converters, dtype=dtype,
+                encoding=encoding, filelike=filelike,
+                byte_converters=byte_converters)
 
-def _loadtxt_dispatcher(fname, dtype=None, comments=None, delimiter=None,
-                        converters=None, skiprows=None, usecols=None, unpack=None,
-                        ndmin=None, encoding=None, max_rows=None, *, like=None):
-    return (like,)
+        else:
+            # This branch reads the file into chunks of object arrays and then
+            # casts them to the desired actual dtype.  This ensures correct
+            # string-length and datetime-unit discovery (like `arr.astype()`).
+            # Due to chunking, certain error reports are less clear, currently.
+            if filelike:
+                data = iter(data)  # cannot chunk when reading from file
+
+            c_byte_converters = False
+            if read_dtype_via_object_chunks == "S":
+                c_byte_converters = True  # Use latin1 rather than ascii
+
+            chunks = []
+            while max_rows != 0:
+                if max_rows < 0:
+                    chunk_size = _loadtxt_chunksize
+                else:
+                    chunk_size = min(_loadtxt_chunksize, max_rows)
+
+                next_arr = _load_from_filelike(
+                    data, delimiter=delimiter, comment=comment, quote=quote,
+                    imaginary_unit=imaginary_unit,
+                    usecols=usecols, skiplines=skiplines, max_rows=max_rows,
+                    converters=converters, dtype=dtype,
+                    encoding=encoding, filelike=filelike,
+                    byte_converters=byte_converters,
+                    c_byte_converters=c_byte_converters)
+                # Cast here already.  We hope that this is better even for
+                # large files because the storage is more compact.  It could
+                # be adapted (in principle the concatenate could cast).
+                chunks.append(next_arr.astype(read_dtype_via_object_chunks))
+
+                skiprows = 0  # Only have to skip for first chunk
+                if max_rows >= 0:
+                    max_rows -= chunk_size
+                if len(next_arr) < chunk_size:
+                    # There was less data than requested, so we are done.
+                    break
+
+            # Need at least one chunk, but if empty, the last one may have
+            # the wrong shape.
+            if len(chunks) > 1 and len(chunks[-1]) == 0:
+                del chunks[-1]
+            if len(chunks) == 1:
+                arr = chunks[0]
+            else:
+                arr = np.concatenate(chunks, axis=0)
+
+    # NOTE: ndmin works as advertised for structured dtypes, but normally
+    #       these would return a 1D result plus the structured dimension,
+    #       so ndmin=2 adds a third dimension even when no squeezing occurs.
+    #       A `squeeze=False` could be a better solution (pandas uses squeeze).
+    arr = _ensure_ndmin_ndarray(arr, ndmin=ndmin)
+
+    if arr.shape:
+        if arr.shape[0] == 0:
+            warnings.warn(
+                f'loadtxt: input contained no data: "{fname}"',
+                category=UserWarning,
+                stacklevel=3
+            )
+
+    if unpack:
+        # Unpack structured dtypes if requested:
+        dt = arr.dtype
+        if dt.names is not None:
+            # For structured arrays, return an array for each field.
+            return [arr[field] for field in dt.names]
+        else:
+            return arr.T
+    else:
+        return arr
 
 
 @set_array_function_like_doc
 @set_module('numpy')
 def loadtxt(fname, dtype=float, comments='#', delimiter=None,
             converters=None, skiprows=0, usecols=None, unpack=False,
-            ndmin=0, encoding='bytes', max_rows=None, *, like=None):
+            ndmin=0, encoding='bytes', max_rows=None, *, quotechar=None,
+            like=None):
     r"""
     Load data from a text file.
 
-    Each row in the text file must have the same number of values.
-
     Parameters
     ----------
     fname : file, str, pathlib.Path, list of str, generator
@@ -849,20 +1100,29 @@ def loadtxt(fname, dtype=float, comments='#', delimiter=None,
         each row will be interpreted as an element of the array.  In this
         case, the number of columns used must match the number of fields in
         the data-type.
-    comments : str or sequence of str, optional
+    comments : str or sequence of str or None, optional
         The characters or list of characters used to indicate the start of a
         comment. None implies no comments. For backwards compatibility, byte
         strings will be decoded as 'latin1'. The default is '#'.
     delimiter : str, optional
-        The string used to separate values. For backwards compatibility, byte
-        strings will be decoded as 'latin1'. The default is whitespace.
-    converters : dict, optional
-        A dictionary mapping column number to a function that will parse the
-        column string into the desired value.  E.g., if column 0 is a date
-        string: ``converters = {0: datestr2num}``.  Converters can also be
-        used to provide a default value for missing data (but see also
-        `genfromtxt`): ``converters = {3: lambda s: float(s.strip() or 0)}``.
+        The character used to separate the values. For backwards compatibility,
+        byte strings will be decoded as 'latin1'. The default is whitespace.
+
+        .. versionchanged:: 1.23.0
+           Only single character delimiters are supported. Newline characters
+           cannot be used as the delimiter.
+
+    converters : dict or callable, optional
+        Converter functions to customize value parsing. If `converters` is
+        callable, the function is applied to all columns, else it must be a
+        dict that maps column number to a parser function.
+        See examples for further details.
         Default: None.
+
+        .. versionchanged:: 1.23.0
+           The ability to pass a single callable to be applied to all columns
+           was added.
+
     skiprows : int, optional
         Skip the first `skiprows` lines, including comments; default: 0.
     usecols : int or sequence, optional
@@ -895,10 +1155,27 @@ def loadtxt(fname, dtype=float, comments='#', delimiter=None,
 
         .. versionadded:: 1.14.0
     max_rows : int, optional
-        Read `max_rows` lines of content after `skiprows` lines. The default
-        is to read all the lines.
+        Read `max_rows` rows of content after `skiprows` lines. The default is
+        to read all the rows. Note that empty rows containing no data such as
+        empty lines and comment lines are not counted towards `max_rows`,
+        while such lines are counted in `skiprows`.
 
         .. versionadded:: 1.16.0
+        
+        .. versionchanged:: 1.23.0
+            Lines containing no data, including comment lines (e.g., lines 
+            starting with '#' or as specified via `comments`) are not counted 
+            towards `max_rows`.
+    quotechar : unicode character or None, optional
+        The character used to denote the start and end of a quoted item.
+        Occurrences of the delimiter or comment characters are ignored within
+        a quoted item. The default value is ``quotechar=None``, which means
+        quoting support is disabled.
+
+        If two consecutive instances of `quotechar` are found within a quoted
+        field, the first is treated as an escape character. See examples.
+
+        .. versionadded:: 1.23.0
     ${ARRAY_FUNCTION_LIKE}
 
         .. versionadded:: 1.20.0
@@ -920,6 +1197,11 @@ def loadtxt(fname, dtype=float, comments='#', delimiter=None,
     `genfromtxt` function provides more sophisticated handling of, e.g.,
     lines with missing values.
 
+    Each row in the input text file must have the same number of values to be
+    able to read all values. If all rows do not have same number of values, a
+    subset of up to n columns (where n is the least number of values present
+    in all rows) can be read by specifying the columns via `usecols`.
+
     .. versionadded:: 1.10.0
 
     The strings produced by the Python float.hex method can be used as
@@ -946,6 +1228,29 @@ def loadtxt(fname, dtype=float, comments='#', delimiter=None,
     >>> y
     array([2., 4.])
 
+    The `converters` argument is used to specify functions to preprocess the
+    text prior to parsing. `converters` can be a dictionary that maps
+    preprocessing functions to each column:
+
+    >>> s = StringIO("1.618, 2.296\n3.141, 4.669\n")
+    >>> conv = {
+    ...     0: lambda x: np.floor(float(x)),  # conversion fn for column 0
+    ...     1: lambda x: np.ceil(float(x)),  # conversion fn for column 1
+    ... }
+    >>> np.loadtxt(s, delimiter=",", converters=conv)
+    array([[1., 3.],
+           [3., 5.]])
+
+    `converters` can be a callable instead of a dictionary, in which case it
+    is applied to all columns:
+
+    >>> s = StringIO("0xDE 0xAD\n0xC0 0xDE")
+    >>> import functools
+    >>> conv = functools.partial(int, base=16)
+    >>> np.loadtxt(s, converters=conv)
+    array([[222., 173.],
+           [192., 222.]])
+
     This example shows how `converters` can be used to convert a field
     with a trailing minus sign into a negative number.
 
@@ -953,258 +1258,111 @@ def loadtxt(fname, dtype=float, comments='#', delimiter=None,
     >>> def conv(fld):
     ...     return -float(fld[:-1]) if fld.endswith(b'-') else float(fld)
     ...
-    >>> np.loadtxt(s, converters={0: conv, 1: conv})
+    >>> np.loadtxt(s, converters=conv)
     array([[ 10.01, -31.25],
            [ 19.22,  64.31],
            [-17.57,  63.94]])
-    """
 
-    if like is not None:
-        return _loadtxt_with_like(
-            fname, dtype=dtype, comments=comments, delimiter=delimiter,
-            converters=converters, skiprows=skiprows, usecols=usecols,
-            unpack=unpack, ndmin=ndmin, encoding=encoding,
-            max_rows=max_rows, like=like
-        )
+    Using a callable as the converter can be particularly useful for handling
+    values with different formatting, e.g. floats with underscores:
 
-    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-    # Nested functions used by loadtxt.
-    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+    >>> s = StringIO("1 2.7 100_000")
+    >>> np.loadtxt(s, converters=float)
+    array([1.e+00, 2.7e+00, 1.e+05])
 
-    def split_line(line: str):
-        """Chop off comments, strip, and split at delimiter."""
-        for comment in comments:  # Much faster than using a single regex.
-            line = line.split(comment, 1)[0]
-        line = line.strip('\r\n')
-        return line.split(delimiter) if line else []
+    This idea can be extended to automatically handle values specified in
+    many different formats:
 
-    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-    # Main body of loadtxt.
-    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+    >>> def conv(val):
+    ...     try:
+    ...         return float(val)
+    ...     except ValueError:
+    ...         return float.fromhex(val)
+    >>> s = StringIO("1, 2.5, 3_000, 0b4, 0x1.4000000000000p+2")
+    >>> np.loadtxt(s, delimiter=",", converters=conv, encoding=None)
+    array([1.0e+00, 2.5e+00, 3.0e+03, 1.8e+02, 5.0e+00])
 
-    # Check correctness of the values of `ndmin`
-    if ndmin not in [0, 1, 2]:
-        raise ValueError('Illegal value of ndmin keyword: %s' % ndmin)
+    Note that with the default ``encoding="bytes"``, the inputs to the
+    converter function are latin-1 encoded byte strings. To deactivate the
+    implicit encoding prior to conversion, use ``encoding=None``
 
-    # Type conversions for Py3 convenience
-    if comments is not None:
-        if isinstance(comments, (str, bytes)):
-            comments = [comments]
-        comments = [_decode_line(x) for x in comments]
-    else:
-        comments = []
+    >>> s = StringIO('10.01 31.25-\n19.22 64.31\n17.57- 63.94')
+    >>> conv = lambda x: -float(x[:-1]) if x.endswith('-') else float(x)
+    >>> np.loadtxt(s, converters=conv, encoding=None)
+    array([[ 10.01, -31.25],
+           [ 19.22,  64.31],
+           [-17.57,  63.94]])
 
-    if delimiter is not None:
-        delimiter = _decode_line(delimiter)
+    Support for quoted fields is enabled with the `quotechar` parameter.
+    Comment and delimiter characters are ignored when they appear within a
+    quoted item delineated by `quotechar`:
 
-    user_converters = converters
+    >>> s = StringIO('"alpha, #42", 10.0\n"beta, #64", 2.0\n')
+    >>> dtype = np.dtype([("label", "U12"), ("value", float)])
+    >>> np.loadtxt(s, dtype=dtype, delimiter=",", quotechar='"')
+    array([('alpha, #42', 10.), ('beta, #64',  2.)],
+          dtype=[('label', ' 1:
-            usecols_getter = itemgetter(*usecols)
-        else:
-            # Get an iterable back, even if using a single column.
-            usecols_getter = lambda obj, c=usecols[0]: [obj[c]]
-    else:
-        usecols_getter = None
+    >>> s = StringIO('"alpha, #42"       10.0\n"beta, #64" 2.0\n')
+    >>> dtype = np.dtype([("label", "U12"), ("value", float)])
+    >>> np.loadtxt(s, dtype=dtype, delimiter=None, quotechar='"')
+    array([('alpha, #42', 10.), ('beta, #64',  2.)],
+          dtype=[('label', '>> s = StringIO('"Hello, my name is ""Monty""!"')
+    >>> np.loadtxt(s, dtype="U", delimiter=",", quotechar='"')
+    array('Hello, my name is "Monty"!', dtype='>> d = StringIO("1 2\n2 4\n3 9 12\n4 16 20")
+    >>> np.loadtxt(d, usecols=(0, 1))
+    array([[ 1.,  2.],
+           [ 2.,  4.],
+           [ 3.,  9.],
+           [ 4., 16.]])
 
-        # input may be a python2 io stream
-        if encoding is not None:
-            fencoding = encoding
-        # we must assume local encoding
-        # TODO emit portability warning?
-        elif fencoding is None:
-            import locale
-            fencoding = locale.getpreferredencoding()
-
-        # Skip the first `skiprows` lines
-        for i in range(skiprows):
-            next(line_iter)
-
-        # Read until we find a line with some values, and use it to determine
-        # the need for decoding and estimate the number of columns.
-        for first_line in line_iter:
-            ncols = len(usecols or split_line(first_line))
-            if ncols:
-                # Put first_line back.
-                line_iter = itertools.chain([first_line], line_iter)
-                break
-        else:  # End of lines reached
-            ncols = len(usecols or [])
-            warnings.warn('loadtxt: Empty input file: "%s"' % fname,
-                          stacklevel=2)
-
-        line_iter = itertools.islice(line_iter, max_rows)
-        lineno_words_iter = filter(
-            itemgetter(1),  # item[1] is words; filter skips empty lines.
-            enumerate(map(split_line, line_iter), 1 + skiprows))
-
-        # Now that we know ncols, create the default converters list, and
-        # set packing, if necessary.
-        if len(dtype_types) > 1:
-            # We're dealing with a structured array, each field of
-            # the dtype matches a column
-            converters = [_getconv(dt) for dt in dtype_types]
-        else:
-            # All fields have the same dtype; use specialized packers which are
-            # much faster than those using _loadtxt_pack_items.
-            converters = [defconv for i in range(ncols)]
-            if ncols == 1:
-                packer = itemgetter(0)
-            else:
-                def packer(row): return row
+    """
 
-        # By preference, use the converters specified by the user
-        for i, conv in (user_converters or {}).items():
-            if usecols:
-                try:
-                    i = usecols.index(i)
-                except ValueError:
-                    # Unused converter specified
-                    continue
-            if byte_converters:
-                # converters may use decode to workaround numpy's old
-                # behaviour, so encode the string again (converters are only
-                # called with strings) before passing to the user converter.
-                def tobytes_first(conv, x):
-                    return conv(x.encode("latin1"))
-                converters[i] = functools.partial(tobytes_first, conv)
-            else:
-                converters[i] = conv
-
-        fencode = methodcaller("encode", fencoding)
-        converters = [conv if conv is not bytes else fencode
-                      for conv in converters]
-        if len(set(converters)) == 1:
-            # Optimize single-type data. Note that this is only reached if
-            # `_getconv` returns equal callables (i.e. not local lambdas) on
-            # equal dtypes.
-            def convert_row(vals, _conv=converters[0]):
-                return [*map(_conv, vals)]
-        else:
-            def convert_row(vals):
-                return [conv(val) for conv, val in zip(converters, vals)]
-
-        # read data in chunks and fill it into an array via resize
-        # over-allocating and shrinking the array later may be faster but is
-        # probably not relevant compared to the cost of actually reading and
-        # converting the data
-        X = None
-        while True:
-            chunk = []
-            for lineno, words in itertools.islice(
-                    lineno_words_iter, _loadtxt_chunksize):
-                if usecols_getter is not None:
-                    words = usecols_getter(words)
-                elif len(words) != ncols:
-                    raise ValueError(
-                        f"Wrong number of columns at line {lineno}")
-                # Convert each value according to its column, then pack it
-                # according to the dtype's nesting, and store it.
-                chunk.append(packer(convert_row(words)))
-            if not chunk:  # The islice is empty, i.e. we're done.
-                break
+    if like is not None:
+        return _loadtxt_with_like(
+            fname, dtype=dtype, comments=comments, delimiter=delimiter,
+            converters=converters, skiprows=skiprows, usecols=usecols,
+            unpack=unpack, ndmin=ndmin, encoding=encoding,
+            max_rows=max_rows, like=like
+        )
 
-            if X is None:
-                X = np.array(chunk, dtype)
-            else:
-                nshape = list(X.shape)
-                pos = nshape[0]
-                nshape[0] += len(chunk)
-                X.resize(nshape, refcheck=False)
-                X[pos:, ...] = chunk
+    if isinstance(delimiter, bytes):
+        delimiter.decode("latin1")
 
-    if X is None:
-        X = np.array([], dtype)
+    if dtype is None:
+        dtype = np.float64
 
-    # Multicolumn data are returned with shape (1, N, M), i.e.
-    # (1, 1, M) for a single row - remove the singleton dimension there
-    if X.ndim == 3 and X.shape[:2] == (1, 1):
-        X.shape = (1, -1)
+    comment = comments
+    # Control character type conversions for Py3 convenience
+    if comment is not None:
+        if isinstance(comment, (str, bytes)):
+            comment = [comment]
+        comment = [
+            x.decode('latin1') if isinstance(x, bytes) else x for x in comment]
+    if isinstance(delimiter, bytes):
+        delimiter = delimiter.decode('latin1')
 
-    # Verify that the array has at least dimensions `ndmin`.
-    # Tweak the size and shape of the arrays - remove extraneous dimensions
-    if X.ndim > ndmin:
-        X = np.squeeze(X)
-    # and ensure we have the minimum number of dimensions asked for
-    # - has to be in this order for the odd case ndmin=1, X.squeeze().ndim=0
-    if X.ndim < ndmin:
-        if ndmin == 1:
-            X = np.atleast_1d(X)
-        elif ndmin == 2:
-            X = np.atleast_2d(X).T
+    arr = _read(fname, dtype=dtype, comment=comment, delimiter=delimiter,
+                converters=converters, skiplines=skiprows, usecols=usecols,
+                unpack=unpack, ndmin=ndmin, encoding=encoding,
+                max_rows=max_rows, quote=quotechar)
 
-    if unpack:
-        if len(dtype_types) > 1:
-            # For structured arrays, return an array for each field.
-            return [X[field] for field in dtype.names]
-        else:
-            return X.T
-    else:
-        return X
+    return arr
 
 
 _loadtxt_with_like = array_function_dispatch(
-    _loadtxt_dispatcher
+    _loadtxt_dispatcher, use_like=True
 )(loadtxt)
 
 
@@ -1572,8 +1730,8 @@ def _genfromtxt_dispatcher(fname, dtype=None, comments=None, delimiter=None,
                            names=None, excludelist=None, deletechars=None,
                            replace_space=None, autostrip=None, case_sensitive=None,
                            defaultfmt=None, unpack=None, usemask=None, loose=None,
-                           invalid_raise=None, max_rows=None, encoding=None, *,
-                           like=None):
+                           invalid_raise=None, max_rows=None, encoding=None,
+                           *, ndmin=None, like=None):
     return (like,)
 
 
@@ -1586,8 +1744,8 @@ def genfromtxt(fname, dtype=float, comments='#', delimiter=None,
                deletechars=''.join(sorted(NameValidator.defaultdeletechars)),
                replace_space='_', autostrip=False, case_sensitive=True,
                defaultfmt="f%i", unpack=None, usemask=False, loose=True,
-               invalid_raise=True, max_rows=None, encoding='bytes', *,
-               like=None):
+               invalid_raise=True, max_rows=None, encoding='bytes',
+               *, ndmin=0, like=None):
     """
     Load data from a text file, with missing values handled as specified.
 
@@ -1686,6 +1844,10 @@ def genfromtxt(fname, dtype=float, comments='#', delimiter=None,
         to None the system default is used. The default value is 'bytes'.
 
         .. versionadded:: 1.14.0
+    ndmin : int, optional
+        Same parameter as `loadtxt`
+
+        .. versionadded:: 1.23.0
     ${ARRAY_FUNCTION_LIKE}
 
         .. versionadded:: 1.20.0
@@ -1779,9 +1941,12 @@ def genfromtxt(fname, dtype=float, comments='#', delimiter=None,
             case_sensitive=case_sensitive, defaultfmt=defaultfmt,
             unpack=unpack, usemask=usemask, loose=loose,
             invalid_raise=invalid_raise, max_rows=max_rows, encoding=encoding,
+            ndmin=ndmin,
             like=like
         )
 
+    _ensure_ndmin_ndarray_check_param(ndmin)
+
     if max_rows is not None:
         if skip_footer:
             raise ValueError(
@@ -1806,22 +1971,21 @@ def genfromtxt(fname, dtype=float, comments='#', delimiter=None,
         byte_converters = False
 
     # Initialize the filehandle, the LineSplitter and the NameValidator
+    if isinstance(fname, os_PathLike):
+        fname = os_fspath(fname)
+    if isinstance(fname, str):
+        fid = np.lib._datasource.open(fname, 'rt', encoding=encoding)
+        fid_ctx = contextlib.closing(fid)
+    else:
+        fid = fname
+        fid_ctx = contextlib.nullcontext(fid)
     try:
-        if isinstance(fname, os_PathLike):
-            fname = os_fspath(fname)
-        if isinstance(fname, str):
-            fid = np.lib._datasource.open(fname, 'rt', encoding=encoding)
-            fid_ctx = contextlib.closing(fid)
-        else:
-            fid = fname
-            fid_ctx = contextlib.nullcontext(fid)
         fhd = iter(fid)
     except TypeError as e:
         raise TypeError(
-            f"fname must be a string, filehandle, list of strings,\n"
-            f"or generator. Got {type(fname)} instead."
+            "fname must be a string, a filehandle, a sequence of strings,\n"
+            f"or an iterator of strings. Got {type(fname)} instead."
         ) from e
-
     with fid_ctx:
         split_line = LineSplitter(delimiter=delimiter, comments=comments,
                                   autostrip=autostrip, encoding=encoding)
@@ -2291,7 +2455,9 @@ def encode_unicode_cols(row_tup):
     if usemask:
         output = output.view(MaskedArray)
         output._mask = outputmask
-    output = np.squeeze(output)
+
+    output = _ensure_ndmin_ndarray(output, ndmin=ndmin)
+
     if unpack:
         if names is None:
             return output.T
@@ -2306,7 +2472,7 @@ def encode_unicode_cols(row_tup):
 
 
 _genfromtxt_with_like = array_function_dispatch(
-    _genfromtxt_dispatcher
+    _genfromtxt_dispatcher, use_like=True
 )(genfromtxt)
 
 
diff --git a/numpy/lib/npyio.pyi b/numpy/lib/npyio.pyi
index 8fd36ca6f66b..8007b2dc717b 100644
--- a/numpy/lib/npyio.pyi
+++ b/numpy/lib/npyio.pyi
@@ -2,23 +2,16 @@ import os
 import sys
 import zipfile
 import types
+from re import Pattern
+from collections.abc import Collection, Mapping, Iterator, Sequence, Callable, Iterable
 from typing import (
     Literal as L,
     Any,
-    Mapping,
     TypeVar,
     Generic,
-    List,
-    Type,
-    Iterator,
-    Union,
     IO,
     overload,
-    Sequence,
-    Callable,
-    Pattern,
     Protocol,
-    Iterable,
 )
 
 from numpy import (
@@ -33,7 +26,13 @@ from numpy import (
 )
 
 from numpy.ma.mrecords import MaskedRecords
-from numpy.typing import ArrayLike, DTypeLike, NDArray, _SupportsDType
+from numpy._typing import (
+    ArrayLike,
+    DTypeLike,
+    NDArray,
+    _DTypeLike,
+    _SupportsArrayFunc,
+)
 
 from numpy.core.multiarray import (
     packbits as packbits,
@@ -47,12 +46,6 @@ _SCT = TypeVar("_SCT", bound=generic)
 _CharType_co = TypeVar("_CharType_co", str, bytes, covariant=True)
 _CharType_contra = TypeVar("_CharType_contra", str, bytes, contravariant=True)
 
-_DTypeLike = Union[
-    Type[_SCT],
-    dtype[_SCT],
-    _SupportsDType[dtype[_SCT]],
-]
-
 class _SupportsGetItem(Protocol[_T_contra, _T_co]):
     def __getitem__(self, key: _T_contra, /) -> _T_co: ...
 
@@ -66,17 +59,17 @@ class _SupportsReadSeek(Protocol[_CharType_co]):
 class _SupportsWrite(Protocol[_CharType_contra]):
     def write(self, s: _CharType_contra, /) -> object: ...
 
-__all__: List[str]
+__all__: list[str]
 
 class BagObj(Generic[_T_co]):
     def __init__(self, obj: _SupportsGetItem[str, _T_co]) -> None: ...
     def __getattribute__(self, key: str) -> _T_co: ...
-    def __dir__(self) -> List[str]: ...
+    def __dir__(self) -> list[str]: ...
 
 class NpzFile(Mapping[str, NDArray[Any]]):
     zip: zipfile.ZipFile
     fid: None | IO[str]
-    files: List[str]
+    files: list[str]
     allow_pickle: bool
     pickle_kwargs: None | Mapping[str, Any]
     # Represent `f` as a mutable property so we can access the type of `self`
@@ -94,7 +87,7 @@ class NpzFile(Mapping[str, NDArray[Any]]):
     def __enter__(self: _T) -> _T: ...
     def __exit__(
         self,
-        exc_type: None | Type[BaseException],
+        exc_type: None | type[BaseException],
         exc_value: None | BaseException,
         traceback: None | types.TracebackType,
         /,
@@ -140,7 +133,7 @@ def savez_compressed(
 def loadtxt(
     fname: str | os.PathLike[str] | Iterable[str] | Iterable[bytes],
     dtype: None = ...,
-    comments: str | Sequence[str] = ...,
+    comments: None | str | Sequence[str] = ...,
     delimiter: None | str = ...,
     converters: None | Mapping[int | str, Callable[[str], Any]] = ...,
     skiprows: int = ...,
@@ -150,13 +143,14 @@ def loadtxt(
     encoding: None | str = ...,
     max_rows: None | int = ...,
     *,
-    like: None | ArrayLike = ...
+    quotechar: None | str = ...,
+    like: None | _SupportsArrayFunc = ...
 ) -> NDArray[float64]: ...
 @overload
 def loadtxt(
     fname: str | os.PathLike[str] | Iterable[str] | Iterable[bytes],
     dtype: _DTypeLike[_SCT],
-    comments: str | Sequence[str] = ...,
+    comments: None | str | Sequence[str] = ...,
     delimiter: None | str = ...,
     converters: None | Mapping[int | str, Callable[[str], Any]] = ...,
     skiprows: int = ...,
@@ -166,13 +160,14 @@ def loadtxt(
     encoding: None | str = ...,
     max_rows: None | int = ...,
     *,
-    like: None | ArrayLike = ...
+    quotechar: None | str = ...,
+    like: None | _SupportsArrayFunc = ...
 ) -> NDArray[_SCT]: ...
 @overload
 def loadtxt(
     fname: str | os.PathLike[str] | Iterable[str] | Iterable[bytes],
     dtype: DTypeLike,
-    comments: str | Sequence[str] = ...,
+    comments: None | str | Sequence[str] = ...,
     delimiter: None | str = ...,
     converters: None | Mapping[int | str, Callable[[str], Any]] = ...,
     skiprows: int = ...,
@@ -182,7 +177,8 @@ def loadtxt(
     encoding: None | str = ...,
     max_rows: None | int = ...,
     *,
-    like: None | ArrayLike = ...
+    quotechar: None | str = ...,
+    like: None | _SupportsArrayFunc = ...
 ) -> NDArray[Any]: ...
 
 def savetxt(
@@ -212,27 +208,92 @@ def fromregex(
     encoding: None | str = ...
 ) -> NDArray[Any]: ...
 
-# TODO: Sort out arguments
 @overload
 def genfromtxt(
     fname: str | os.PathLike[str] | Iterable[str] | Iterable[bytes],
     dtype: None = ...,
-    *args: Any,
-    **kwargs: Any,
+    comments: str = ...,
+    delimiter: None | str | int | Iterable[int] = ...,
+    skip_header: int = ...,
+    skip_footer: int = ...,
+    converters: None | Mapping[int | str, Callable[[str], Any]] = ...,
+    missing_values: Any = ...,
+    filling_values: Any = ...,
+    usecols: None | Sequence[int] = ...,
+    names: L[None, True] | str | Collection[str] = ...,
+    excludelist: None | Sequence[str] = ...,
+    deletechars: str = ...,
+    replace_space: str = ...,
+    autostrip: bool = ...,
+    case_sensitive: bool | L['upper', 'lower'] = ...,
+    defaultfmt: str = ...,
+    unpack: None | bool = ...,
+    usemask: bool = ...,
+    loose: bool = ...,
+    invalid_raise: bool = ...,
+    max_rows: None | int = ...,
+    encoding: str = ...,
+    *,
+    ndmin: L[0, 1, 2] = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[float64]: ...
 @overload
 def genfromtxt(
     fname: str | os.PathLike[str] | Iterable[str] | Iterable[bytes],
     dtype: _DTypeLike[_SCT],
-    *args: Any,
-    **kwargs: Any,
+    comments: str = ...,
+    delimiter: None | str | int | Iterable[int] = ...,
+    skip_header: int = ...,
+    skip_footer: int = ...,
+    converters: None | Mapping[int | str, Callable[[str], Any]] = ...,
+    missing_values: Any = ...,
+    filling_values: Any = ...,
+    usecols: None | Sequence[int] = ...,
+    names: L[None, True] | str | Collection[str] = ...,
+    excludelist: None | Sequence[str] = ...,
+    deletechars: str = ...,
+    replace_space: str = ...,
+    autostrip: bool = ...,
+    case_sensitive: bool | L['upper', 'lower'] = ...,
+    defaultfmt: str = ...,
+    unpack: None | bool = ...,
+    usemask: bool = ...,
+    loose: bool = ...,
+    invalid_raise: bool = ...,
+    max_rows: None | int = ...,
+    encoding: str = ...,
+    *,
+    ndmin: L[0, 1, 2] = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[_SCT]: ...
 @overload
 def genfromtxt(
     fname: str | os.PathLike[str] | Iterable[str] | Iterable[bytes],
     dtype: DTypeLike,
-    *args: Any,
-    **kwargs: Any,
+    comments: str = ...,
+    delimiter: None | str | int | Iterable[int] = ...,
+    skip_header: int = ...,
+    skip_footer: int = ...,
+    converters: None | Mapping[int | str, Callable[[str], Any]] = ...,
+    missing_values: Any = ...,
+    filling_values: Any = ...,
+    usecols: None | Sequence[int] = ...,
+    names: L[None, True] | str | Collection[str] = ...,
+    excludelist: None | Sequence[str] = ...,
+    deletechars: str = ...,
+    replace_space: str = ...,
+    autostrip: bool = ...,
+    case_sensitive: bool | L['upper', 'lower'] = ...,
+    defaultfmt: str = ...,
+    unpack: None | bool = ...,
+    usemask: bool = ...,
+    loose: bool = ...,
+    invalid_raise: bool = ...,
+    max_rows: None | int = ...,
+    encoding: str = ...,
+    *,
+    ndmin: L[0, 1, 2] = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[Any]: ...
 
 @overload
diff --git a/numpy/lib/polynomial.py b/numpy/lib/polynomial.py
index f824c4c5e2c1..6aa7088616b2 100644
--- a/numpy/lib/polynomial.py
+++ b/numpy/lib/polynomial.py
@@ -686,7 +686,7 @@ def polyfit(x, y, deg, rcond=None, full=False, w=None, cov=False):
                                  "to scale the covariance matrix")
             # note, this used to be: fac = resids / (len(x) - order - 2.0)
             # it was deciced that the "- 2" (originally justified by "Bayesian
-            # uncertainty analysis") is not was the user expects
+            # uncertainty analysis") is not what the user expects
             # (see gh-11196 and gh-11197)
             fac = resids / (len(x) - order)
         if y.ndim == 1:
diff --git a/numpy/lib/polynomial.pyi b/numpy/lib/polynomial.pyi
index 00065f53b227..14bbaf39d249 100644
--- a/numpy/lib/polynomial.pyi
+++ b/numpy/lib/polynomial.pyi
@@ -1,12 +1,10 @@
 from typing import (
     Literal as L,
-    List,
     overload,
     Any,
     SupportsInt,
     SupportsIndex,
     TypeVar,
-    Tuple,
     NoReturn,
 )
 
@@ -25,7 +23,7 @@ from numpy import (
     object_,
 )
 
-from numpy.typing import (
+from numpy._typing import (
     NDArray,
     ArrayLike,
     _ArrayLikeBool_co,
@@ -38,8 +36,8 @@ from numpy.typing import (
 
 _T = TypeVar("_T")
 
-_2Tup = Tuple[_T, _T]
-_5Tup = Tuple[
+_2Tup = tuple[_T, _T]
+_5Tup = tuple[
     _T,
     NDArray[float64],
     NDArray[int32],
@@ -47,7 +45,7 @@ _5Tup = Tuple[
     NDArray[float64],
 ]
 
-__all__: List[str]
+__all__: list[str]
 
 def poly(seq_of_zeros: ArrayLike) -> NDArray[floating[Any]]: ...
 
diff --git a/numpy/lib/recfunctions.py b/numpy/lib/recfunctions.py
index a491f612e075..6afcf1b7fc57 100644
--- a/numpy/lib/recfunctions.py
+++ b/numpy/lib/recfunctions.py
@@ -13,7 +13,6 @@
 from numpy.ma.mrecords import MaskedRecords
 from numpy.core.overrides import array_function_dispatch
 from numpy.lib._iotools import _is_string_like
-from numpy.testing import suppress_warnings
 
 _check_fill_value = np.ma.core._check_fill_value
 
@@ -105,7 +104,8 @@ def _get_fieldspec(dtype):
 
 def get_names(adtype):
     """
-    Returns the field names of the input datatype as a tuple.
+    Returns the field names of the input datatype as a tuple. Input datatype
+    must have fields otherwise error is raised.
 
     Parameters
     ----------
@@ -115,15 +115,10 @@ def get_names(adtype):
     Examples
     --------
     >>> from numpy.lib import recfunctions as rfn
-    >>> rfn.get_names(np.empty((1,), dtype=int))
-    Traceback (most recent call last):
-        ...
-    AttributeError: 'numpy.ndarray' object has no attribute 'names'
-
-    >>> rfn.get_names(np.empty((1,), dtype=[('A',int), ('B', float)]))
-    Traceback (most recent call last):
-        ...
-    AttributeError: 'numpy.ndarray' object has no attribute 'names'
+    >>> rfn.get_names(np.empty((1,), dtype=[('A', int)]).dtype)
+    ('A',)
+    >>> rfn.get_names(np.empty((1,), dtype=[('A',int), ('B', float)]).dtype)
+    ('A', 'B')
     >>> adtype = np.dtype([('a', int), ('b', [('ba', int), ('bb', int)])])
     >>> rfn.get_names(adtype)
     ('a', ('b', ('ba', 'bb')))
@@ -141,8 +136,9 @@ def get_names(adtype):
 
 def get_names_flat(adtype):
     """
-    Returns the field names of the input datatype as a tuple. Nested structure
-    are flattened beforehand.
+    Returns the field names of the input datatype as a tuple. Input datatype
+    must have fields otherwise error is raised.
+    Nested structure are flattened beforehand.
 
     Parameters
     ----------
@@ -152,14 +148,10 @@ def get_names_flat(adtype):
     Examples
     --------
     >>> from numpy.lib import recfunctions as rfn
-    >>> rfn.get_names_flat(np.empty((1,), dtype=int)) is None
-    Traceback (most recent call last):
-        ...
-    AttributeError: 'numpy.ndarray' object has no attribute 'names'
-    >>> rfn.get_names_flat(np.empty((1,), dtype=[('A',int), ('B', float)]))
-    Traceback (most recent call last):
-        ...
-    AttributeError: 'numpy.ndarray' object has no attribute 'names'
+    >>> rfn.get_names_flat(np.empty((1,), dtype=[('A', int)]).dtype) is None
+    False
+    >>> rfn.get_names_flat(np.empty((1,), dtype=[('A',int), ('B', str)]).dtype)
+    ('A', 'B')
     >>> adtype = np.dtype([('a', int), ('b', [('ba', int), ('bb', int)])])
     >>> rfn.get_names_flat(adtype)
     ('a', 'b', 'ba', 'bb')
@@ -784,7 +776,8 @@ def repack_fields(a, align=False, recurse=False):
 
     This method removes any overlaps and reorders the fields in memory so they
     have increasing byte offsets, and adds or removes padding bytes depending
-    on the `align` option, which behaves like the `align` option to `np.dtype`.
+    on the `align` option, which behaves like the `align` option to
+    `numpy.dtype`.
 
     If `align=False`, this method produces a "packed" memory layout in which
     each field starts at the byte the previous field ended, and any padding
@@ -917,11 +910,12 @@ def structured_to_unstructured(arr, dtype=None, copy=False, casting='unsafe'):
     dtype : dtype, optional
        The dtype of the output unstructured array.
     copy : bool, optional
-        See copy argument to `ndarray.astype`. If true, always return a copy.
-        If false, and `dtype` requirements are satisfied, a view is returned.
+        See copy argument to `numpy.ndarray.astype`. If true, always return a
+        copy. If false, and `dtype` requirements are satisfied, a view is
+        returned.
     casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
-        See casting argument of `ndarray.astype`. Controls what kind of data
-        casting may occur.
+        See casting argument of `numpy.ndarray.astype`. Controls what kind of
+        data casting may occur.
 
     Returns
     -------
@@ -976,9 +970,7 @@ def structured_to_unstructured(arr, dtype=None, copy=False, casting='unsafe'):
                                  'formats': dts,
                                  'offsets': offsets,
                                  'itemsize': arr.dtype.itemsize})
-    with suppress_warnings() as sup:  # until 1.16 (gh-12447)
-        sup.filter(FutureWarning, "Numpy has detected")
-        arr = arr.view(flattened_fields)
+    arr = arr.view(flattened_fields)
 
     # next cast to a packed format with all fields converted to new dtype
     packed_fields = np.dtype({'names': names,
@@ -1020,11 +1012,12 @@ def unstructured_to_structured(arr, dtype=None, names=None, align=False,
     align : boolean, optional
        Whether to create an aligned memory layout.
     copy : bool, optional
-        See copy argument to `ndarray.astype`. If true, always return a copy.
-        If false, and `dtype` requirements are satisfied, a view is returned.
+        See copy argument to `numpy.ndarray.astype`. If true, always return a
+        copy. If false, and `dtype` requirements are satisfied, a view is
+        returned.
     casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
-        See casting argument of `ndarray.astype`. Controls what kind of data
-        casting may occur.
+        See casting argument of `numpy.ndarray.astype`. Controls what kind of
+        data casting may occur.
 
     Returns
     -------
@@ -1064,6 +1057,8 @@ def unstructured_to_structured(arr, dtype=None, names=None, align=False,
     else:
         if names is not None:
             raise ValueError("don't supply both dtype and names")
+        # if dtype is the args of np.dtype, construct it
+        dtype = np.dtype(dtype)
         # sanity check of the input dtype
         fields = _get_fields_and_offsets(dtype)
         if len(fields) == 0:
diff --git a/numpy/lib/scimath.py b/numpy/lib/scimath.py
index 308f1328bb35..b7ef0d7109c6 100644
--- a/numpy/lib/scimath.py
+++ b/numpy/lib/scimath.py
@@ -234,6 +234,15 @@ def sqrt(x):
     >>> np.emath.sqrt([-1,4])
     array([0.+1.j, 2.+0.j])
 
+    Different results are expected because:
+    floating point 0.0 and -0.0 are distinct.
+
+    For more control, explicitly use complex() as follows:
+
+    >>> np.emath.sqrt(complex(-4.0, 0.0))
+    2j
+    >>> np.emath.sqrt(complex(-4.0, -0.0))
+    -2j
     """
     x = _fix_real_lt_zero(x)
     return nx.sqrt(x)
diff --git a/numpy/lib/scimath.pyi b/numpy/lib/scimath.pyi
index d0d4af41eb0c..589feb15f8ff 100644
--- a/numpy/lib/scimath.pyi
+++ b/numpy/lib/scimath.pyi
@@ -1,13 +1,94 @@
-from typing import List
-
-__all__: List[str]
-
-def sqrt(x): ...
-def log(x): ...
-def log10(x): ...
-def logn(n, x): ...
-def log2(x): ...
-def power(x, p): ...
-def arccos(x): ...
-def arcsin(x): ...
-def arctanh(x): ...
+from typing import overload, Any
+
+from numpy import complexfloating
+
+from numpy._typing import (
+    NDArray,
+    _ArrayLikeFloat_co,
+    _ArrayLikeComplex_co,
+    _ComplexLike_co,
+    _FloatLike_co,
+)
+
+__all__: list[str]
+
+@overload
+def sqrt(x: _FloatLike_co) -> Any: ...
+@overload
+def sqrt(x: _ComplexLike_co) -> complexfloating[Any, Any]: ...
+@overload
+def sqrt(x: _ArrayLikeFloat_co) -> NDArray[Any]: ...
+@overload
+def sqrt(x: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ...
+
+@overload
+def log(x: _FloatLike_co) -> Any: ...
+@overload
+def log(x: _ComplexLike_co) -> complexfloating[Any, Any]: ...
+@overload
+def log(x: _ArrayLikeFloat_co) -> NDArray[Any]: ...
+@overload
+def log(x: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ...
+
+@overload
+def log10(x: _FloatLike_co) -> Any: ...
+@overload
+def log10(x: _ComplexLike_co) -> complexfloating[Any, Any]: ...
+@overload
+def log10(x: _ArrayLikeFloat_co) -> NDArray[Any]: ...
+@overload
+def log10(x: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ...
+
+@overload
+def log2(x: _FloatLike_co) -> Any: ...
+@overload
+def log2(x: _ComplexLike_co) -> complexfloating[Any, Any]: ...
+@overload
+def log2(x: _ArrayLikeFloat_co) -> NDArray[Any]: ...
+@overload
+def log2(x: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ...
+
+@overload
+def logn(n: _FloatLike_co, x: _FloatLike_co) -> Any: ...
+@overload
+def logn(n: _ComplexLike_co, x: _ComplexLike_co) -> complexfloating[Any, Any]: ...
+@overload
+def logn(n: _ArrayLikeFloat_co, x: _ArrayLikeFloat_co) -> NDArray[Any]: ...
+@overload
+def logn(n: _ArrayLikeComplex_co, x: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ...
+
+@overload
+def power(x: _FloatLike_co, p: _FloatLike_co) -> Any: ...
+@overload
+def power(x: _ComplexLike_co, p: _ComplexLike_co) -> complexfloating[Any, Any]: ...
+@overload
+def power(x: _ArrayLikeFloat_co, p: _ArrayLikeFloat_co) -> NDArray[Any]: ...
+@overload
+def power(x: _ArrayLikeComplex_co, p: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ...
+
+@overload
+def arccos(x: _FloatLike_co) -> Any: ...
+@overload
+def arccos(x: _ComplexLike_co) -> complexfloating[Any, Any]: ...
+@overload
+def arccos(x: _ArrayLikeFloat_co) -> NDArray[Any]: ...
+@overload
+def arccos(x: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ...
+
+@overload
+def arcsin(x: _FloatLike_co) -> Any: ...
+@overload
+def arcsin(x: _ComplexLike_co) -> complexfloating[Any, Any]: ...
+@overload
+def arcsin(x: _ArrayLikeFloat_co) -> NDArray[Any]: ...
+@overload
+def arcsin(x: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ...
+
+@overload
+def arctanh(x: _FloatLike_co) -> Any: ...
+@overload
+def arctanh(x: _ComplexLike_co) -> complexfloating[Any, Any]: ...
+@overload
+def arctanh(x: _ArrayLikeFloat_co) -> NDArray[Any]: ...
+@overload
+def arctanh(x: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ...
diff --git a/numpy/lib/shape_base.py b/numpy/lib/shape_base.py
index a3fbee3d5fb3..ab91423d9894 100644
--- a/numpy/lib/shape_base.py
+++ b/numpy/lib/shape_base.py
@@ -885,7 +885,7 @@ def hsplit(ary, indices_or_sections):
 
     Please refer to the `split` documentation.  `hsplit` is equivalent
     to `split` with ``axis=1``, the array is always split along the second
-    axis regardless of the array dimension.
+    axis except for 1-D arrays, where it is split at ``axis=0``.
 
     See Also
     --------
@@ -933,6 +933,12 @@ def hsplit(ary, indices_or_sections):
      array([[[2.,  3.]],
            [[6.,  7.]]])]
 
+    With a 1-D array, the split is along axis 0.
+
+    >>> x = np.array([0, 1, 2, 3, 4, 5])
+    >>> np.hsplit(x, 2)
+    [array([0, 1, 2]), array([3, 4, 5])]
+
     """
     if _nx.ndim(ary) == 0:
         raise ValueError('hsplit only works on arrays of 1 or more dimensions')
@@ -1133,35 +1139,49 @@ def kron(a, b):
     True
 
     """
+    # Working:
+    # 1. Equalise the shapes by prepending smaller array with 1s
+    # 2. Expand shapes of both the arrays by adding new axes at
+    #    odd positions for 1st array and even positions for 2nd
+    # 3. Compute the product of the modified array
+    # 4. The inner most array elements now contain the rows of
+    #    the Kronecker product
+    # 5. Reshape the result to kron's shape, which is same as
+    #    product of shapes of the two arrays.
     b = asanyarray(b)
     a = array(a, copy=False, subok=True, ndmin=b.ndim)
+    is_any_mat = isinstance(a, matrix) or isinstance(b, matrix)
     ndb, nda = b.ndim, a.ndim
+    nd = max(ndb, nda)
+
     if (nda == 0 or ndb == 0):
         return _nx.multiply(a, b)
+
     as_ = a.shape
     bs = b.shape
     if not a.flags.contiguous:
         a = reshape(a, as_)
     if not b.flags.contiguous:
         b = reshape(b, bs)
-    nd = ndb
-    if (ndb != nda):
-        if (ndb > nda):
-            as_ = (1,)*(ndb-nda) + as_
-        else:
-            bs = (1,)*(nda-ndb) + bs
-            nd = nda
-    result = outer(a, b).reshape(as_+bs)
-    axis = nd-1
-    for _ in range(nd):
-        result = concatenate(result, axis=axis)
-    wrapper = get_array_prepare(a, b)
-    if wrapper is not None:
-        result = wrapper(result)
-    wrapper = get_array_wrap(a, b)
-    if wrapper is not None:
-        result = wrapper(result)
-    return result
+
+    # Equalise the shapes by prepending smaller one with 1s
+    as_ = (1,)*max(0, ndb-nda) + as_
+    bs = (1,)*max(0, nda-ndb) + bs
+
+    # Insert empty dimensions
+    a_arr = expand_dims(a, axis=tuple(range(ndb-nda)))
+    b_arr = expand_dims(b, axis=tuple(range(nda-ndb)))
+
+    # Compute the product
+    a_arr = expand_dims(a_arr, axis=tuple(range(1, nd*2, 2)))
+    b_arr = expand_dims(b_arr, axis=tuple(range(0, nd*2, 2)))
+    # In case of `mat`, convert result to `array`
+    result = _nx.multiply(a_arr, b_arr, subok=(not is_any_mat))
+
+    # Reshape back
+    result = result.reshape(_nx.multiply(as_, bs))
+
+    return result if not is_any_mat else matrix(result, copy=False)
 
 
 def _tile_dispatcher(A, reps):
diff --git a/numpy/lib/shape_base.pyi b/numpy/lib/shape_base.pyi
index 8aa283d0291f..1b718da221e0 100644
--- a/numpy/lib/shape_base.pyi
+++ b/numpy/lib/shape_base.pyi
@@ -1,9 +1,9 @@
-from typing import List, TypeVar, Callable, Sequence, Any, overload, Tuple, SupportsIndex, Protocol
+from collections.abc import Callable, Sequence
+from typing import TypeVar, Any, overload, SupportsIndex, Protocol
 
 from numpy import (
     generic,
     integer,
-    dtype,
     ufunc,
     bool_,
     unsignedinteger,
@@ -13,33 +13,30 @@ from numpy import (
     object_,
 )
 
-from numpy.typing import (
+from numpy._typing import (
     ArrayLike,
     NDArray,
     _ShapeLike,
-     _FiniteNestedSequence,
-     _SupportsDType,
-     _ArrayLikeBool_co,
-     _ArrayLikeUInt_co,
-     _ArrayLikeInt_co,
-     _ArrayLikeFloat_co,
-     _ArrayLikeComplex_co,
-     _ArrayLikeObject_co,
+    _ArrayLike,
+    _ArrayLikeBool_co,
+    _ArrayLikeUInt_co,
+    _ArrayLikeInt_co,
+    _ArrayLikeFloat_co,
+    _ArrayLikeComplex_co,
+    _ArrayLikeObject_co,
 )
 
 from numpy.core.shape_base import vstack
 
 _SCT = TypeVar("_SCT", bound=generic)
 
-_ArrayLike = _FiniteNestedSequence[_SupportsDType[dtype[_SCT]]]
-
 # The signatures of `__array_wrap__` and `__array_prepare__` are the same;
 # give them unique names for the sake of clarity
 class _ArrayWrap(Protocol):
     def __call__(
         self,
         array: NDArray[Any],
-        context: None | Tuple[ufunc, Tuple[Any, ...], int] = ...,
+        context: None | tuple[ufunc, tuple[Any, ...], int] = ...,
         /,
     ) -> Any: ...
 
@@ -47,7 +44,7 @@ class _ArrayPrepare(Protocol):
     def __call__(
         self,
         array: NDArray[Any],
-        context: None | Tuple[ufunc, Tuple[Any, ...], int] = ...,
+        context: None | tuple[ufunc, tuple[Any, ...], int] = ...,
         /,
     ) -> Any: ...
 
@@ -59,7 +56,7 @@ class _SupportsArrayPrepare(Protocol):
     @property
     def __array_prepare__(self) -> _ArrayPrepare: ...
 
-__all__: List[str]
+__all__: list[str]
 
 row_stack = vstack
 
@@ -76,6 +73,8 @@ def put_along_axis(
     axis: None | int,
 ) -> None: ...
 
+# TODO: Use PEP 612 `ParamSpec` once mypy supports `Concatenate`
+# xref python/mypy#8645
 @overload
 def apply_along_axis(
     func1d: Callable[..., _ArrayLike[_SCT]],
@@ -125,59 +124,59 @@ def array_split(
     ary: _ArrayLike[_SCT],
     indices_or_sections: _ShapeLike,
     axis: SupportsIndex = ...,
-) -> List[NDArray[_SCT]]: ...
+) -> list[NDArray[_SCT]]: ...
 @overload
 def array_split(
     ary: ArrayLike,
     indices_or_sections: _ShapeLike,
     axis: SupportsIndex = ...,
-) -> List[NDArray[Any]]: ...
+) -> list[NDArray[Any]]: ...
 
 @overload
 def split(
     ary: _ArrayLike[_SCT],
     indices_or_sections: _ShapeLike,
     axis: SupportsIndex = ...,
-) -> List[NDArray[_SCT]]: ...
+) -> list[NDArray[_SCT]]: ...
 @overload
 def split(
     ary: ArrayLike,
     indices_or_sections: _ShapeLike,
     axis: SupportsIndex = ...,
-) -> List[NDArray[Any]]: ...
+) -> list[NDArray[Any]]: ...
 
 @overload
 def hsplit(
     ary: _ArrayLike[_SCT],
     indices_or_sections: _ShapeLike,
-) -> List[NDArray[_SCT]]: ...
+) -> list[NDArray[_SCT]]: ...
 @overload
 def hsplit(
     ary: ArrayLike,
     indices_or_sections: _ShapeLike,
-) -> List[NDArray[Any]]: ...
+) -> list[NDArray[Any]]: ...
 
 @overload
 def vsplit(
     ary: _ArrayLike[_SCT],
     indices_or_sections: _ShapeLike,
-) -> List[NDArray[_SCT]]: ...
+) -> list[NDArray[_SCT]]: ...
 @overload
 def vsplit(
     ary: ArrayLike,
     indices_or_sections: _ShapeLike,
-) -> List[NDArray[Any]]: ...
+) -> list[NDArray[Any]]: ...
 
 @overload
 def dsplit(
     ary: _ArrayLike[_SCT],
     indices_or_sections: _ShapeLike,
-) -> List[NDArray[_SCT]]: ...
+) -> list[NDArray[_SCT]]: ...
 @overload
 def dsplit(
     ary: ArrayLike,
     indices_or_sections: _ShapeLike,
-) -> List[NDArray[Any]]: ...
+) -> list[NDArray[Any]]: ...
 
 @overload
 def get_array_prepare(*args: _SupportsArrayPrepare) -> _ArrayPrepare: ...
diff --git a/numpy/lib/stride_tricks.py b/numpy/lib/stride_tricks.py
index 5093993a9e92..6794ad557a2e 100644
--- a/numpy/lib/stride_tricks.py
+++ b/numpy/lib/stride_tricks.py
@@ -86,6 +86,7 @@ def as_strided(x, shape=None, strides=None, subok=False, writeable=True):
     Vectorized write operations on such arrays will typically be
     unpredictable. They may even give different results for small, large,
     or transposed arrays.
+
     Since writing to these arrays has to be tested and done with great
     care, you may want to use ``writeable=False`` to avoid accidental write
     operations.
diff --git a/numpy/lib/stride_tricks.pyi b/numpy/lib/stride_tricks.pyi
index aad404107433..4c9a98e85f78 100644
--- a/numpy/lib/stride_tricks.pyi
+++ b/numpy/lib/stride_tricks.pyi
@@ -1,26 +1,25 @@
-from typing import Any, List, Dict, Iterable, TypeVar, overload, SupportsIndex
+from collections.abc import Iterable
+from typing import Any, TypeVar, overload, SupportsIndex
 
-from numpy import dtype, generic
-from numpy.typing import (
+from numpy import generic
+from numpy._typing import (
     NDArray,
     ArrayLike,
     _ShapeLike,
     _Shape,
-    _FiniteNestedSequence,
-    _SupportsArray,
+    _ArrayLike
 )
 
 _SCT = TypeVar("_SCT", bound=generic)
-_ArrayLike = _FiniteNestedSequence[_SupportsArray[dtype[_SCT]]]
 
-__all__: List[str]
+__all__: list[str]
 
 class DummyArray:
-    __array_interface__: Dict[str, Any]
+    __array_interface__: dict[str, Any]
     base: None | NDArray[Any]
     def __init__(
         self,
-        interface: Dict[str, Any],
+        interface: dict[str, Any],
         base: None | NDArray[Any] = ...,
     ) -> None: ...
 
@@ -78,4 +77,4 @@ def broadcast_shapes(*args: _ShapeLike) -> _Shape: ...
 def broadcast_arrays(
     *args: ArrayLike,
     subok: bool = ...,
-) -> List[NDArray[Any]]: ...
+) -> list[NDArray[Any]]: ...
diff --git a/numpy/lib/tests/test__datasource.py b/numpy/lib/tests/test__datasource.py
index 2738d41c4fbc..c8149abc30c4 100644
--- a/numpy/lib/tests/test__datasource.py
+++ b/numpy/lib/tests/test__datasource.py
@@ -87,11 +87,11 @@ def invalid_httpfile():
 
 
 class TestDataSourceOpen:
-    def setup(self):
+    def setup_method(self):
         self.tmpdir = mkdtemp()
         self.ds = datasource.DataSource(self.tmpdir)
 
-    def teardown(self):
+    def teardown_method(self):
         rmtree(self.tmpdir)
         del self.ds
 
@@ -156,11 +156,11 @@ def test_ValidBz2File(self):
 
 
 class TestDataSourceExists:
-    def setup(self):
+    def setup_method(self):
         self.tmpdir = mkdtemp()
         self.ds = datasource.DataSource(self.tmpdir)
 
-    def teardown(self):
+    def teardown_method(self):
         rmtree(self.tmpdir)
         del self.ds
 
@@ -186,11 +186,11 @@ def test_InvalidFile(self):
 
 
 class TestDataSourceAbspath:
-    def setup(self):
+    def setup_method(self):
         self.tmpdir = os.path.abspath(mkdtemp())
         self.ds = datasource.DataSource(self.tmpdir)
 
-    def teardown(self):
+    def teardown_method(self):
         rmtree(self.tmpdir)
         del self.ds
 
@@ -251,11 +251,11 @@ def test_windows_os_sep(self):
 
 
 class TestRepositoryAbspath:
-    def setup(self):
+    def setup_method(self):
         self.tmpdir = os.path.abspath(mkdtemp())
         self.repos = datasource.Repository(valid_baseurl(), self.tmpdir)
 
-    def teardown(self):
+    def teardown_method(self):
         rmtree(self.tmpdir)
         del self.repos
 
@@ -284,11 +284,11 @@ def test_windows_os_sep(self):
 
 
 class TestRepositoryExists:
-    def setup(self):
+    def setup_method(self):
         self.tmpdir = mkdtemp()
         self.repos = datasource.Repository(valid_baseurl(), self.tmpdir)
 
-    def teardown(self):
+    def teardown_method(self):
         rmtree(self.tmpdir)
         del self.repos
 
@@ -317,10 +317,10 @@ def test_CachedHTTPFile(self):
 
 
 class TestOpenFunc:
-    def setup(self):
+    def setup_method(self):
         self.tmpdir = mkdtemp()
 
-    def teardown(self):
+    def teardown_method(self):
         rmtree(self.tmpdir)
 
     def test_DataSourceOpen(self):
diff --git a/numpy/lib/tests/test_arraypad.py b/numpy/lib/tests/test_arraypad.py
index 75db5928b288..a596815730db 100644
--- a/numpy/lib/tests/test_arraypad.py
+++ b/numpy/lib/tests/test_arraypad.py
@@ -474,8 +474,7 @@ def test_simple_stat_length(self):
 
     @pytest.mark.filterwarnings("ignore:Mean of empty slice:RuntimeWarning")
     @pytest.mark.filterwarnings(
-        "ignore:invalid value encountered in (true_divide|double_scalars):"
-        "RuntimeWarning"
+        "ignore:invalid value encountered in( scalar)? divide:RuntimeWarning"
     )
     @pytest.mark.parametrize("mode", ["mean", "median"])
     def test_zero_stat_length_valid(self, mode):
@@ -1215,7 +1214,7 @@ def _padwithtens(vector, pad_width, iaxis, kwargs):
 
 
 def test_unicode_mode():
-    a = np.pad([1], 2, mode=u'constant')
+    a = np.pad([1], 2, mode='constant')
     b = np.array([0, 0, 1, 0, 0])
     assert_array_equal(a, b)
 
diff --git a/numpy/lib/tests/test_arraysetops.py b/numpy/lib/tests/test_arraysetops.py
index 13385cd2409d..a180accbe451 100644
--- a/numpy/lib/tests/test_arraysetops.py
+++ b/numpy/lib/tests/test_arraysetops.py
@@ -195,7 +195,8 @@ def test_ediff1d_scalar_handling(self,
         assert_equal(actual, expected)
         assert actual.dtype == expected.dtype
 
-    def test_isin(self):
+    @pytest.mark.parametrize("kind", [None, "sort", "table"])
+    def test_isin(self, kind):
         # the tests for in1d cover most of isin's behavior
         # if in1d is removed, would need to change those tests to test
         # isin instead.
@@ -205,7 +206,7 @@ def _isin_slow(a, b):
         isin_slow = np.vectorize(_isin_slow, otypes=[bool], excluded={1})
 
         def assert_isin_equal(a, b):
-            x = isin(a, b)
+            x = isin(a, b, kind=kind)
             y = isin_slow(a, b)
             assert_array_equal(x, y)
 
@@ -231,12 +232,32 @@ def assert_isin_equal(a, b):
         assert_isin_equal(5, 6)
 
         # empty array-like:
-        x = []
-        assert_isin_equal(x, b)
-        assert_isin_equal(a, x)
-        assert_isin_equal(x, x)
-
-    def test_in1d(self):
+        if kind != "table":
+            # An empty list will become float64,
+            # which is invalid for kind="table"
+            x = []
+            assert_isin_equal(x, b)
+            assert_isin_equal(a, x)
+            assert_isin_equal(x, x)
+
+        # empty array with various types:
+        for dtype in [bool, np.int64, np.float64]:
+            if kind == "table" and dtype == np.float64:
+                continue
+
+            if dtype in {np.int64, np.float64}:
+                ar = np.array([10, 20, 30], dtype=dtype)
+            elif dtype in {bool}:
+                ar = np.array([True, False, False])
+
+            empty_array = np.array([], dtype=dtype)
+
+            assert_isin_equal(empty_array, ar)
+            assert_isin_equal(ar, empty_array)
+            assert_isin_equal(empty_array, empty_array)
+
+    @pytest.mark.parametrize("kind", [None, "sort", "table"])
+    def test_in1d(self, kind):
         # we use two different sizes for the b array here to test the
         # two different paths in in1d().
         for mult in (1, 10):
@@ -244,57 +265,58 @@ def test_in1d(self):
             a = [5, 7, 1, 2]
             b = [2, 4, 3, 1, 5] * mult
             ec = np.array([True, False, True, True])
-            c = in1d(a, b, assume_unique=True)
+            c = in1d(a, b, assume_unique=True, kind=kind)
             assert_array_equal(c, ec)
 
             a[0] = 8
             ec = np.array([False, False, True, True])
-            c = in1d(a, b, assume_unique=True)
+            c = in1d(a, b, assume_unique=True, kind=kind)
             assert_array_equal(c, ec)
 
             a[0], a[3] = 4, 8
             ec = np.array([True, False, True, False])
-            c = in1d(a, b, assume_unique=True)
+            c = in1d(a, b, assume_unique=True, kind=kind)
             assert_array_equal(c, ec)
 
             a = np.array([5, 4, 5, 3, 4, 4, 3, 4, 3, 5, 2, 1, 5, 5])
             b = [2, 3, 4] * mult
             ec = [False, True, False, True, True, True, True, True, True,
                   False, True, False, False, False]
-            c = in1d(a, b)
+            c = in1d(a, b, kind=kind)
             assert_array_equal(c, ec)
 
             b = b + [5, 5, 4] * mult
             ec = [True, True, True, True, True, True, True, True, True, True,
                   True, False, True, True]
-            c = in1d(a, b)
+            c = in1d(a, b, kind=kind)
             assert_array_equal(c, ec)
 
             a = np.array([5, 7, 1, 2])
             b = np.array([2, 4, 3, 1, 5] * mult)
             ec = np.array([True, False, True, True])
-            c = in1d(a, b)
+            c = in1d(a, b, kind=kind)
             assert_array_equal(c, ec)
 
             a = np.array([5, 7, 1, 1, 2])
             b = np.array([2, 4, 3, 3, 1, 5] * mult)
             ec = np.array([True, False, True, True, True])
-            c = in1d(a, b)
+            c = in1d(a, b, kind=kind)
             assert_array_equal(c, ec)
 
             a = np.array([5, 5])
             b = np.array([2, 2] * mult)
             ec = np.array([False, False])
-            c = in1d(a, b)
+            c = in1d(a, b, kind=kind)
             assert_array_equal(c, ec)
 
         a = np.array([5])
         b = np.array([2])
         ec = np.array([False])
-        c = in1d(a, b)
+        c = in1d(a, b, kind=kind)
         assert_array_equal(c, ec)
 
-        assert_array_equal(in1d([], []), [])
+        if kind in {None, "sort"}:
+            assert_array_equal(in1d([], [], kind=kind), [])
 
     def test_in1d_char_array(self):
         a = np.array(['a', 'b', 'c', 'd', 'e', 'c', 'e', 'b'])
@@ -305,16 +327,29 @@ def test_in1d_char_array(self):
 
         assert_array_equal(c, ec)
 
-    def test_in1d_invert(self):
+    @pytest.mark.parametrize("kind", [None, "sort", "table"])
+    def test_in1d_invert(self, kind):
         "Test in1d's invert parameter"
         # We use two different sizes for the b array here to test the
         # two different paths in in1d().
         for mult in (1, 10):
             a = np.array([5, 4, 5, 3, 4, 4, 3, 4, 3, 5, 2, 1, 5, 5])
             b = [2, 3, 4] * mult
-            assert_array_equal(np.invert(in1d(a, b)), in1d(a, b, invert=True))
-
-    def test_in1d_ravel(self):
+            assert_array_equal(np.invert(in1d(a, b, kind=kind)),
+                               in1d(a, b, invert=True, kind=kind))
+
+        # float:
+        if kind in {None, "sort"}:
+            for mult in (1, 10):
+                a = np.array([5, 4, 5, 3, 4, 4, 3, 4, 3, 5, 2, 1, 5, 5],
+                            dtype=np.float32)
+                b = [2, 3, 4] * mult
+                b = np.array(b, dtype=np.float32)
+                assert_array_equal(np.invert(in1d(a, b, kind=kind)),
+                                   in1d(a, b, invert=True, kind=kind))
+
+    @pytest.mark.parametrize("kind", [None, "sort", "table"])
+    def test_in1d_ravel(self, kind):
         # Test that in1d ravels its input arrays. This is not documented
         # behavior however. The test is to ensure consistentency.
         a = np.arange(6).reshape(2, 3)
@@ -322,10 +357,110 @@ def test_in1d_ravel(self):
         long_b = np.arange(3, 63).reshape(30, 2)
         ec = np.array([False, False, False, True, True, True])
 
-        assert_array_equal(in1d(a, b, assume_unique=True), ec)
-        assert_array_equal(in1d(a, b, assume_unique=False), ec)
-        assert_array_equal(in1d(a, long_b, assume_unique=True), ec)
-        assert_array_equal(in1d(a, long_b, assume_unique=False), ec)
+        assert_array_equal(in1d(a, b, assume_unique=True, kind=kind),
+                           ec)
+        assert_array_equal(in1d(a, b, assume_unique=False,
+                                kind=kind),
+                           ec)
+        assert_array_equal(in1d(a, long_b, assume_unique=True,
+                                kind=kind),
+                           ec)
+        assert_array_equal(in1d(a, long_b, assume_unique=False,
+                                kind=kind),
+                           ec)
+
+    def test_in1d_hit_alternate_algorithm(self):
+        """Hit the standard isin code with integers"""
+        # Need extreme range to hit standard code
+        # This hits it without the use of kind='table'
+        a = np.array([5, 4, 5, 3, 4, 4, 1e9], dtype=np.int64)
+        b = np.array([2, 3, 4, 1e9], dtype=np.int64)
+        expected = np.array([0, 1, 0, 1, 1, 1, 1], dtype=bool)
+        assert_array_equal(expected, in1d(a, b))
+        assert_array_equal(np.invert(expected), in1d(a, b, invert=True))
+
+        a = np.array([5, 7, 1, 2], dtype=np.int64)
+        b = np.array([2, 4, 3, 1, 5, 1e9], dtype=np.int64)
+        ec = np.array([True, False, True, True])
+        c = in1d(a, b, assume_unique=True)
+        assert_array_equal(c, ec)
+
+    @pytest.mark.parametrize("kind", [None, "sort", "table"])
+    def test_in1d_boolean(self, kind):
+        """Test that in1d works for boolean input"""
+        a = np.array([True, False])
+        b = np.array([False, False, False])
+        expected = np.array([False, True])
+        assert_array_equal(expected,
+                           in1d(a, b, kind=kind))
+        assert_array_equal(np.invert(expected),
+                           in1d(a, b, invert=True, kind=kind))
+
+    @pytest.mark.parametrize("kind", [None, "sort"])
+    def test_in1d_timedelta(self, kind):
+        """Test that in1d works for timedelta input"""
+        rstate = np.random.RandomState(0)
+        a = rstate.randint(0, 100, size=10)
+        b = rstate.randint(0, 100, size=10)
+        truth = in1d(a, b)
+        a_timedelta = a.astype("timedelta64[s]")
+        b_timedelta = b.astype("timedelta64[s]")
+        assert_array_equal(truth, in1d(a_timedelta, b_timedelta, kind=kind))
+
+    def test_in1d_table_timedelta_fails(self):
+        a = np.array([0, 1, 2], dtype="timedelta64[s]")
+        b = a
+        # Make sure it raises a value error:
+        with pytest.raises(ValueError):
+            in1d(a, b, kind="table")
+
+    @pytest.mark.parametrize(
+        "dtype1,dtype2",
+        [
+            (np.int8, np.int16),
+            (np.int16, np.int8),
+            (np.uint8, np.uint16),
+            (np.uint16, np.uint8),
+            (np.uint8, np.int16),
+            (np.int16, np.uint8),
+        ]
+    )
+    @pytest.mark.parametrize("kind", [None, "sort", "table"])
+    def test_in1d_mixed_dtype(self, dtype1, dtype2, kind):
+        """Test that in1d works as expected for mixed dtype input."""
+        is_dtype2_signed = np.issubdtype(dtype2, np.signedinteger)
+        ar1 = np.array([0, 0, 1, 1], dtype=dtype1)
+
+        if is_dtype2_signed:
+            ar2 = np.array([-128, 0, 127], dtype=dtype2)
+        else:
+            ar2 = np.array([127, 0, 255], dtype=dtype2)
+
+        expected = np.array([True, True, False, False])
+
+        expect_failure = kind == "table" and any((
+            dtype1 == np.int8 and dtype2 == np.int16,
+            dtype1 == np.int16 and dtype2 == np.int8
+        ))
+
+        if expect_failure:
+            with pytest.raises(RuntimeError, match="exceed the maximum"):
+                in1d(ar1, ar2, kind=kind)
+        else:
+            assert_array_equal(in1d(ar1, ar2, kind=kind), expected)
+
+    @pytest.mark.parametrize("kind", [None, "sort", "table"])
+    def test_in1d_mixed_boolean(self, kind):
+        """Test that in1d works as expected for bool/int input."""
+        for dtype in np.typecodes["AllInteger"]:
+            a = np.array([True, False, False], dtype=bool)
+            b = np.array([0, 0, 0, 0], dtype=dtype)
+            expected = np.array([False, True, True], dtype=bool)
+            assert_array_equal(in1d(a, b, kind=kind), expected)
+
+            a, b = b, a
+            expected = np.array([True, True, True, True], dtype=bool)
+            assert_array_equal(in1d(a, b, kind=kind), expected)
 
     def test_in1d_first_array_is_object(self):
         ar1 = [None]
@@ -391,6 +526,40 @@ def test_in1d_with_arrays_containing_tuples(self):
         result = np.in1d(ar1, ar2, invert=True)
         assert_array_equal(result, np.invert(expected))
 
+    def test_in1d_errors(self):
+        """Test that in1d raises expected errors."""
+
+        # Error 1: `kind` is not one of 'sort' 'table' or None.
+        ar1 = np.array([1, 2, 3, 4, 5])
+        ar2 = np.array([2, 4, 6, 8, 10])
+        assert_raises(ValueError, in1d, ar1, ar2, kind='quicksort')
+
+        # Error 2: `kind="table"` does not work for non-integral arrays.
+        obj_ar1 = np.array([1, 'a', 3, 'b', 5], dtype=object)
+        obj_ar2 = np.array([1, 'a', 3, 'b', 5], dtype=object)
+        assert_raises(ValueError, in1d, obj_ar1, obj_ar2, kind='table')
+
+        for dtype in [np.int32, np.int64]:
+            ar1 = np.array([-1, 2, 3, 4, 5], dtype=dtype)
+            # The range of this array will overflow:
+            overflow_ar2 = np.array([-1, np.iinfo(dtype).max], dtype=dtype)
+
+            # Error 3: `kind="table"` will trigger a runtime error
+            #  if there is an integer overflow expected when computing the
+            #  range of ar2
+            assert_raises(
+                RuntimeError,
+                in1d, ar1, overflow_ar2, kind='table'
+            )
+
+            # Non-error: `kind=None` will *not* trigger a runtime error
+            #  if there is an integer overflow, it will switch to
+            #  the `sort` algorithm.
+            result = np.in1d(ar1, overflow_ar2, kind=None)
+            assert_array_equal(result, [True] + [False] * 4)
+            result = np.in1d(ar1, overflow_ar2, kind='sort')
+            assert_array_equal(result, [True] + [False] * 4)
+
     def test_union1d(self):
         a = np.array([5, 4, 7, 1, 2])
         b = np.array([2, 4, 3, 3, 2, 1, 5])
@@ -765,3 +934,11 @@ def _run_axis_tests(self, dtype):
         assert_array_equal(uniq[:, inv], data)
         msg = "Unique's return_counts=True failed with axis=1"
         assert_array_equal(cnt, np.array([2, 1, 1]), msg)
+
+    def test_unique_nanequals(self):
+        # issue 20326
+        a = np.array([1, 1, np.nan, np.nan, np.nan])
+        unq = np.unique(a)
+        not_unq = np.unique(a, equal_nan=False)
+        assert_array_equal(unq, np.array([1, np.nan]))
+        assert_array_equal(not_unq, np.array([1, np.nan, np.nan, np.nan]))
diff --git a/numpy/lib/tests/test_financial_expired.py b/numpy/lib/tests/test_financial_expired.py
index 70b0cd7909b2..838f999a61e6 100644
--- a/numpy/lib/tests/test_financial_expired.py
+++ b/numpy/lib/tests/test_financial_expired.py
@@ -3,8 +3,6 @@
 import numpy as np
 
 
-@pytest.mark.skipif(sys.version_info[:2] < (3, 7),
-                    reason="requires python 3.7 or higher")
 def test_financial_expired():
     match = 'NEP 32'
     with pytest.warns(DeprecationWarning, match=match):
diff --git a/numpy/lib/tests/test_format.py b/numpy/lib/tests/test_format.py
index 78e67a89b5a3..6f6406cf87ea 100644
--- a/numpy/lib/tests/test_format.py
+++ b/numpy/lib/tests/test_format.py
@@ -283,8 +283,9 @@
 import numpy as np
 from numpy.testing import (
     assert_, assert_array_equal, assert_raises, assert_raises_regex,
-    assert_warns,
+    assert_warns, IS_PYPY, IS_WASM
     )
+from numpy.testing._private.utils import requires_memory
 from numpy.lib import format
 
 
@@ -458,6 +459,8 @@ def test_long_str():
     assert_array_equal(long_str_arr, long_str_arr2)
 
 
+@pytest.mark.skipif(IS_WASM, reason="memmap doesn't work correctly")
+@pytest.mark.slow
 def test_memmap_roundtrip(tmpdir):
     for i, arr in enumerate(basic_arrays + record_arrays):
         if arr.dtype.hasobject:
@@ -524,6 +527,7 @@ def test_load_padded_dtype(tmpdir, dt):
     assert_array_equal(arr, arr1)
 
 
+@pytest.mark.xfail(IS_WASM, reason="Emscripten NODEFS has a buggy dup")
 def test_python2_python3_interoperability():
     fname = 'win64python2.npy'
     path = os.path.join(os.path.dirname(__file__), 'data', fname)
@@ -535,7 +539,7 @@ def test_pickle_python2_python3():
     # Python 2 and Python 3 and vice versa
     data_dir = os.path.join(os.path.dirname(__file__), 'data')
 
-    expected = np.array([None, range, u'\u512a\u826f',
+    expected = np.array([None, range, '\u512a\u826f',
                          b'\xe4\xb8\x8d\xe8\x89\xaf'],
                         dtype=object)
 
@@ -666,13 +670,14 @@ def test_version_2_0():
     assert_(len(header) % format.ARRAY_ALIGN == 0)
 
     f.seek(0)
-    n = format.read_array(f)
+    n = format.read_array(f, max_header_size=200000)
     assert_array_equal(d, n)
 
     # 1.0 requested but data cannot be saved this way
     assert_raises(ValueError, format.write_array, f, d, (1, 0))
 
 
+@pytest.mark.skipif(IS_WASM, reason="memmap doesn't work correctly")
 def test_version_2_0_memmap(tmpdir):
     # requires more than 2 byte for header
     dt = [(("%d" % i) * 100, float) for i in range(500)]
@@ -688,7 +693,7 @@ def test_version_2_0_memmap(tmpdir):
                             shape=d.shape, version=(2, 0))
     ma[...] = d
     ma.flush()
-    ma = format.open_memmap(tf1, mode='r')
+    ma = format.open_memmap(tf1, mode='r', max_header_size=200000)
     assert_array_equal(ma, d)
 
     with warnings.catch_warnings(record=True) as w:
@@ -699,9 +704,49 @@ def test_version_2_0_memmap(tmpdir):
         ma[...] = d
         ma.flush()
 
-    ma = format.open_memmap(tf2, mode='r')
+    ma = format.open_memmap(tf2, mode='r', max_header_size=200000)
+
     assert_array_equal(ma, d)
 
+@pytest.mark.parametrize("mmap_mode", ["r", None])
+def test_huge_header(tmpdir, mmap_mode):
+    f = os.path.join(tmpdir, f'large_header.npy')
+    arr = np.array(1, dtype="i,"*10000+"i")
+
+    with pytest.warns(UserWarning, match=".*format 2.0"):
+        np.save(f, arr)
+    
+    with pytest.raises(ValueError, match="Header.*large"):
+        np.load(f, mmap_mode=mmap_mode)
+
+    with pytest.raises(ValueError, match="Header.*large"):
+        np.load(f, mmap_mode=mmap_mode, max_header_size=20000)
+
+    res = np.load(f, mmap_mode=mmap_mode, allow_pickle=True)
+    assert_array_equal(res, arr)
+
+    res = np.load(f, mmap_mode=mmap_mode, max_header_size=180000)
+    assert_array_equal(res, arr)
+
+def test_huge_header_npz(tmpdir):
+    f = os.path.join(tmpdir, f'large_header.npz')
+    arr = np.array(1, dtype="i,"*10000+"i")
+
+    with pytest.warns(UserWarning, match=".*format 2.0"):
+        np.savez(f, arr=arr)
+    
+    # Only getting the array from the file actually reads it
+    with pytest.raises(ValueError, match="Header.*large"):
+        np.load(f)["arr"]
+
+    with pytest.raises(ValueError, match="Header.*large"):
+        np.load(f, max_header_size=20000)["arr"]
+
+    res = np.load(f, allow_pickle=True)["arr"]
+    assert_array_equal(res, arr)
+
+    res = np.load(f, max_header_size=180000)["arr"]
+    assert_array_equal(res, arr)
 
 def test_write_version():
     f = BytesIO()
@@ -790,11 +835,11 @@ def test_bad_magic_args():
 
 def test_large_header():
     s = BytesIO()
-    d = {'a': 1, 'b': 2}
+    d = {'shape': tuple(), 'fortran_order': False, 'descr': ' unicode upcast
-        utf8 = u'\u03d6'
-        latin1 = u'\xf6\xfc\xf6'
+        utf8 = '\u03d6'
+        latin1 = '\xf6\xfc\xf6'
 
         # skip test if cannot encode utf8 test string with preferred
         # encoding. The preferred encoding is assumed to be the default
@@ -2198,9 +2258,9 @@ def test_utf8_file_nodtype_unicode(self):
 
         with temppath() as path:
             with io.open(path, "wt") as f:
-                f.write(u"norm1,norm2,norm3\n")
-                f.write(u"norm1," + latin1 + u",norm3\n")
-                f.write(u"test1,testNonethe" + utf8 + u",test3\n")
+                f.write("norm1,norm2,norm3\n")
+                f.write("norm1," + latin1 + ",norm3\n")
+                f.write("test1,testNonethe" + utf8 + ",test3\n")
             with warnings.catch_warnings(record=True) as w:
                 warnings.filterwarnings('always', '',
                                         np.VisibleDeprecationWarning)
@@ -2393,6 +2453,13 @@ def test_auto_dtype_largeint(self):
         assert_equal(test['f1'], 17179869184)
         assert_equal(test['f2'], 1024)
 
+    def test_unpack_float_data(self):
+        txt = TextIO("1,2,3\n4,5,6\n7,8,9\n0.0,1.0,2.0")
+        a, b, c = np.loadtxt(txt, delimiter=",", unpack=True)
+        assert_array_equal(a, np.array([1.0, 4.0, 7.0, 0.0]))
+        assert_array_equal(b, np.array([2.0, 5.0, 8.0, 1.0]))
+        assert_array_equal(c, np.array([3.0, 6.0, 9.0, 2.0]))
+
     def test_unpack_structured(self):
         # Regression test for gh-4341
         # Unpacking should work on structured arrays
@@ -2438,6 +2505,17 @@ def test_squeeze_scalar(self):
         assert_equal((), test.shape)
         assert_equal(expected.dtype, test.dtype)
 
+    @pytest.mark.parametrize("ndim", [0, 1, 2])
+    def test_ndmin_keyword(self, ndim: int):
+        # lets have the same behaviour of ndmin as loadtxt
+        # as they should be the same for non-missing values
+        txt = "42"
+
+        a = np.loadtxt(StringIO(txt), ndmin=ndim)
+        b = np.genfromtxt(StringIO(txt), ndmin=ndim)
+
+        assert_array_equal(a, b)
+
 
 class TestPathUsage:
     # Test that pathlib.Path can be used
@@ -2472,6 +2550,7 @@ def test_save_load_memmap(self):
                 break_cycles()
                 break_cycles()
 
+    @pytest.mark.xfail(IS_WASM, reason="memmap doesn't work correctly")
     def test_save_load_memmap_readwrite(self):
         # Test that pathlib.Path instances can be written mem-mapped.
         with temppath(suffix='.npy') as path:
@@ -2517,7 +2596,7 @@ def test_recfromtxt(self):
         with temppath(suffix='.txt') as path:
             path = Path(path)
             with path.open('w') as f:
-                f.write(u'A,B\n0,1\n2,3')
+                f.write('A,B\n0,1\n2,3')
 
             kwargs = dict(delimiter=",", missing_values="N/A", names=True)
             test = np.recfromtxt(path, **kwargs)
@@ -2530,7 +2609,7 @@ def test_recfromcsv(self):
         with temppath(suffix='.txt') as path:
             path = Path(path)
             with path.open('w') as f:
-                f.write(u'A,B\n0,1\n2,3')
+                f.write('A,B\n0,1\n2,3')
 
             kwargs = dict(missing_values="N/A", names=True, case_sensitive=True)
             test = np.recfromcsv(path, dtype=None, **kwargs)
diff --git a/numpy/lib/tests/test_loadtxt.py b/numpy/lib/tests/test_loadtxt.py
new file mode 100644
index 000000000000..8a5b044b8fb2
--- /dev/null
+++ b/numpy/lib/tests/test_loadtxt.py
@@ -0,0 +1,1039 @@
+"""
+Tests specific to `np.loadtxt` added during the move of loadtxt to be backed
+by C code.
+These tests complement those found in `test_io.py`.
+"""
+
+import sys
+import os
+import pytest
+from tempfile import NamedTemporaryFile, mkstemp
+from io import StringIO
+
+import numpy as np
+from numpy.ma.testutils import assert_equal
+from numpy.testing import assert_array_equal, HAS_REFCOUNT, IS_PYPY
+
+
+def test_scientific_notation():
+    """Test that both 'e' and 'E' are parsed correctly."""
+    data = StringIO(
+        (
+            "1.0e-1,2.0E1,3.0\n"
+            "4.0e-2,5.0E-1,6.0\n"
+            "7.0e-3,8.0E1,9.0\n"
+            "0.0e-4,1.0E-1,2.0"
+        )
+    )
+    expected = np.array(
+        [[0.1, 20., 3.0], [0.04, 0.5, 6], [0.007, 80., 9], [0, 0.1, 2]]
+    )
+    assert_array_equal(np.loadtxt(data, delimiter=","), expected)
+
+
+@pytest.mark.parametrize("comment", ["..", "//", "@-", "this is a comment:"])
+def test_comment_multiple_chars(comment):
+    content = "# IGNORE\n1.5, 2.5# ABC\n3.0,4.0# XXX\n5.5,6.0\n"
+    txt = StringIO(content.replace("#", comment))
+    a = np.loadtxt(txt, delimiter=",", comments=comment)
+    assert_equal(a, [[1.5, 2.5], [3.0, 4.0], [5.5, 6.0]])
+
+
+@pytest.fixture
+def mixed_types_structured():
+    """
+    Fixture providing hetergeneous input data with a structured dtype, along
+    with the associated structured array.
+    """
+    data = StringIO(
+        (
+            "1000;2.4;alpha;-34\n"
+            "2000;3.1;beta;29\n"
+            "3500;9.9;gamma;120\n"
+            "4090;8.1;delta;0\n"
+            "5001;4.4;epsilon;-99\n"
+            "6543;7.8;omega;-1\n"
+        )
+    )
+    dtype = np.dtype(
+        [('f0', np.uint16), ('f1', np.float64), ('f2', 'S7'), ('f3', np.int8)]
+    )
+    expected = np.array(
+        [
+            (1000, 2.4, "alpha", -34),
+            (2000, 3.1, "beta", 29),
+            (3500, 9.9, "gamma", 120),
+            (4090, 8.1, "delta", 0),
+            (5001, 4.4, "epsilon", -99),
+            (6543, 7.8, "omega", -1)
+        ],
+        dtype=dtype
+    )
+    return data, dtype, expected
+
+
+@pytest.mark.parametrize('skiprows', [0, 1, 2, 3])
+def test_structured_dtype_and_skiprows_no_empty_lines(
+        skiprows, mixed_types_structured):
+    data, dtype, expected = mixed_types_structured
+    a = np.loadtxt(data, dtype=dtype, delimiter=";", skiprows=skiprows)
+    assert_array_equal(a, expected[skiprows:])
+
+
+def test_unpack_structured(mixed_types_structured):
+    data, dtype, expected = mixed_types_structured
+
+    a, b, c, d = np.loadtxt(data, dtype=dtype, delimiter=";", unpack=True)
+    assert_array_equal(a, expected["f0"])
+    assert_array_equal(b, expected["f1"])
+    assert_array_equal(c, expected["f2"])
+    assert_array_equal(d, expected["f3"])
+
+
+def test_structured_dtype_with_shape():
+    dtype = np.dtype([("a", "u1", 2), ("b", "u1", 2)])
+    data = StringIO("0,1,2,3\n6,7,8,9\n")
+    expected = np.array([((0, 1), (2, 3)), ((6, 7), (8, 9))], dtype=dtype)
+    assert_array_equal(np.loadtxt(data, delimiter=",", dtype=dtype), expected)
+
+
+def test_structured_dtype_with_multi_shape():
+    dtype = np.dtype([("a", "u1", (2, 2))])
+    data = StringIO("0 1 2 3\n")
+    expected = np.array([(((0, 1), (2, 3)),)], dtype=dtype)
+    assert_array_equal(np.loadtxt(data, dtype=dtype), expected)
+
+
+def test_nested_structured_subarray():
+    # Test from gh-16678
+    point = np.dtype([('x', float), ('y', float)])
+    dt = np.dtype([('code', int), ('points', point, (2,))])
+    data = StringIO("100,1,2,3,4\n200,5,6,7,8\n")
+    expected = np.array(
+        [
+            (100, [(1., 2.), (3., 4.)]),
+            (200, [(5., 6.), (7., 8.)]),
+        ],
+        dtype=dt
+    )
+    assert_array_equal(np.loadtxt(data, dtype=dt, delimiter=","), expected)
+
+
+def test_structured_dtype_offsets():
+    # An aligned structured dtype will have additional padding
+    dt = np.dtype("i1, i4, i1, i4, i1, i4", align=True)
+    data = StringIO("1,2,3,4,5,6\n7,8,9,10,11,12\n")
+    expected = np.array([(1, 2, 3, 4, 5, 6), (7, 8, 9, 10, 11, 12)], dtype=dt)
+    assert_array_equal(np.loadtxt(data, delimiter=",", dtype=dt), expected)
+
+
+@pytest.mark.parametrize("param", ("skiprows", "max_rows"))
+def test_exception_negative_row_limits(param):
+    """skiprows and max_rows should raise for negative parameters."""
+    with pytest.raises(ValueError, match="argument must be nonnegative"):
+        np.loadtxt("foo.bar", **{param: -3})
+
+
+@pytest.mark.parametrize("param", ("skiprows", "max_rows"))
+def test_exception_noninteger_row_limits(param):
+    with pytest.raises(TypeError, match="argument must be an integer"):
+        np.loadtxt("foo.bar", **{param: 1.0})
+
+
+@pytest.mark.parametrize(
+    "data, shape",
+    [
+        ("1 2 3 4 5\n", (1, 5)),  # Single row
+        ("1\n2\n3\n4\n5\n", (5, 1)),  # Single column
+    ]
+)
+def test_ndmin_single_row_or_col(data, shape):
+    arr = np.array([1, 2, 3, 4, 5])
+    arr2d = arr.reshape(shape)
+
+    assert_array_equal(np.loadtxt(StringIO(data), dtype=int), arr)
+    assert_array_equal(np.loadtxt(StringIO(data), dtype=int, ndmin=0), arr)
+    assert_array_equal(np.loadtxt(StringIO(data), dtype=int, ndmin=1), arr)
+    assert_array_equal(np.loadtxt(StringIO(data), dtype=int, ndmin=2), arr2d)
+
+
+@pytest.mark.parametrize("badval", [-1, 3, None, "plate of shrimp"])
+def test_bad_ndmin(badval):
+    with pytest.raises(ValueError, match="Illegal value of ndmin keyword"):
+        np.loadtxt("foo.bar", ndmin=badval)
+
+
+@pytest.mark.parametrize(
+    "ws",
+    (
+            " ",  # space
+            "\t",  # tab
+            "\u2003",  # em
+            "\u00A0",  # non-break
+            "\u3000",  # ideographic space
+    )
+)
+def test_blank_lines_spaces_delimit(ws):
+    txt = StringIO(
+        f"1 2{ws}30\n\n{ws}\n"
+        f"4 5 60{ws}\n  {ws}  \n"
+        f"7 8 {ws} 90\n  # comment\n"
+        f"3 2 1"
+    )
+    # NOTE: It is unclear that the `  # comment` should succeed. Except
+    #       for delimiter=None, which should use any whitespace (and maybe
+    #       should just be implemented closer to Python
+    expected = np.array([[1, 2, 30], [4, 5, 60], [7, 8, 90], [3, 2, 1]])
+    assert_equal(
+        np.loadtxt(txt, dtype=int, delimiter=None, comments="#"), expected
+    )
+
+
+def test_blank_lines_normal_delimiter():
+    txt = StringIO('1,2,30\n\n4,5,60\n\n7,8,90\n# comment\n3,2,1')
+    expected = np.array([[1, 2, 30], [4, 5, 60], [7, 8, 90], [3, 2, 1]])
+    assert_equal(
+        np.loadtxt(txt, dtype=int, delimiter=',', comments="#"), expected
+    )
+
+
+@pytest.mark.parametrize("dtype", (float, object))
+def test_maxrows_no_blank_lines(dtype):
+    txt = StringIO("1.5,2.5\n3.0,4.0\n5.5,6.0")
+    res = np.loadtxt(txt, dtype=dtype, delimiter=",", max_rows=2)
+    assert_equal(res.dtype, dtype)
+    assert_equal(res, np.array([["1.5", "2.5"], ["3.0", "4.0"]], dtype=dtype))
+
+
+@pytest.mark.skipif(IS_PYPY and sys.implementation.version <= (7, 3, 8),
+                    reason="PyPy bug in error formatting")
+@pytest.mark.parametrize("dtype", (np.dtype("f8"), np.dtype("i2")))
+def test_exception_message_bad_values(dtype):
+    txt = StringIO("1,2\n3,XXX\n5,6")
+    msg = f"could not convert string 'XXX' to {dtype} at row 1, column 2"
+    with pytest.raises(ValueError, match=msg):
+        np.loadtxt(txt, dtype=dtype, delimiter=",")
+
+
+def test_converters_negative_indices():
+    txt = StringIO('1.5,2.5\n3.0,XXX\n5.5,6.0')
+    conv = {-1: lambda s: np.nan if s == 'XXX' else float(s)}
+    expected = np.array([[1.5, 2.5], [3.0, np.nan], [5.5, 6.0]])
+    res = np.loadtxt(
+        txt, dtype=np.float64, delimiter=",", converters=conv, encoding=None
+    )
+    assert_equal(res, expected)
+
+
+def test_converters_negative_indices_with_usecols():
+    txt = StringIO('1.5,2.5,3.5\n3.0,4.0,XXX\n5.5,6.0,7.5\n')
+    conv = {-1: lambda s: np.nan if s == 'XXX' else float(s)}
+    expected = np.array([[1.5, 3.5], [3.0, np.nan], [5.5, 7.5]])
+    res = np.loadtxt(
+        txt,
+        dtype=np.float64,
+        delimiter=",",
+        converters=conv,
+        usecols=[0, -1],
+        encoding=None,
+    )
+    assert_equal(res, expected)
+
+    # Second test with variable number of rows:
+    res = np.loadtxt(StringIO('''0,1,2\n0,1,2,3,4'''), delimiter=",",
+                     usecols=[0, -1], converters={-1: (lambda x: -1)})
+    assert_array_equal(res, [[0, -1], [0, -1]])
+
+def test_ragged_usecols():
+    # usecols, and negative ones, work even with varying number of columns.
+    txt = StringIO("0,0,XXX\n0,XXX,0,XXX\n0,XXX,XXX,0,XXX\n")
+    expected = np.array([[0, 0], [0, 0], [0, 0]])
+    res = np.loadtxt(txt, dtype=float, delimiter=",", usecols=[0, -2])
+    assert_equal(res, expected)
+
+    txt = StringIO("0,0,XXX\n0\n0,XXX,XXX,0,XXX\n")
+    with pytest.raises(ValueError,
+                match="invalid column index -2 at row 2 with 1 columns"):
+        # There is no -2 column in the second row:
+        np.loadtxt(txt, dtype=float, delimiter=",", usecols=[0, -2])
+
+
+def test_empty_usecols():
+    txt = StringIO("0,0,XXX\n0,XXX,0,XXX\n0,XXX,XXX,0,XXX\n")
+    res = np.loadtxt(txt, dtype=np.dtype([]), delimiter=",", usecols=[])
+    assert res.shape == (3,)
+    assert res.dtype == np.dtype([])
+
+
+@pytest.mark.parametrize("c1", ["a", "の", "🫕"])
+@pytest.mark.parametrize("c2", ["a", "の", "🫕"])
+def test_large_unicode_characters(c1, c2):
+    # c1 and c2 span ascii, 16bit and 32bit range.
+    txt = StringIO(f"a,{c1},c,1.0\ne,{c2},2.0,g")
+    res = np.loadtxt(txt, dtype=np.dtype('U12'), delimiter=",")
+    expected = np.array(
+        [f"a,{c1},c,1.0".split(","), f"e,{c2},2.0,g".split(",")],
+        dtype=np.dtype('U12')
+    )
+    assert_equal(res, expected)
+
+
+def test_unicode_with_converter():
+    txt = StringIO("cat,dog\nαβγ,δεζ\nabc,def\n")
+    conv = {0: lambda s: s.upper()}
+    res = np.loadtxt(
+        txt,
+        dtype=np.dtype("U12"),
+        converters=conv,
+        delimiter=",",
+        encoding=None
+    )
+    expected = np.array([['CAT', 'dog'], ['ΑΒΓ', 'δεζ'], ['ABC', 'def']])
+    assert_equal(res, expected)
+
+
+def test_converter_with_structured_dtype():
+    txt = StringIO('1.5,2.5,Abc\n3.0,4.0,dEf\n5.5,6.0,ghI\n')
+    dt = np.dtype([('m', np.int32), ('r', np.float32), ('code', 'U8')])
+    conv = {0: lambda s: int(10*float(s)), -1: lambda s: s.upper()}
+    res = np.loadtxt(txt, dtype=dt, delimiter=",", converters=conv)
+    expected = np.array(
+        [(15, 2.5, 'ABC'), (30, 4.0, 'DEF'), (55, 6.0, 'GHI')], dtype=dt
+    )
+    assert_equal(res, expected)
+
+
+def test_converter_with_unicode_dtype():
+    """
+    With the default 'bytes' encoding, tokens are encoded prior to being
+    passed to the converter. This means that the output of the converter may
+    be bytes instead of unicode as expected by `read_rows`.
+
+    This test checks that outputs from the above scenario are properly decoded
+    prior to parsing by `read_rows`.
+    """
+    txt = StringIO('abc,def\nrst,xyz')
+    conv = bytes.upper
+    res = np.loadtxt(
+            txt, dtype=np.dtype("U3"), converters=conv, delimiter=",")
+    expected = np.array([['ABC', 'DEF'], ['RST', 'XYZ']])
+    assert_equal(res, expected)
+
+
+def test_read_huge_row():
+    row = "1.5, 2.5," * 50000
+    row = row[:-1] + "\n"
+    txt = StringIO(row * 2)
+    res = np.loadtxt(txt, delimiter=",", dtype=float)
+    assert_equal(res, np.tile([1.5, 2.5], (2, 50000)))
+
+
+@pytest.mark.parametrize("dtype", "edfgFDG")
+def test_huge_float(dtype):
+    # Covers a non-optimized path that is rarely taken:
+    field = "0" * 1000 + ".123456789"
+    dtype = np.dtype(dtype)
+    value = np.loadtxt([field], dtype=dtype)[()]
+    assert value == dtype.type("0.123456789")
+
+
+@pytest.mark.parametrize(
+    ("given_dtype", "expected_dtype"),
+    [
+        ("S", np.dtype("S5")),
+        ("U", np.dtype("U5")),
+    ],
+)
+def test_string_no_length_given(given_dtype, expected_dtype):
+    """
+    The given dtype is just 'S' or 'U' with no length. In these cases, the
+    length of the resulting dtype is determined by the longest string found
+    in the file.
+    """
+    txt = StringIO("AAA,5-1\nBBBBB,0-3\nC,4-9\n")
+    res = np.loadtxt(txt, dtype=given_dtype, delimiter=",")
+    expected = np.array(
+        [['AAA', '5-1'], ['BBBBB', '0-3'], ['C', '4-9']], dtype=expected_dtype
+    )
+    assert_equal(res, expected)
+    assert_equal(res.dtype, expected_dtype)
+
+
+def test_float_conversion():
+    """
+    Some tests that the conversion to float64 works as accurately as the
+    Python built-in `float` function. In a naive version of the float parser,
+    these strings resulted in values that were off by an ULP or two.
+    """
+    strings = [
+        '0.9999999999999999',
+        '9876543210.123456',
+        '5.43215432154321e+300',
+        '0.901',
+        '0.333',
+    ]
+    txt = StringIO('\n'.join(strings))
+    res = np.loadtxt(txt)
+    expected = np.array([float(s) for s in strings])
+    assert_equal(res, expected)
+
+
+def test_bool():
+    # Simple test for bool via integer
+    txt = StringIO("1, 0\n10, -1")
+    res = np.loadtxt(txt, dtype=bool, delimiter=",")
+    assert res.dtype == bool
+    assert_array_equal(res, [[True, False], [True, True]])
+    # Make sure we use only 1 and 0 on the byte level:
+    assert_array_equal(res.view(np.uint8), [[1, 0], [1, 1]])
+
+
+@pytest.mark.skipif(IS_PYPY and sys.implementation.version <= (7, 3, 8),
+                    reason="PyPy bug in error formatting")
+@pytest.mark.parametrize("dtype", np.typecodes["AllInteger"])
+@pytest.mark.filterwarnings("error:.*integer via a float.*:DeprecationWarning")
+def test_integer_signs(dtype):
+    dtype = np.dtype(dtype)
+    assert np.loadtxt(["+2"], dtype=dtype) == 2
+    if dtype.kind == "u":
+        with pytest.raises(ValueError):
+            np.loadtxt(["-1\n"], dtype=dtype)
+    else:
+        assert np.loadtxt(["-2\n"], dtype=dtype) == -2
+
+    for sign in ["++", "+-", "--", "-+"]:
+        with pytest.raises(ValueError):
+            np.loadtxt([f"{sign}2\n"], dtype=dtype)
+
+
+@pytest.mark.skipif(IS_PYPY and sys.implementation.version <= (7, 3, 8),
+                    reason="PyPy bug in error formatting")
+@pytest.mark.parametrize("dtype", np.typecodes["AllInteger"])
+@pytest.mark.filterwarnings("error:.*integer via a float.*:DeprecationWarning")
+def test_implicit_cast_float_to_int_fails(dtype):
+    txt = StringIO("1.0, 2.1, 3.7\n4, 5, 6")
+    with pytest.raises(ValueError):
+        np.loadtxt(txt, dtype=dtype, delimiter=",")
+
+@pytest.mark.parametrize("dtype", (np.complex64, np.complex128))
+@pytest.mark.parametrize("with_parens", (False, True))
+def test_complex_parsing(dtype, with_parens):
+    s = "(1.0-2.5j),3.75,(7+-5.0j)\n(4),(-19e2j),(0)"
+    if not with_parens:
+        s = s.replace("(", "").replace(")", "")
+
+    res = np.loadtxt(StringIO(s), dtype=dtype, delimiter=",")
+    expected = np.array(
+        [[1.0-2.5j, 3.75, 7-5j], [4.0, -1900j, 0]], dtype=dtype
+    )
+    assert_equal(res, expected)
+
+
+def test_read_from_generator():
+    def gen():
+        for i in range(4):
+            yield f"{i},{2*i},{i**2}"
+
+    res = np.loadtxt(gen(), dtype=int, delimiter=",")
+    expected = np.array([[0, 0, 0], [1, 2, 1], [2, 4, 4], [3, 6, 9]])
+    assert_equal(res, expected)
+
+
+def test_read_from_generator_multitype():
+    def gen():
+        for i in range(3):
+            yield f"{i} {i / 4}"
+
+    res = np.loadtxt(gen(), dtype="i, d", delimiter=" ")
+    expected = np.array([(0, 0.0), (1, 0.25), (2, 0.5)], dtype="i, d")
+    assert_equal(res, expected)
+
+
+def test_read_from_bad_generator():
+    def gen():
+        for entry in ["1,2", b"3, 5", 12738]:
+            yield entry
+
+    with pytest.raises(
+            TypeError, match=r"non-string returned while reading data"):
+        np.loadtxt(gen(), dtype="i, i", delimiter=",")
+
+
+@pytest.mark.skipif(not HAS_REFCOUNT, reason="Python lacks refcounts")
+def test_object_cleanup_on_read_error():
+    sentinel = object()
+    already_read = 0
+
+    def conv(x):
+        nonlocal already_read
+        if already_read > 4999:
+            raise ValueError("failed half-way through!")
+        already_read += 1
+        return sentinel
+
+    txt = StringIO("x\n" * 10000)
+
+    with pytest.raises(ValueError, match="at row 5000, column 1"):
+        np.loadtxt(txt, dtype=object, converters={0: conv})
+
+    assert sys.getrefcount(sentinel) == 2
+
+
+@pytest.mark.skipif(IS_PYPY and sys.implementation.version <= (7, 3, 8),
+                    reason="PyPy bug in error formatting")
+def test_character_not_bytes_compatible():
+    """Test exception when a character cannot be encoded as 'S'."""
+    data = StringIO("–")  # == \u2013
+    with pytest.raises(ValueError):
+        np.loadtxt(data, dtype="S5")
+
+
+@pytest.mark.parametrize("conv", (0, [float], ""))
+def test_invalid_converter(conv):
+    msg = (
+        "converters must be a dictionary mapping columns to converter "
+        "functions or a single callable."
+    )
+    with pytest.raises(TypeError, match=msg):
+        np.loadtxt(StringIO("1 2\n3 4"), converters=conv)
+
+
+@pytest.mark.skipif(IS_PYPY and sys.implementation.version <= (7, 3, 8),
+                    reason="PyPy bug in error formatting")
+def test_converters_dict_raises_non_integer_key():
+    with pytest.raises(TypeError, match="keys of the converters dict"):
+        np.loadtxt(StringIO("1 2\n3 4"), converters={"a": int})
+    with pytest.raises(TypeError, match="keys of the converters dict"):
+        np.loadtxt(StringIO("1 2\n3 4"), converters={"a": int}, usecols=0)
+
+
+@pytest.mark.parametrize("bad_col_ind", (3, -3))
+def test_converters_dict_raises_non_col_key(bad_col_ind):
+    data = StringIO("1 2\n3 4")
+    with pytest.raises(ValueError, match="converter specified for column"):
+        np.loadtxt(data, converters={bad_col_ind: int})
+
+
+def test_converters_dict_raises_val_not_callable():
+    with pytest.raises(TypeError,
+                match="values of the converters dictionary must be callable"):
+        np.loadtxt(StringIO("1 2\n3 4"), converters={0: 1})
+
+
+@pytest.mark.parametrize("q", ('"', "'", "`"))
+def test_quoted_field(q):
+    txt = StringIO(
+        f"{q}alpha, x{q}, 2.5\n{q}beta, y{q}, 4.5\n{q}gamma, z{q}, 5.0\n"
+    )
+    dtype = np.dtype([('f0', 'U8'), ('f1', np.float64)])
+    expected = np.array(
+        [("alpha, x", 2.5), ("beta, y", 4.5), ("gamma, z", 5.0)], dtype=dtype
+    )
+
+    res = np.loadtxt(txt, dtype=dtype, delimiter=",", quotechar=q)
+    assert_array_equal(res, expected)
+
+
+@pytest.mark.parametrize("q", ('"', "'", "`"))
+def test_quoted_field_with_whitepace_delimiter(q):
+    txt = StringIO(
+        f"{q}alpha, x{q}     2.5\n{q}beta, y{q} 4.5\n{q}gamma, z{q}   5.0\n"
+    )
+    dtype = np.dtype([('f0', 'U8'), ('f1', np.float64)])
+    expected = np.array(
+        [("alpha, x", 2.5), ("beta, y", 4.5), ("gamma, z", 5.0)], dtype=dtype
+    )
+
+    res = np.loadtxt(txt, dtype=dtype, delimiter=None, quotechar=q)
+    assert_array_equal(res, expected)
+
+
+def test_quote_support_default():
+    """Support for quoted fields is disabled by default."""
+    txt = StringIO('"lat,long", 45, 30\n')
+    dtype = np.dtype([('f0', 'U24'), ('f1', np.float64), ('f2', np.float64)])
+
+    with pytest.raises(ValueError, match="the number of columns changed"):
+        np.loadtxt(txt, dtype=dtype, delimiter=",")
+
+    # Enable quoting support with non-None value for quotechar param
+    txt.seek(0)
+    expected = np.array([("lat,long", 45., 30.)], dtype=dtype)
+
+    res = np.loadtxt(txt, dtype=dtype, delimiter=",", quotechar='"')
+    assert_array_equal(res, expected)
+
+
+@pytest.mark.skipif(IS_PYPY and sys.implementation.version <= (7, 3, 8),
+                    reason="PyPy bug in error formatting")
+def test_quotechar_multichar_error():
+    txt = StringIO("1,2\n3,4")
+    msg = r".*must be a single unicode character or None"
+    with pytest.raises(TypeError, match=msg):
+        np.loadtxt(txt, delimiter=",", quotechar="''")
+
+
+def test_comment_multichar_error_with_quote():
+    txt = StringIO("1,2\n3,4")
+    msg = (
+        "when multiple comments or a multi-character comment is given, "
+        "quotes are not supported."
+    )
+    with pytest.raises(ValueError, match=msg):
+        np.loadtxt(txt, delimiter=",", comments="123", quotechar='"')
+    with pytest.raises(ValueError, match=msg):
+        np.loadtxt(txt, delimiter=",", comments=["#", "%"], quotechar='"')
+
+    # A single character string in a tuple is unpacked though:
+    res = np.loadtxt(txt, delimiter=",", comments=("#",), quotechar="'")
+    assert_equal(res, [[1, 2], [3, 4]])
+
+
+def test_structured_dtype_with_quotes():
+    data = StringIO(
+        (
+            "1000;2.4;'alpha';-34\n"
+            "2000;3.1;'beta';29\n"
+            "3500;9.9;'gamma';120\n"
+            "4090;8.1;'delta';0\n"
+            "5001;4.4;'epsilon';-99\n"
+            "6543;7.8;'omega';-1\n"
+        )
+    )
+    dtype = np.dtype(
+        [('f0', np.uint16), ('f1', np.float64), ('f2', 'S7'), ('f3', np.int8)]
+    )
+    expected = np.array(
+        [
+            (1000, 2.4, "alpha", -34),
+            (2000, 3.1, "beta", 29),
+            (3500, 9.9, "gamma", 120),
+            (4090, 8.1, "delta", 0),
+            (5001, 4.4, "epsilon", -99),
+            (6543, 7.8, "omega", -1)
+        ],
+        dtype=dtype
+    )
+    res = np.loadtxt(data, dtype=dtype, delimiter=";", quotechar="'")
+    assert_array_equal(res, expected)
+
+
+def test_quoted_field_is_not_empty():
+    txt = StringIO('1\n\n"4"\n""')
+    expected = np.array(["1", "4", ""], dtype="U1")
+    res = np.loadtxt(txt, delimiter=",", dtype="U1", quotechar='"')
+    assert_equal(res, expected)
+
+def test_quoted_field_is_not_empty_nonstrict():
+    # Same as test_quoted_field_is_not_empty but check that we are not strict
+    # about missing closing quote (this is the `csv.reader` default also)
+    txt = StringIO('1\n\n"4"\n"')
+    expected = np.array(["1", "4", ""], dtype="U1")
+    res = np.loadtxt(txt, delimiter=",", dtype="U1", quotechar='"')
+    assert_equal(res, expected)
+
+def test_consecutive_quotechar_escaped():
+    txt = StringIO('"Hello, my name is ""Monty""!"')
+    expected = np.array('Hello, my name is "Monty"!', dtype="U40")
+    res = np.loadtxt(txt, dtype="U40", delimiter=",", quotechar='"')
+    assert_equal(res, expected)
+
+
+@pytest.mark.parametrize("data", ("", "\n\n\n", "# 1 2 3\n# 4 5 6\n"))
+@pytest.mark.parametrize("ndmin", (0, 1, 2))
+@pytest.mark.parametrize("usecols", [None, (1, 2, 3)])
+def test_warn_on_no_data(data, ndmin, usecols):
+    """Check that a UserWarning is emitted when no data is read from input."""
+    if usecols is not None:
+        expected_shape = (0, 3)
+    elif ndmin == 2:
+        expected_shape = (0, 1)  # guess a single column?!
+    else:
+        expected_shape = (0,)
+
+    txt = StringIO(data)
+    with pytest.warns(UserWarning, match="input contained no data"):
+        res = np.loadtxt(txt, ndmin=ndmin, usecols=usecols)
+    assert res.shape == expected_shape
+
+    with NamedTemporaryFile(mode="w") as fh:
+        fh.write(data)
+        fh.seek(0)
+        with pytest.warns(UserWarning, match="input contained no data"):
+            res = np.loadtxt(txt, ndmin=ndmin, usecols=usecols)
+        assert res.shape == expected_shape
+
+@pytest.mark.parametrize("skiprows", (2, 3))
+def test_warn_on_skipped_data(skiprows):
+    data = "1 2 3\n4 5 6"
+    txt = StringIO(data)
+    with pytest.warns(UserWarning, match="input contained no data"):
+        np.loadtxt(txt, skiprows=skiprows)
+
+
+@pytest.mark.parametrize(["dtype", "value"], [
+        ("i2", 0x0001), ("u2", 0x0001),
+        ("i4", 0x00010203), ("u4", 0x00010203),
+        ("i8", 0x0001020304050607), ("u8", 0x0001020304050607),
+        # The following values are constructed to lead to unique bytes:
+        ("float16", 3.07e-05),
+        ("float32", 9.2557e-41), ("complex64", 9.2557e-41+2.8622554e-29j),
+        ("float64", -1.758571353180402e-24),
+        # Here and below, the repr side-steps a small loss of precision in
+        # complex `str` in PyPy (which is probably fine, as repr works):
+        ("complex128", repr(5.406409232372729e-29-1.758571353180402e-24j)),
+        # Use integer values that fit into double.  Everything else leads to
+        # problems due to longdoubles going via double and decimal strings
+        # causing rounding errors.
+        ("longdouble", 0x01020304050607),
+        ("clongdouble", repr(0x01020304050607 + (0x00121314151617 * 1j))),
+        ("U2", "\U00010203\U000a0b0c")])
+@pytest.mark.parametrize("swap", [True, False])
+def test_byteswapping_and_unaligned(dtype, value, swap):
+    # Try to create "interesting" values within the valid unicode range:
+    dtype = np.dtype(dtype)
+    data = [f"x,{value}\n"]  # repr as PyPy `str` truncates some
+    if swap:
+        dtype = dtype.newbyteorder()
+    full_dt = np.dtype([("a", "S1"), ("b", dtype)], align=False)
+    # The above ensures that the interesting "b" field is unaligned:
+    assert full_dt.fields["b"][1] == 1
+    res = np.loadtxt(data, dtype=full_dt, delimiter=",", encoding=None,
+                     max_rows=1)  # max-rows prevents over-allocation
+    assert res["b"] == dtype.type(value)
+
+
+@pytest.mark.parametrize("dtype",
+        np.typecodes["AllInteger"] + "efdFD" + "?")
+def test_unicode_whitespace_stripping(dtype):
+    # Test that all numeric types (and bool) strip whitespace correctly
+    # \u202F is a narrow no-break space, `\n` is just a whitespace if quoted.
+    # Currently, skip float128 as it did not always support this and has no
+    # "custom" parsing:
+    txt = StringIO(' 3 ,"\u202F2\n"')
+    res = np.loadtxt(txt, dtype=dtype, delimiter=",", quotechar='"')
+    assert_array_equal(res, np.array([3, 2]).astype(dtype))
+
+
+@pytest.mark.parametrize("dtype", "FD")
+def test_unicode_whitespace_stripping_complex(dtype):
+    # Complex has a few extra cases since it has two components and
+    # parentheses
+    line = " 1 , 2+3j , ( 4+5j ), ( 6+-7j )  , 8j , ( 9j ) \n"
+    data = [line, line.replace(" ", "\u202F")]
+    res = np.loadtxt(data, dtype=dtype, delimiter=',')
+    assert_array_equal(res, np.array([[1, 2+3j, 4+5j, 6-7j, 8j, 9j]] * 2))
+
+
+@pytest.mark.skipif(IS_PYPY and sys.implementation.version <= (7, 3, 8),
+                    reason="PyPy bug in error formatting")
+@pytest.mark.parametrize("dtype", "FD")
+@pytest.mark.parametrize("field",
+        ["1 +2j", "1+ 2j", "1+2 j", "1+-+3", "(1j", "(1", "(1+2j", "1+2j)"])
+def test_bad_complex(dtype, field):
+    with pytest.raises(ValueError):
+        np.loadtxt([field + "\n"], dtype=dtype, delimiter=",")
+
+
+@pytest.mark.skipif(IS_PYPY and sys.implementation.version <= (7, 3, 8),
+                    reason="PyPy bug in error formatting")
+@pytest.mark.parametrize("dtype",
+            np.typecodes["AllInteger"] + "efgdFDG" + "?")
+def test_nul_character_error(dtype):
+    # Test that a \0 character is correctly recognized as an error even if
+    # what comes before is valid (not everything gets parsed internally).
+    if dtype.lower() == "g":
+        pytest.xfail("longdouble/clongdouble assignment may misbehave.")
+    with pytest.raises(ValueError):
+        np.loadtxt(["1\000"], dtype=dtype, delimiter=",", quotechar='"')
+
+
+@pytest.mark.skipif(IS_PYPY and sys.implementation.version <= (7, 3, 8),
+                    reason="PyPy bug in error formatting")
+@pytest.mark.parametrize("dtype",
+        np.typecodes["AllInteger"] + "efgdFDG" + "?")
+def test_no_thousands_support(dtype):
+    # Mainly to document behaviour, Python supports thousands like 1_1.
+    # (e and G may end up using different conversion and support it, this is
+    # a bug but happens...)
+    if dtype == "e":
+        pytest.skip("half assignment currently uses Python float converter")
+    if dtype in "eG":
+        pytest.xfail("clongdouble assignment is buggy (uses `complex`?).")
+
+    assert int("1_1") == float("1_1") == complex("1_1") == 11
+    with pytest.raises(ValueError):
+        np.loadtxt(["1_1\n"], dtype=dtype)
+
+
+@pytest.mark.parametrize("data", [
+    ["1,2\n", "2\n,3\n"],
+    ["1,2\n", "2\r,3\n"]])
+def test_bad_newline_in_iterator(data):
+    # In NumPy <=1.22 this was accepted, because newlines were completely
+    # ignored when the input was an iterable.  This could be changed, but right
+    # now, we raise an error.
+    msg = "Found an unquoted embedded newline within a single line"
+    with pytest.raises(ValueError, match=msg):
+        np.loadtxt(data, delimiter=",")
+
+
+@pytest.mark.parametrize("data", [
+    ["1,2\n", "2,3\r\n"],  # a universal newline
+    ["1,2\n", "'2\n',3\n"],  # a quoted newline
+    ["1,2\n", "'2\r',3\n"],
+    ["1,2\n", "'2\r\n',3\n"],
+])
+def test_good_newline_in_iterator(data):
+    # The quoted newlines will be untransformed here, but are just whitespace.
+    res = np.loadtxt(data, delimiter=",", quotechar="'")
+    assert_array_equal(res, [[1., 2.], [2., 3.]])
+
+
+@pytest.mark.parametrize("newline", ["\n", "\r", "\r\n"])
+def test_universal_newlines_quoted(newline):
+    # Check that universal newline support within the tokenizer is not applied
+    # to quoted fields.  (note that lines must end in newline or quoted
+    # fields will not include a newline at all)
+    data = ['1,"2\n"\n', '3,"4\n', '1"\n']
+    data = [row.replace("\n", newline) for row in data]
+    res = np.loadtxt(data, dtype=object, delimiter=",", quotechar='"')
+    assert_array_equal(res, [['1', f'2{newline}'], ['3', f'4{newline}1']])
+
+
+def test_null_character():
+    # Basic tests to check that the NUL character is not special:
+    res = np.loadtxt(["1\0002\0003\n", "4\0005\0006"], delimiter="\000")
+    assert_array_equal(res, [[1, 2, 3], [4, 5, 6]])
+
+    # Also not as part of a field (avoid unicode/arrays as unicode strips \0)
+    res = np.loadtxt(["1\000,2\000,3\n", "4\000,5\000,6"],
+                     delimiter=",", dtype=object)
+    assert res.tolist() == [["1\000", "2\000", "3"], ["4\000", "5\000", "6"]]
+
+
+def test_iterator_fails_getting_next_line():
+    class BadSequence:
+        def __len__(self):
+            return 100
+
+        def __getitem__(self, item):
+            if item == 50:
+                raise RuntimeError("Bad things happened!")
+            return f"{item}, {item+1}"
+
+    with pytest.raises(RuntimeError, match="Bad things happened!"):
+        np.loadtxt(BadSequence(), dtype=int, delimiter=",")
+
+
+class TestCReaderUnitTests:
+    # These are internal tests for path that should not be possible to hit
+    # unless things go very very wrong somewhere.
+    def test_not_an_filelike(self):
+        with pytest.raises(AttributeError, match=".*read"):
+            np.core._multiarray_umath._load_from_filelike(
+                object(), dtype=np.dtype("i"), filelike=True)
+
+    def test_filelike_read_fails(self):
+        # Can only be reached if loadtxt opens the file, so it is hard to do
+        # via the public interface (although maybe not impossible considering
+        # the current "DataClass" backing).
+        class BadFileLike:
+            counter = 0
+
+            def read(self, size):
+                self.counter += 1
+                if self.counter > 20:
+                    raise RuntimeError("Bad bad bad!")
+                return "1,2,3\n"
+
+        with pytest.raises(RuntimeError, match="Bad bad bad!"):
+            np.core._multiarray_umath._load_from_filelike(
+                BadFileLike(), dtype=np.dtype("i"), filelike=True)
+
+    def test_filelike_bad_read(self):
+        # Can only be reached if loadtxt opens the file, so it is hard to do
+        # via the public interface (although maybe not impossible considering
+        # the current "DataClass" backing).
+
+        class BadFileLike:
+            counter = 0
+
+            def read(self, size):
+                return 1234  # not a string!
+
+        with pytest.raises(TypeError,
+                    match="non-string returned while reading data"):
+            np.core._multiarray_umath._load_from_filelike(
+                BadFileLike(), dtype=np.dtype("i"), filelike=True)
+
+    def test_not_an_iter(self):
+        with pytest.raises(TypeError,
+                    match="error reading from object, expected an iterable"):
+            np.core._multiarray_umath._load_from_filelike(
+                object(), dtype=np.dtype("i"), filelike=False)
+
+    def test_bad_type(self):
+        with pytest.raises(TypeError, match="internal error: dtype must"):
+            np.core._multiarray_umath._load_from_filelike(
+                object(), dtype="i", filelike=False)
+
+    def test_bad_encoding(self):
+        with pytest.raises(TypeError, match="encoding must be a unicode"):
+            np.core._multiarray_umath._load_from_filelike(
+                object(), dtype=np.dtype("i"), filelike=False, encoding=123)
+
+    @pytest.mark.parametrize("newline", ["\r", "\n", "\r\n"])
+    def test_manual_universal_newlines(self, newline):
+        # This is currently not available to users, because we should always
+        # open files with universal newlines enabled `newlines=None`.
+        # (And reading from an iterator uses slightly different code paths.)
+        # We have no real support for `newline="\r"` or `newline="\n" as the
+        # user cannot specify those options.
+        data = StringIO('0\n1\n"2\n"\n3\n4 #\n'.replace("\n", newline),
+                        newline="")
+
+        res = np.core._multiarray_umath._load_from_filelike(
+            data, dtype=np.dtype("U10"), filelike=True,
+            quote='"', comment="#", skiplines=1)
+        assert_array_equal(res[:, 0], ["1", f"2{newline}", "3", "4 "])
+
+
+def test_delimiter_comment_collision_raises():
+    with pytest.raises(TypeError, match=".*control characters.*incompatible"):
+        np.loadtxt(StringIO("1, 2, 3"), delimiter=",", comments=",")
+
+
+def test_delimiter_quotechar_collision_raises():
+    with pytest.raises(TypeError, match=".*control characters.*incompatible"):
+        np.loadtxt(StringIO("1, 2, 3"), delimiter=",", quotechar=",")
+
+
+def test_comment_quotechar_collision_raises():
+    with pytest.raises(TypeError, match=".*control characters.*incompatible"):
+        np.loadtxt(StringIO("1 2 3"), comments="#", quotechar="#")
+
+
+def test_delimiter_and_multiple_comments_collision_raises():
+    with pytest.raises(
+        TypeError, match="Comment characters.*cannot include the delimiter"
+    ):
+        np.loadtxt(StringIO("1, 2, 3"), delimiter=",", comments=["#", ","])
+
+
+@pytest.mark.parametrize(
+    "ws",
+    (
+        " ",  # space
+        "\t",  # tab
+        "\u2003",  # em
+        "\u00A0",  # non-break
+        "\u3000",  # ideographic space
+    )
+)
+def test_collision_with_default_delimiter_raises(ws):
+    with pytest.raises(TypeError, match=".*control characters.*incompatible"):
+        np.loadtxt(StringIO(f"1{ws}2{ws}3\n4{ws}5{ws}6\n"), comments=ws)
+    with pytest.raises(TypeError, match=".*control characters.*incompatible"):
+        np.loadtxt(StringIO(f"1{ws}2{ws}3\n4{ws}5{ws}6\n"), quotechar=ws)
+
+
+@pytest.mark.parametrize("nl", ("\n", "\r"))
+def test_control_character_newline_raises(nl):
+    txt = StringIO(f"1{nl}2{nl}3{nl}{nl}4{nl}5{nl}6{nl}{nl}")
+    msg = "control character.*cannot be a newline"
+    with pytest.raises(TypeError, match=msg):
+        np.loadtxt(txt, delimiter=nl)
+    with pytest.raises(TypeError, match=msg):
+        np.loadtxt(txt, comments=nl)
+    with pytest.raises(TypeError, match=msg):
+        np.loadtxt(txt, quotechar=nl)
+
+
+@pytest.mark.parametrize(
+    ("generic_data", "long_datum", "unitless_dtype", "expected_dtype"),
+    [
+        ("2012-03", "2013-01-15", "M8", "M8[D]"),  # Datetimes
+        ("spam-a-lot", "tis_but_a_scratch", "U", "U17"),  # str
+    ],
+)
+@pytest.mark.parametrize("nrows", (10, 50000, 60000))  # lt, eq, gt chunksize
+def test_parametric_unit_discovery(
+    generic_data, long_datum, unitless_dtype, expected_dtype, nrows
+):
+    """Check that the correct unit (e.g. month, day, second) is discovered from
+    the data when a user specifies a unitless datetime."""
+    # Unit should be "D" (days) due to last entry
+    data = [generic_data] * 50000 + [long_datum]
+    expected = np.array(data, dtype=expected_dtype)
+
+    # file-like path
+    txt = StringIO("\n".join(data))
+    a = np.loadtxt(txt, dtype=unitless_dtype)
+    assert a.dtype == expected.dtype
+    assert_equal(a, expected)
+
+    # file-obj path
+    fd, fname = mkstemp()
+    os.close(fd)
+    with open(fname, "w") as fh:
+        fh.write("\n".join(data))
+    a = np.loadtxt(fname, dtype=unitless_dtype)
+    os.remove(fname)
+    assert a.dtype == expected.dtype
+    assert_equal(a, expected)
+
+
+def test_str_dtype_unit_discovery_with_converter():
+    data = ["spam-a-lot"] * 60000 + ["XXXtis_but_a_scratch"]
+    expected = np.array(
+        ["spam-a-lot"] * 60000 + ["tis_but_a_scratch"], dtype="U17"
+    )
+    conv = lambda s: s.strip("XXX")
+
+    # file-like path
+    txt = StringIO("\n".join(data))
+    a = np.loadtxt(txt, dtype="U", converters=conv, encoding=None)
+    assert a.dtype == expected.dtype
+    assert_equal(a, expected)
+
+    # file-obj path
+    fd, fname = mkstemp()
+    os.close(fd)
+    with open(fname, "w") as fh:
+        fh.write("\n".join(data))
+    a = np.loadtxt(fname, dtype="U", converters=conv, encoding=None)
+    os.remove(fname)
+    assert a.dtype == expected.dtype
+    assert_equal(a, expected)
+
+
+@pytest.mark.skipif(IS_PYPY and sys.implementation.version <= (7, 3, 8),
+                    reason="PyPy bug in error formatting")
+def test_control_character_empty():
+    with pytest.raises(TypeError, match="Text reading control character must"):
+        np.loadtxt(StringIO("1 2 3"), delimiter="")
+    with pytest.raises(TypeError, match="Text reading control character must"):
+        np.loadtxt(StringIO("1 2 3"), quotechar="")
+    with pytest.raises(ValueError, match="comments cannot be an empty string"):
+        np.loadtxt(StringIO("1 2 3"), comments="")
+    with pytest.raises(ValueError, match="comments cannot be an empty string"):
+        np.loadtxt(StringIO("1 2 3"), comments=["#", ""])
+
+
+def test_control_characters_as_bytes():
+    """Byte control characters (comments, delimiter) are supported."""
+    a = np.loadtxt(StringIO("#header\n1,2,3"), comments=b"#", delimiter=b",")
+    assert_equal(a, [1, 2, 3])
+
+
+@pytest.mark.filterwarnings('ignore::UserWarning')
+def test_field_growing_cases():
+    # Test empty field appending/growing (each field still takes 1 character)
+    # to see if the final field appending does not create issues.
+    res = np.loadtxt([""], delimiter=",", dtype=bytes)
+    assert len(res) == 0
+
+    for i in range(1, 1024):
+        res = np.loadtxt(["," * i], delimiter=",", dtype=bytes)
+        assert len(res) == i+1
diff --git a/numpy/lib/tests/test_nanfunctions.py b/numpy/lib/tests/test_nanfunctions.py
index 733a077ea1fc..7cdcff32dc80 100644
--- a/numpy/lib/tests/test_nanfunctions.py
+++ b/numpy/lib/tests/test_nanfunctions.py
@@ -3,6 +3,7 @@
 import inspect
 
 import numpy as np
+from numpy.core.numeric import normalize_axis_tuple
 from numpy.lib.nanfunctions import _nan_mask, _replace_nan
 from numpy.testing import (
     assert_, assert_equal, assert_almost_equal, assert_raises,
@@ -807,6 +808,34 @@ def test_keepdims(self):
             res = np.nanmedian(d, axis=(0, 1, 3), keepdims=True)
             assert_equal(res.shape, (1, 1, 7, 1))
 
+    @pytest.mark.parametrize(
+        argnames='axis',
+        argvalues=[
+            None,
+            1,
+            (1, ),
+            (0, 1),
+            (-3, -1),
+        ]
+    )
+    @pytest.mark.filterwarnings("ignore:All-NaN slice:RuntimeWarning")
+    def test_keepdims_out(self, axis):
+        d = np.ones((3, 5, 7, 11))
+        # Randomly set some elements to NaN:
+        w = np.random.random((4, 200)) * np.array(d.shape)[:, None]
+        w = w.astype(np.intp)
+        d[tuple(w)] = np.nan
+        if axis is None:
+            shape_out = (1,) * d.ndim
+        else:
+            axis_norm = normalize_axis_tuple(axis, d.ndim)
+            shape_out = tuple(
+                1 if i in axis_norm else d.shape[i] for i in range(d.ndim))
+        out = np.empty(shape_out)
+        result = np.nanmedian(d, axis=axis, keepdims=True, out=out)
+        assert result is out
+        assert_equal(result.shape, shape_out)
+
     def test_out(self):
         mat = np.random.rand(3, 3)
         nan_mat = np.insert(mat, [0, 2], np.nan, axis=1)
@@ -982,6 +1011,37 @@ def test_keepdims(self):
             res = np.nanpercentile(d, 90, axis=(0, 1, 3), keepdims=True)
             assert_equal(res.shape, (1, 1, 7, 1))
 
+    @pytest.mark.parametrize('q', [7, [1, 7]])
+    @pytest.mark.parametrize(
+        argnames='axis',
+        argvalues=[
+            None,
+            1,
+            (1,),
+            (0, 1),
+            (-3, -1),
+        ]
+    )
+    @pytest.mark.filterwarnings("ignore:All-NaN slice:RuntimeWarning")
+    def test_keepdims_out(self, q, axis):
+        d = np.ones((3, 5, 7, 11))
+        # Randomly set some elements to NaN:
+        w = np.random.random((4, 200)) * np.array(d.shape)[:, None]
+        w = w.astype(np.intp)
+        d[tuple(w)] = np.nan
+        if axis is None:
+            shape_out = (1,) * d.ndim
+        else:
+            axis_norm = normalize_axis_tuple(axis, d.ndim)
+            shape_out = tuple(
+                1 if i in axis_norm else d.shape[i] for i in range(d.ndim))
+        shape_out = np.shape(q) + shape_out
+
+        out = np.empty(shape_out)
+        result = np.nanpercentile(d, q, axis=axis, keepdims=True, out=out)
+        assert result is out
+        assert_equal(result.shape, shape_out)
+
     def test_out(self):
         mat = np.random.rand(3, 3)
         nan_mat = np.insert(mat, [0, 2], np.nan, axis=1)
diff --git a/numpy/lib/tests/test_recfunctions.py b/numpy/lib/tests/test_recfunctions.py
index 2f3c14df31f0..0c919a53d845 100644
--- a/numpy/lib/tests/test_recfunctions.py
+++ b/numpy/lib/tests/test_recfunctions.py
@@ -20,7 +20,7 @@
 class TestRecFunctions:
     # Misc tests
 
-    def setup(self):
+    def setup_method(self):
         x = np.array([1, 2, ])
         y = np.array([10, 20, 30])
         z = np.array([('A', 1.), ('B', 2.)],
@@ -318,6 +318,15 @@ def inspect(dt, dtype=None):
         assert_raises(NotImplementedError, unstructured_to_structured,
                                            np.zeros((3,0), dtype=np.int32))
 
+    def test_unstructured_to_structured(self):
+        # test if dtype is the args of np.dtype
+        a = np.zeros((20, 2))
+        test_dtype_args = [('x', float), ('y', float)]
+        test_dtype = np.dtype(test_dtype_args)
+        field1 = unstructured_to_structured(a, dtype=test_dtype_args)  # now
+        field2 = unstructured_to_structured(a, dtype=test_dtype)  # before
+        assert_equal(field1, field2)
+
     def test_field_assignment_by_name(self):
         a = np.ones(2, dtype=[('a', 'i4'), ('b', 'f8'), ('c', 'u1')])
         newdt = [('b', 'f4'), ('c', 'u1')]
@@ -372,7 +381,7 @@ def test_masked_flexible(self):
 class TestMergeArrays:
     # Test merge_arrays
 
-    def setup(self):
+    def setup_method(self):
         x = np.array([1, 2, ])
         y = np.array([10, 20, 30])
         z = np.array(
@@ -505,7 +514,7 @@ def test_singlerecord(self):
 class TestAppendFields:
     # Test append_fields
 
-    def setup(self):
+    def setup_method(self):
         x = np.array([1, 2, ])
         y = np.array([10, 20, 30])
         z = np.array(
@@ -558,7 +567,7 @@ def test_append_on_nested(self):
 
 class TestStackArrays:
     # Test stack_arrays
-    def setup(self):
+    def setup_method(self):
         x = np.array([1, 2, ])
         y = np.array([10, 20, 30])
         z = np.array(
@@ -728,7 +737,7 @@ def test_subdtype(self):
 
 
 class TestJoinBy:
-    def setup(self):
+    def setup_method(self):
         self.a = np.array(list(zip(np.arange(10), np.arange(50, 60),
                                    np.arange(100, 110))),
                           dtype=[('a', int), ('b', int), ('c', int)])
@@ -835,7 +844,6 @@ def test_duplicate_keys(self):
         b = np.ones(3, dtype=[('c', 'u1'), ('b', 'f4'), ('a', 'i4')])
         assert_raises(ValueError, join_by, ['a', 'b', 'b'], a, b)
 
-    @pytest.mark.xfail(reason="See comment at gh-9343")
     def test_same_name_different_dtypes_key(self):
         a_dtype = np.dtype([('key', 'S5'), ('value', '= M:
         return m
+    # Ensure M and k are integers, so we don't get any surprise casting
+    # results in the expressions `M-k` and `M+1` used below.  This avoids
+    # a problem with inputs with type (for example) np.uint64.
+    M = operator.index(M)
+    k = operator.index(k)
     if k >= 0:
         i = k
     else:
@@ -223,7 +229,7 @@ def eye(N, M=None, k=0, dtype=float, order='C', *, like=None):
 
 
 _eye_with_like = array_function_dispatch(
-    _eye_dispatcher
+    _eye_dispatcher, use_like=True
 )(eye)
 
 
@@ -425,7 +431,7 @@ def tri(N, M=None, k=0, dtype=float, *, like=None):
 
 
 _tri_with_like = array_function_dispatch(
-    _tri_dispatcher
+    _tri_dispatcher, use_like=True
 )(tri)
 
 
@@ -494,8 +500,8 @@ def triu(m, k=0):
     Upper triangle of an array.
 
     Return a copy of an array with the elements below the `k`-th diagonal
-    zeroed. For arrays with ``ndim`` exceeding 2, `triu` will apply to the final
-    two axes.
+    zeroed. For arrays with ``ndim`` exceeding 2, `triu` will apply to the
+    final two axes.
 
     Please refer to the documentation for `tril` for further details.
 
@@ -628,8 +634,8 @@ def vander(x, N=None, increasing=False):
     return v
 
 
-def _histogram2d_dispatcher(x, y, bins=None, range=None, normed=None,
-                            weights=None, density=None):
+def _histogram2d_dispatcher(x, y, bins=None, range=None, density=None,
+                            weights=None):
     yield x
     yield y
 
@@ -647,8 +653,7 @@ def _histogram2d_dispatcher(x, y, bins=None, range=None, normed=None,
 
 
 @array_function_dispatch(_histogram2d_dispatcher)
-def histogram2d(x, y, bins=10, range=None, normed=None, weights=None,
-                density=None):
+def histogram2d(x, y, bins=10, range=None, density=None, weights=None):
     """
     Compute the bi-dimensional histogram of two data samples.
 
@@ -682,13 +687,9 @@ def histogram2d(x, y, bins=10, range=None, normed=None, weights=None,
         If False, the default, returns the number of samples in each bin.
         If True, returns the probability *density* function at the bin,
         ``bin_count / sample_count / bin_area``.
-    normed : bool, optional
-        An alias for the density argument that behaves identically. To avoid
-        confusion with the broken normed argument to `histogram`, `density`
-        should be preferred.
     weights : array_like, shape(N,), optional
         An array of values ``w_i`` weighing each sample ``(x_i, y_i)``.
-        Weights are normalized to 1 if `normed` is True. If `normed` is
+        Weights are normalized to 1 if `density` is True. If `density` is
         False, the values of the returned histogram are equal to the sum of
         the weights belonging to the samples falling into each bin.
 
@@ -710,7 +711,7 @@ def histogram2d(x, y, bins=10, range=None, normed=None, weights=None,
 
     Notes
     -----
-    When `normed` is True, then the returned histogram is the sample
+    When `density` is True, then the returned histogram is the sample
     density, defined such that the sum over bins of the product
     ``bin_value * bin_area`` is 1.
 
@@ -765,7 +766,7 @@ def histogram2d(x, y, bins=10, range=None, normed=None, weights=None,
     >>> xcenters = (xedges[:-1] + xedges[1:]) / 2
     >>> ycenters = (yedges[:-1] + yedges[1:]) / 2
     >>> im.set_data(xcenters, ycenters, H)
-    >>> ax.images.append(im)
+    >>> ax.add_image(im)
     >>> plt.show()
 
     It is also possible to construct a 2-D histogram without specifying bin
@@ -804,7 +805,7 @@ def histogram2d(x, y, bins=10, range=None, normed=None, weights=None,
     >>> plt.show()
     """
     from numpy import histogramdd
-    
+
     if len(x) != len(y):
         raise ValueError('x and y must have the same length.')
 
@@ -816,7 +817,7 @@ def histogram2d(x, y, bins=10, range=None, normed=None, weights=None,
     if N != 1 and N != 2:
         xedges = yedges = asarray(bins)
         bins = [xedges, yedges]
-    hist, edges = histogramdd([x, y], bins, range, normed, weights, density)
+    hist, edges = histogramdd([x, y], bins, range, density, weights)
     return hist, edges[0], edges[1]
 
 
diff --git a/numpy/lib/twodim_base.pyi b/numpy/lib/twodim_base.pyi
index cba503ca3558..1b3b94bd5cba 100644
--- a/numpy/lib/twodim_base.pyi
+++ b/numpy/lib/twodim_base.pyi
@@ -1,18 +1,12 @@
+from collections.abc import Callable, Sequence
 from typing import (
     Any,
-    Callable,
-    List,
-    Sequence,
     overload,
-    Tuple,
-    Type,
     TypeVar,
     Union,
 )
 
 from numpy import (
-    ndarray,
-    dtype,
     generic,
     number,
     bool_,
@@ -28,13 +22,13 @@ from numpy import (
     _OrderCF,
 )
 
-from numpy.typing import (
+from numpy._typing import (
     DTypeLike,
-    _SupportsDType,
+    _DTypeLike,
     ArrayLike,
+    _ArrayLike,
     NDArray,
-    _FiniteNestedSequence,
-    _SupportsArray,
+    _SupportsArrayFunc,
     _ArrayLikeInt_co,
     _ArrayLikeFloat_co,
     _ArrayLikeComplex_co,
@@ -50,14 +44,7 @@ _MaskFunc = Callable[
     NDArray[Union[number[Any], bool_, timedelta64, datetime64, object_]],
 ]
 
-_DTypeLike = Union[
-    Type[_SCT],
-    dtype[_SCT],
-    _SupportsDType[dtype[_SCT]],
-]
-_ArrayLike = _FiniteNestedSequence[_SupportsArray[dtype[_SCT]]]
-
-__all__: List[str]
+__all__: list[str]
 
 @overload
 def fliplr(m: _ArrayLike[_SCT]) -> NDArray[_SCT]: ...
@@ -77,7 +64,7 @@ def eye(
     dtype: None = ...,
     order: _OrderCF = ...,
     *,
-    like: None | ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[float64]: ...
 @overload
 def eye(
@@ -87,7 +74,7 @@ def eye(
     dtype: _DTypeLike[_SCT] = ...,
     order: _OrderCF = ...,
     *,
-    like: None | ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[_SCT]: ...
 @overload
 def eye(
@@ -97,7 +84,7 @@ def eye(
     dtype: DTypeLike = ...,
     order: _OrderCF = ...,
     *,
-    like: None | ArrayLike = ...,
+    like: None | _SupportsArrayFunc = ...,
 ) -> NDArray[Any]: ...
 
 @overload
@@ -117,7 +104,7 @@ def tri(
     k: int = ...,
     dtype: None = ...,
     *,
-    like: None | ArrayLike = ...
+    like: None | _SupportsArrayFunc = ...
 ) -> NDArray[float64]: ...
 @overload
 def tri(
@@ -126,7 +113,7 @@ def tri(
     k: int = ...,
     dtype: _DTypeLike[_SCT] = ...,
     *,
-    like: None | ArrayLike = ...
+    like: None | _SupportsArrayFunc = ...
 ) -> NDArray[_SCT]: ...
 @overload
 def tri(
@@ -135,7 +122,7 @@ def tri(
     k: int = ...,
     dtype: DTypeLike = ...,
     *,
-    like: None | ArrayLike = ...
+    like: None | _SupportsArrayFunc = ...
 ) -> NDArray[Any]: ...
 
 @overload
@@ -179,10 +166,9 @@ def histogram2d(  # type: ignore[misc]
     y: _ArrayLikeFloat_co,
     bins: int | Sequence[int] = ...,
     range: None | _ArrayLikeFloat_co = ...,
-    normed: None | bool = ...,
-    weights: None | _ArrayLikeFloat_co = ...,
     density: None | bool = ...,
-) -> Tuple[
+    weights: None | _ArrayLikeFloat_co = ...,
+) -> tuple[
     NDArray[float64],
     NDArray[floating[Any]],
     NDArray[floating[Any]],
@@ -193,10 +179,9 @@ def histogram2d(
     y: _ArrayLikeComplex_co,
     bins: int | Sequence[int] = ...,
     range: None | _ArrayLikeFloat_co = ...,
-    normed: None | bool = ...,
-    weights: None | _ArrayLikeFloat_co = ...,
     density: None | bool = ...,
-) -> Tuple[
+    weights: None | _ArrayLikeFloat_co = ...,
+) -> tuple[
     NDArray[float64],
     NDArray[complexfloating[Any, Any]],
     NDArray[complexfloating[Any, Any]],
@@ -207,10 +192,9 @@ def histogram2d(
     y: _ArrayLikeComplex_co,
     bins: Sequence[_ArrayLikeInt_co],
     range: None | _ArrayLikeFloat_co = ...,
-    normed: None | bool = ...,
-    weights: None | _ArrayLikeFloat_co = ...,
     density: None | bool = ...,
-) -> Tuple[
+    weights: None | _ArrayLikeFloat_co = ...,
+) -> tuple[
     NDArray[float64],
     NDArray[Any],
     NDArray[Any],
@@ -224,32 +208,32 @@ def mask_indices(
     n: int,
     mask_func: _MaskFunc[int],
     k: int = ...,
-) -> Tuple[NDArray[intp], NDArray[intp]]: ...
+) -> tuple[NDArray[intp], NDArray[intp]]: ...
 @overload
 def mask_indices(
     n: int,
     mask_func: _MaskFunc[_T],
     k: _T,
-) -> Tuple[NDArray[intp], NDArray[intp]]: ...
+) -> tuple[NDArray[intp], NDArray[intp]]: ...
 
 def tril_indices(
     n: int,
     k: int = ...,
     m: None | int = ...,
-) -> Tuple[NDArray[int_], NDArray[int_]]: ...
+) -> tuple[NDArray[int_], NDArray[int_]]: ...
 
 def tril_indices_from(
     arr: NDArray[Any],
     k: int = ...,
-) -> Tuple[NDArray[int_], NDArray[int_]]: ...
+) -> tuple[NDArray[int_], NDArray[int_]]: ...
 
 def triu_indices(
     n: int,
     k: int = ...,
     m: None | int = ...,
-) -> Tuple[NDArray[int_], NDArray[int_]]: ...
+) -> tuple[NDArray[int_], NDArray[int_]]: ...
 
 def triu_indices_from(
     arr: NDArray[Any],
     k: int = ...,
-) -> Tuple[NDArray[int_], NDArray[int_]]: ...
+) -> tuple[NDArray[int_], NDArray[int_]]: ...
diff --git a/numpy/lib/type_check.py b/numpy/lib/type_check.py
index 56afd83ce335..94d525f51da1 100644
--- a/numpy/lib/type_check.py
+++ b/numpy/lib/type_check.py
@@ -6,7 +6,7 @@
 
 __all__ = ['iscomplexobj', 'isrealobj', 'imag', 'iscomplex',
            'isreal', 'nan_to_num', 'real', 'real_if_close',
-           'typename', 'asfarray', 'mintypecode', 'asscalar',
+           'typename', 'asfarray', 'mintypecode',
            'common_type']
 
 import numpy.core.numeric as _nx
@@ -276,22 +276,22 @@ def isreal(x):
     >>> a = np.array([1+1j, 1+0j, 4.5, 3, 2, 2j], dtype=complex)
     >>> np.isreal(a)
     array([False,  True,  True,  True,  True, False])
-    
+
     The function does not work on string arrays.
 
     >>> a = np.array([2j, "a"], dtype="U")
     >>> np.isreal(a)  # Warns about non-elementwise comparison
     False
-    
+
     Returns True for all elements in input array of ``dtype=object`` even if
     any of the elements is complex.
 
     >>> a = np.array([1, "2", 3+4j], dtype=object)
     >>> np.isreal(a)
     array([ True,  True,  True])
-    
+
     isreal should not be used with object arrays
-    
+
     >>> a = np.array([1+2j, 2+1j], dtype=object)
     >>> np.isreal(a)
     array([ True,  True])
@@ -405,14 +405,14 @@ def _nan_to_num_dispatcher(x, copy=None, nan=None, posinf=None, neginf=None):
 def nan_to_num(x, copy=True, nan=0.0, posinf=None, neginf=None):
     """
     Replace NaN with zero and infinity with large finite numbers (default
-    behaviour) or with the numbers defined by the user using the `nan`, 
+    behaviour) or with the numbers defined by the user using the `nan`,
     `posinf` and/or `neginf` keywords.
 
     If `x` is inexact, NaN is replaced by zero or by the user defined value in
-    `nan` keyword, infinity is replaced by the largest finite floating point 
-    values representable by ``x.dtype`` or by the user defined value in 
-    `posinf` keyword and -infinity is replaced by the most negative finite 
-    floating point values representable by ``x.dtype`` or by the user defined 
+    `nan` keyword, infinity is replaced by the largest finite floating point
+    values representable by ``x.dtype`` or by the user defined value in
+    `posinf` keyword and -infinity is replaced by the most negative finite
+    floating point values representable by ``x.dtype`` or by the user defined
     value in `neginf` keyword.
 
     For complex dtypes, the above is applied to each of the real and
@@ -429,27 +429,27 @@ def nan_to_num(x, copy=True, nan=0.0, posinf=None, neginf=None):
         in-place (False). The in-place operation only occurs if
         casting to an array does not require a copy.
         Default is True.
-        
+
         .. versionadded:: 1.13
     nan : int, float, optional
-        Value to be used to fill NaN values. If no value is passed 
+        Value to be used to fill NaN values. If no value is passed
         then NaN values will be replaced with 0.0.
-        
+
         .. versionadded:: 1.17
     posinf : int, float, optional
-        Value to be used to fill positive infinity values. If no value is 
+        Value to be used to fill positive infinity values. If no value is
         passed then positive infinity values will be replaced with a very
         large number.
-        
+
         .. versionadded:: 1.17
     neginf : int, float, optional
-        Value to be used to fill negative infinity values. If no value is 
+        Value to be used to fill negative infinity values. If no value is
         passed then negative infinity values will be replaced with a very
         small (or negative) number.
-        
+
         .. versionadded:: 1.17
 
-        
+
 
     Returns
     -------
@@ -483,7 +483,7 @@ def nan_to_num(x, copy=True, nan=0.0, posinf=None, neginf=None):
     array([ 1.79769313e+308, -1.79769313e+308,  0.00000000e+000, # may vary
            -1.28000000e+002,  1.28000000e+002])
     >>> np.nan_to_num(x, nan=-9999, posinf=33333333, neginf=33333333)
-    array([ 3.3333333e+07,  3.3333333e+07, -9.9990000e+03, 
+    array([ 3.3333333e+07,  3.3333333e+07, -9.9990000e+03,
            -1.2800000e+02,  1.2800000e+02])
     >>> y = np.array([complex(np.inf, np.nan), np.nan, complex(np.nan, np.inf)])
     array([  1.79769313e+308,  -1.79769313e+308,   0.00000000e+000, # may vary
@@ -529,7 +529,7 @@ def _real_if_close_dispatcher(a, tol=None):
 @array_function_dispatch(_real_if_close_dispatcher)
 def real_if_close(a, tol=100):
     """
-    If input is complex with all imaginary parts close to zero, return 
+    If input is complex with all imaginary parts close to zero, return
     real parts.
 
     "Close to zero" is defined as `tol` * (machine epsilon of the type for
@@ -583,40 +583,6 @@ def real_if_close(a, tol=100):
     return a
 
 
-def _asscalar_dispatcher(a):
-    # 2018-10-10, 1.16
-    warnings.warn('np.asscalar(a) is deprecated since NumPy v1.16, use '
-                  'a.item() instead', DeprecationWarning, stacklevel=3)
-    return (a,)
-
-
-@array_function_dispatch(_asscalar_dispatcher)
-def asscalar(a):
-    """
-    Convert an array of size 1 to its scalar equivalent.
-
-    .. deprecated:: 1.16
-
-        Deprecated, use `numpy.ndarray.item()` instead.
-
-    Parameters
-    ----------
-    a : ndarray
-        Input array of size 1.
-
-    Returns
-    -------
-    out : scalar
-        Scalar representation of `a`. The output data type is the same type
-        returned by the input's `item` method.
-
-    Examples
-    --------
-    >>> np.asscalar(np.array([24]))
-    24
-    """
-    return a.item()
-
 #-----------------------------------------------------------------------------
 
 _namefromtype = {'S1': 'character',
diff --git a/numpy/lib/type_check.pyi b/numpy/lib/type_check.pyi
index 0a55dbf21347..b04da21d44b6 100644
--- a/numpy/lib/type_check.pyi
+++ b/numpy/lib/type_check.pyi
@@ -1,11 +1,8 @@
+from collections.abc import Container, Iterable
 from typing import (
     Literal as L,
     Any,
-    Container,
-    Iterable,
-    List,
     overload,
-    Type,
     TypeVar,
     Protocol,
 )
@@ -20,7 +17,7 @@ from numpy import (
     integer,
 )
 
-from numpy.typing import (
+from numpy._typing import (
     ArrayLike,
     DTypeLike,
     NBitBase,
@@ -28,8 +25,7 @@ from numpy.typing import (
     _64Bit,
     _SupportsDType,
     _ScalarLike_co,
-    _FiniteNestedSequence,
-    _SupportsArray,
+    _ArrayLike,
     _DTypeLikeComplex,
 )
 
@@ -39,8 +35,6 @@ _SCT = TypeVar("_SCT", bound=generic)
 _NBit1 = TypeVar("_NBit1", bound=NBitBase)
 _NBit2 = TypeVar("_NBit2", bound=NBitBase)
 
-_ArrayLike = _FiniteNestedSequence[_SupportsArray[dtype[_SCT]]]
-
 class _SupportsReal(Protocol[_T_co]):
     @property
     def real(self) -> _T_co: ...
@@ -49,7 +43,7 @@ class _SupportsImag(Protocol[_T_co]):
     @property
     def imag(self) -> _T_co: ...
 
-__all__: List[str]
+__all__: list[str]
 
 def mintypecode(
     typechars: Iterable[str | ArrayLike],
@@ -62,7 +56,7 @@ def mintypecode(
 @overload
 def asfarray(
     a: object,
-    dtype: None | Type[float] = ...,
+    dtype: None | type[float] = ...,
 ) -> NDArray[float64]: ...
 @overload
 def asfarray(  # type: ignore[misc]
@@ -151,9 +145,6 @@ def real_if_close(
     tol: float = ...,
 ) -> NDArray[Any]: ...
 
-# NOTE: deprecated
-# def asscalar(a): ...
-
 @overload
 def typename(char: L['S1']) -> L['character']: ...
 @overload
@@ -204,28 +195,28 @@ def common_type(  # type: ignore[misc]
     *arrays: _SupportsDType[dtype[
         integer[Any]
     ]]
-) -> Type[floating[_64Bit]]: ...
+) -> type[floating[_64Bit]]: ...
 @overload
 def common_type(  # type: ignore[misc]
     *arrays: _SupportsDType[dtype[
         floating[_NBit1]
     ]]
-) -> Type[floating[_NBit1]]: ...
+) -> type[floating[_NBit1]]: ...
 @overload
 def common_type(  # type: ignore[misc]
     *arrays: _SupportsDType[dtype[
         integer[Any] | floating[_NBit1]
     ]]
-) -> Type[floating[_NBit1 | _64Bit]]: ...
+) -> type[floating[_NBit1 | _64Bit]]: ...
 @overload
 def common_type(  # type: ignore[misc]
     *arrays: _SupportsDType[dtype[
         floating[_NBit1] | complexfloating[_NBit2, _NBit2]
     ]]
-) -> Type[complexfloating[_NBit1 | _NBit2, _NBit1 | _NBit2]]: ...
+) -> type[complexfloating[_NBit1 | _NBit2, _NBit1 | _NBit2]]: ...
 @overload
 def common_type(
     *arrays: _SupportsDType[dtype[
         integer[Any] | floating[_NBit1] | complexfloating[_NBit2, _NBit2]
     ]]
-) -> Type[complexfloating[_64Bit | _NBit1 | _NBit2, _64Bit | _NBit1 | _NBit2]]: ...
+) -> type[complexfloating[_64Bit | _NBit1 | _NBit2, _64Bit | _NBit1 | _NBit2]]: ...
diff --git a/numpy/lib/ufunclike.pyi b/numpy/lib/ufunclike.pyi
index 03f08ebffea3..82537e2acd95 100644
--- a/numpy/lib/ufunclike.pyi
+++ b/numpy/lib/ufunclike.pyi
@@ -1,7 +1,7 @@
-from typing import Any, overload, TypeVar, List, Union
+from typing import Any, overload, TypeVar
 
 from numpy import floating, bool_, object_, ndarray
-from numpy.typing import (
+from numpy._typing import (
     NDArray,
     _FloatLike_co,
     _ArrayLikeFloat_co,
@@ -10,7 +10,7 @@ from numpy.typing import (
 
 _ArrayType = TypeVar("_ArrayType", bound=ndarray[Any, Any])
 
-__all__: List[str]
+__all__: list[str]
 
 @overload
 def fix(  # type: ignore[misc]
@@ -29,7 +29,7 @@ def fix(
 ) -> NDArray[object_]: ...
 @overload
 def fix(
-    x: Union[_ArrayLikeFloat_co, _ArrayLikeObject_co],
+    x: _ArrayLikeFloat_co | _ArrayLikeObject_co,
     out: _ArrayType,
 ) -> _ArrayType: ...
 
diff --git a/numpy/lib/utils.py b/numpy/lib/utils.py
index 1df2ab09b29d..afde8cc600a8 100644
--- a/numpy/lib/utils.py
+++ b/numpy/lib/utils.py
@@ -4,6 +4,7 @@
 import types
 import re
 import warnings
+import functools
 
 from numpy.core.numerictypes import issubclass_, issubsctype, issubdtype
 from numpy.core.overrides import set_module
@@ -13,9 +14,86 @@
 __all__ = [
     'issubclass_', 'issubsctype', 'issubdtype', 'deprecate',
     'deprecate_with_doc', 'get_include', 'info', 'source', 'who',
-    'lookfor', 'byte_bounds', 'safe_eval'
+    'lookfor', 'byte_bounds', 'safe_eval', 'show_runtime'
     ]
 
+
+def show_runtime():
+    """
+    Print information about various resources in the system
+    including available intrinsic support and BLAS/LAPACK library
+    in use
+
+    See Also
+    --------
+    show_config : Show libraries in the system on which NumPy was built.
+
+    Notes
+    -----
+    1. Information is derived with the help of `threadpoolctl `_
+       library.
+    2. SIMD related information is derived from ``__cpu_features__``,
+       ``__cpu_baseline__`` and ``__cpu_dispatch__``
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.show_runtime()
+    [{'simd_extensions': {'baseline': ['SSE', 'SSE2', 'SSE3'],
+                          'found': ['SSSE3',
+                                    'SSE41',
+                                    'POPCNT',
+                                    'SSE42',
+                                    'AVX',
+                                    'F16C',
+                                    'FMA3',
+                                    'AVX2'],
+                          'not_found': ['AVX512F',
+                                        'AVX512CD',
+                                        'AVX512_KNL',
+                                        'AVX512_KNM',
+                                        'AVX512_SKX',
+                                        'AVX512_CLX',
+                                        'AVX512_CNL',
+                                        'AVX512_ICL']}},
+     {'architecture': 'Zen',
+      'filepath': '/usr/lib/x86_64-linux-gnu/openblas-pthread/libopenblasp-r0.3.20.so',
+      'internal_api': 'openblas',
+      'num_threads': 12,
+      'prefix': 'libopenblas',
+      'threading_layer': 'pthreads',
+      'user_api': 'blas',
+      'version': '0.3.20'}]
+    """
+    from numpy.core._multiarray_umath import (
+        __cpu_features__, __cpu_baseline__, __cpu_dispatch__
+    )
+    from pprint import pprint
+    config_found = []
+    features_found, features_not_found = [], []
+    for feature in __cpu_dispatch__:
+        if __cpu_features__[feature]:
+            features_found.append(feature)
+        else:
+            features_not_found.append(feature)
+    config_found.append({
+        "simd_extensions": {
+            "baseline": __cpu_baseline__,
+            "found": features_found,
+            "not_found": features_not_found
+        }
+    })
+    try:
+        from threadpoolctl import threadpool_info
+        config_found.extend(threadpool_info())
+    except ImportError:
+        print("WARNING: `threadpoolctl` not found in system!"
+              " Install it by `pip install threadpoolctl`."
+              " Once installed, try `np.show_runtime` again"
+              " for more detailed build information")
+    pprint(config_found)
+
+
 def get_include():
     """
     Return the directory that contains the NumPy \\*.h header files.
@@ -25,8 +103,7 @@ def get_include():
 
     Notes
     -----
-    When using ``distutils``, for example in ``setup.py``.
-    ::
+    When using ``distutils``, for example in ``setup.py``::
 
         import numpy as np
         ...
@@ -46,11 +123,6 @@ def get_include():
     return d
 
 
-def _set_function_name(func, name):
-    func.__name__ = name
-    return func
-
-
 class _Deprecate:
     """
     Decorator class to deprecate old functions.
@@ -78,10 +150,7 @@ def __call__(self, func, *args, **kwargs):
         message = self.message
 
         if old_name is None:
-            try:
-                old_name = func.__name__
-            except AttributeError:
-                old_name = func.__name__
+            old_name = func.__name__
         if new_name is None:
             depdoc = "`%s` is deprecated!" % old_name
         else:
@@ -91,12 +160,12 @@ def __call__(self, func, *args, **kwargs):
         if message is not None:
             depdoc += "\n" + message
 
-        def newfunc(*args,**kwds):
-            """`arrayrange` is deprecated, use `arange` instead!"""
+        @functools.wraps(func)
+        def newfunc(*args, **kwds):
             warnings.warn(depdoc, DeprecationWarning, stacklevel=2)
             return func(*args, **kwds)
 
-        newfunc = _set_function_name(newfunc, old_name)
+        newfunc.__name__ = old_name
         doc = func.__doc__
         if doc is None:
             doc = depdoc
@@ -118,12 +187,7 @@ def newfunc(*args,**kwds):
             depdoc = textwrap.indent(depdoc, ' ' * indent)
             doc = '\n\n'.join([depdoc, doc])
         newfunc.__doc__ = doc
-        try:
-            d = func.__dict__
-        except AttributeError:
-            pass
-        else:
-            newfunc.__dict__.update(d)
+
         return newfunc
 
 
@@ -429,7 +493,7 @@ def _makenamedict(module='numpy'):
     return thedict, dictlist
 
 
-def _info(obj, output=sys.stdout):
+def _info(obj, output=None):
     """Provide information about ndarray obj.
 
     Parameters
@@ -455,6 +519,9 @@ def _info(obj, output=sys.stdout):
     strides = obj.strides
     endian = obj.dtype.byteorder
 
+    if output is None:
+        output = sys.stdout
+
     print("class: ", nm, file=output)
     print("shape: ", obj.shape, file=output)
     print("strides: ", strides, file=output)
@@ -481,7 +548,7 @@ def _info(obj, output=sys.stdout):
 
 
 @set_module('numpy')
-def info(object=None, maxwidth=76, output=sys.stdout, toplevel='numpy'):
+def info(object=None, maxwidth=76, output=None, toplevel='numpy'):
     """
     Get help information for a function, class, or module.
 
@@ -496,7 +563,8 @@ def info(object=None, maxwidth=76, output=sys.stdout, toplevel='numpy'):
         Printing width.
     output : file like object, optional
         File like object that the output is written to, default is
-        ``stdout``.  The object has to be opened in 'w' or 'a' mode.
+        ``None``, in which case ``sys.stdout`` will be used.
+        The object has to be opened in 'w' or 'a' mode.
     toplevel : str, optional
         Start search at this level.
 
@@ -541,6 +609,9 @@ def info(object=None, maxwidth=76, output=sys.stdout, toplevel='numpy'):
     elif hasattr(object, '_ppimport_attr'):
         object = object._ppimport_attr
 
+    if output is None:
+        output = sys.stdout
+
     if object is None:
         info(info)
     elif isinstance(object, ndarray):
@@ -901,8 +972,12 @@ def _lookfor_generate_cache(module, import_modules, regenerate):
                             finally:
                                 sys.stdout = old_stdout
                                 sys.stderr = old_stderr
-                        # Catch SystemExit, too
-                        except (Exception, SystemExit):
+                        except KeyboardInterrupt:
+                            # Assume keyboard interrupt came from a user
+                            raise
+                        except BaseException:
+                            # Ignore also SystemExit and pytests.importorskip
+                            # `Skipped` (these are BaseExceptions; gh-22345)
                             continue
 
             for n, v in _getmembers(item):
@@ -961,6 +1036,12 @@ def safe_eval(source):
     Evaluate a string containing a Python literal expression without
     allowing the execution of arbitrary non-literal code.
 
+    .. warning::
+
+        This function is identical to :py:meth:`ast.literal_eval` and
+        has the same security implications.  It may not always be safe
+        to evaluate large input strings.
+
     Parameters
     ----------
     source : str
diff --git a/numpy/lib/utils.pyi b/numpy/lib/utils.pyi
index f0a8797ad61e..52ca92774975 100644
--- a/numpy/lib/utils.pyi
+++ b/numpy/lib/utils.pyi
@@ -1,15 +1,9 @@
 from ast import AST
+from collections.abc import Callable, Mapping, Sequence
 from typing import (
     Any,
-    Callable,
-    List,
-    Mapping,
-    Optional,
     overload,
-    Sequence,
-    Tuple,
     TypeVar,
-    Union,
     Protocol,
 )
 
@@ -28,17 +22,17 @@ _FuncType = TypeVar("_FuncType", bound=Callable[..., Any])
 class _SupportsWrite(Protocol[_T_contra]):
     def write(self, s: _T_contra, /) -> Any: ...
 
-__all__: List[str]
+__all__: list[str]
 
 class _Deprecate:
-    old_name: Optional[str]
-    new_name: Optional[str]
-    message: Optional[str]
+    old_name: None | str
+    new_name: None | str
+    message: None | str
     def __init__(
         self,
-        old_name: Optional[str] = ...,
-        new_name: Optional[str] = ...,
-        message: Optional[str] = ...,
+        old_name: None | str = ...,
+        new_name: None | str = ...,
+        message: None | str = ...,
     ) -> None: ...
     # NOTE: `__call__` can in principle take arbitrary `*args` and `**kwargs`,
     # even though they aren't used for anything
@@ -49,47 +43,49 @@ def get_include() -> str: ...
 @overload
 def deprecate(
     *,
-    old_name: Optional[str] = ...,
-    new_name: Optional[str] = ...,
-    message: Optional[str] = ...,
+    old_name: None | str = ...,
+    new_name: None | str = ...,
+    message: None | str = ...,
 ) -> _Deprecate: ...
 @overload
 def deprecate(
     func: _FuncType,
     /,
-    old_name: Optional[str] = ...,
-    new_name: Optional[str] = ...,
-    message: Optional[str] = ...,
+    old_name: None | str = ...,
+    new_name: None | str = ...,
+    message: None | str = ...,
 ) -> _FuncType: ...
 
-def deprecate_with_doc(msg: Optional[str]) -> _Deprecate: ...
+def deprecate_with_doc(msg: None | str) -> _Deprecate: ...
 
 # NOTE: In practice `byte_bounds` can (potentially) take any object
 # implementing the `__array_interface__` protocol. The caveat is
 # that certain keys, marked as optional in the spec, must be present for
 #  `byte_bounds`. This concerns `"strides"` and `"data"`.
-def byte_bounds(a: Union[generic, ndarray[Any, Any]]) -> Tuple[int, int]: ...
+def byte_bounds(a: generic | ndarray[Any, Any]) -> tuple[int, int]: ...
 
-def who(vardict: Optional[Mapping[str, ndarray[Any, Any]]] = ...) -> None: ...
+def who(vardict: None | Mapping[str, ndarray[Any, Any]] = ...) -> None: ...
 
 def info(
     object: object = ...,
     maxwidth: int = ...,
-    output: Optional[_SupportsWrite[str]] = ...,
+    output: None | _SupportsWrite[str] = ...,
     toplevel: str = ...,
 ) -> None: ...
 
 def source(
     object: object,
-    output: Optional[_SupportsWrite[str]] = ...,
+    output: None | _SupportsWrite[str] = ...,
 ) -> None: ...
 
 def lookfor(
     what: str,
-    module: Union[None, str, Sequence[str]] = ...,
+    module: None | str | Sequence[str] = ...,
     import_modules: bool = ...,
     regenerate: bool = ...,
-    output: Optional[_SupportsWrite[str]] =...,
+    output: None | _SupportsWrite[str] =...,
 ) -> None: ...
 
-def safe_eval(source: Union[str, AST]) -> Any: ...
+def safe_eval(source: str | AST) -> Any: ...
+
+def show_runtime() -> None: ...
diff --git a/numpy/linalg/__init__.pyi b/numpy/linalg/__init__.pyi
index d457f153a02e..d9acd5581732 100644
--- a/numpy/linalg/__init__.pyi
+++ b/numpy/linalg/__init__.pyi
@@ -1,5 +1,3 @@
-from typing import Any, List
-
 from numpy.linalg.linalg import (
     matrix_power as matrix_power,
     solve as solve,
@@ -25,8 +23,8 @@ from numpy.linalg.linalg import (
 
 from numpy._pytesttester import PytestTester
 
-__all__: List[str]
-__path__: List[str]
+__all__: list[str]
+__path__: list[str]
 test: PytestTester
 
 class LinAlgError(Exception): ...
diff --git a/numpy/linalg/lapack_lite/f2c.c b/numpy/linalg/lapack_lite/f2c.c
index 9a1e9cec1d2b..869fce5d3d9f 100644
--- a/numpy/linalg/lapack_lite/f2c.c
+++ b/numpy/linalg/lapack_lite/f2c.c
@@ -14,9 +14,9 @@
 #include "f2c.h"
 
 
-extern void s_wsfe(cilist *f) {;}
-extern void e_wsfe(void) {;}
-extern void do_fio(integer *c, char *s, ftnlen l) {;}
+extern int s_wsfe(cilist *f) {return 0;}
+extern int e_wsfe(void) {return 0;}
+extern int do_fio(integer *c, char *s, ftnlen l) {return 0;}
 
 /* You'll want this if you redo the f2c_*.c files with the -C option
  * to f2c for checking array subscripts. (It's not suggested you do that
@@ -377,10 +377,11 @@ p->i = p1.i;
 
 #endif /* NO_OVERWRITE */
 
- VOID
 #ifdef KR_headers
+int
 s_cat(lp, rpp, rnp, np, ll) char *lp, *rpp[]; ftnlen rnp[], *np, ll;
 #else
+int
 s_cat(char *lp, char *rpp[], ftnlen rnp[], ftnlen *np, ftnlen ll)
 #endif
 {
@@ -429,7 +430,8 @@ s_cat(char *lp, char *rpp[], ftnlen rnp[], ftnlen *np, ftnlen ll)
 		free(lp1);
 		}
 #endif
-	}
+	return 0;
+}
 
 
 /* compare two strings */
@@ -485,9 +487,9 @@ return(0);
 /* assign strings:  a = b */
 
 #ifdef KR_headers
-VOID s_copy(a, b, la, lb) register char *a, *b; ftnlen la, lb;
+int s_copy(a, b, la, lb) register char *a, *b; ftnlen la, lb;
 #else
-void s_copy(register char *a, register char *b, ftnlen la, ftnlen lb)
+int s_copy(register char *a, register char *b, ftnlen la, ftnlen lb)
 #endif
 {
 	register char *aend, *bend;
@@ -524,6 +526,7 @@ void s_copy(register char *a, register char *b, ftnlen la, ftnlen lb)
 		while(a < aend)
 			*a++ = ' ';
 		}
+        return 0;
 	}
 
 
diff --git a/numpy/linalg/lapack_lite/f2c.h b/numpy/linalg/lapack_lite/f2c.h
index d3fbfc1771f8..b44aaac440f8 100644
--- a/numpy/linalg/lapack_lite/f2c.h
+++ b/numpy/linalg/lapack_lite/f2c.h
@@ -263,7 +263,7 @@ extern double d_tan(double *);
 extern double d_tanh(double *);
 extern double derf_(double *);
 extern double derfc_(double *);
-extern void do_fio(ftnint *, char *, ftnlen);
+extern int do_fio(ftnint *, char *, ftnlen);
 extern integer do_lio(ftnint *, ftnint *, char *, ftnlen);
 extern integer do_uio(ftnint *, char *, ftnlen);
 extern integer e_rdfe(void);
@@ -275,7 +275,7 @@ extern integer e_rsli(void);
 extern integer e_rsue(void);
 extern integer e_wdfe(void);
 extern integer e_wdue(void);
-extern void e_wsfe(void);
+extern int e_wsfe(void);
 extern integer e_wsfi(void);
 extern integer e_wsle(void);
 extern integer e_wsli(void);
@@ -350,9 +350,9 @@ extern double r_sinh(float *);
 extern double r_sqrt(float *);
 extern double r_tan(float *);
 extern double r_tanh(float *);
-extern void s_cat(char *, char **, integer *, integer *, ftnlen);
+extern int s_cat(char *, char **, integer *, integer *, ftnlen);
 extern integer s_cmp(char *, char *, ftnlen, ftnlen);
-extern void s_copy(char *, char *, ftnlen, ftnlen);
+extern int s_copy(char *, char *, ftnlen, ftnlen);
 extern int s_paus(char *, ftnlen);
 extern integer s_rdfe(cilist *);
 extern integer s_rdue(cilist *);
@@ -367,7 +367,7 @@ extern integer s_rsue(cilist *);
 extern int s_stop(char *, ftnlen);
 extern integer s_wdfe(cilist *);
 extern integer s_wdue(cilist *);
-extern void s_wsfe(	cilist *);
+extern int s_wsfe(	cilist *);
 extern integer s_wsfi(icilist *);
 extern integer s_wsle(cilist *);
 extern integer s_wsli(icilist *);
diff --git a/numpy/linalg/lapack_lite/f2c_blas.c b/numpy/linalg/lapack_lite/f2c_blas.c
index 65286892fb64..9a9fd3f9b917 100644
--- a/numpy/linalg/lapack_lite/f2c_blas.c
+++ b/numpy/linalg/lapack_lite/f2c_blas.c
@@ -380,7 +380,6 @@ static doublecomplex c_b1078 = {1.,0.};
     static logical nota, notb;
     static complex temp;
     static logical conja, conjb;
-    static integer ncola;
     extern logical lsame_(char *, char *);
     static integer nrowa, nrowb;
     extern /* Subroutine */ int xerbla_(char *, integer *);
@@ -514,7 +513,7 @@ static doublecomplex c_b1078 = {1.,0.};
        Set  NOTA  and  NOTB  as  true if  A  and  B  respectively are not
        conjugated or transposed, set  CONJA and CONJB  as true if  A  and
        B  respectively are to be  transposed but  not conjugated  and set
-       NROWA, NCOLA and  NROWB  as the number of rows and  columns  of  A
+       NROWA and  NROWB  as the number of rows and  columns  of  A
        and the number of rows of  B  respectively.
 */
 
@@ -536,10 +535,8 @@ static doublecomplex c_b1078 = {1.,0.};
     conjb = lsame_(transb, "C");
     if (nota) {
 	nrowa = *m;
-	ncola = *k;
     } else {
 	nrowa = *k;
-	ncola = *m;
     }
     if (notb) {
 	nrowb = *k;
@@ -6850,7 +6847,6 @@ doublereal ddot_(integer *n, doublereal *dx, integer *incx, doublereal *dy,
     static integer i__, j, l, info;
     static logical nota, notb;
     static doublereal temp;
-    static integer ncola;
     extern logical lsame_(char *, char *);
     static integer nrowa, nrowb;
     extern /* Subroutine */ int xerbla_(char *, integer *);
@@ -6982,7 +6978,7 @@ doublereal ddot_(integer *n, doublereal *dx, integer *incx, doublereal *dy,
 
 
        Set  NOTA  and  NOTB  as  true if  A  and  B  respectively are not
-       transposed and set  NROWA, NCOLA and  NROWB  as the number of rows
+       transposed and set  NROWA and  NROWB  as the number of rows
        and  columns of  A  and the  number of  rows  of  B  respectively.
 */
 
@@ -7002,10 +6998,8 @@ doublereal ddot_(integer *n, doublereal *dx, integer *incx, doublereal *dy,
     notb = lsame_(transb, "N");
     if (nota) {
 	nrowa = *m;
-	ncola = *k;
     } else {
 	nrowa = *k;
-	ncola = *m;
     }
     if (notb) {
 	nrowb = *k;
@@ -11454,7 +11448,6 @@ doublereal sdot_(integer *n, real *sx, integer *incx, real *sy, integer *incy)
     static integer i__, j, l, info;
     static logical nota, notb;
     static real temp;
-    static integer ncola;
     extern logical lsame_(char *, char *);
     static integer nrowa, nrowb;
     extern /* Subroutine */ int xerbla_(char *, integer *);
@@ -11586,7 +11579,7 @@ doublereal sdot_(integer *n, real *sx, integer *incx, real *sy, integer *incy)
 
 
        Set  NOTA  and  NOTB  as  true if  A  and  B  respectively are not
-       transposed and set  NROWA, NCOLA and  NROWB  as the number of rows
+       transposed and set  NROWA and  NROWB  as the number of rows
        and  columns of  A  and the  number of  rows  of  B  respectively.
 */
 
@@ -11606,10 +11599,8 @@ doublereal sdot_(integer *n, real *sx, integer *incx, real *sy, integer *incy)
     notb = lsame_(transb, "N");
     if (nota) {
 	nrowa = *m;
-	ncola = *k;
     } else {
 	nrowa = *k;
-	ncola = *m;
     }
     if (notb) {
 	nrowb = *k;
@@ -15667,7 +15658,6 @@ doublereal snrm2_(integer *n, real *x, integer *incx)
     static logical nota, notb;
     static doublecomplex temp;
     static logical conja, conjb;
-    static integer ncola;
     extern logical lsame_(char *, char *);
     static integer nrowa, nrowb;
     extern /* Subroutine */ int xerbla_(char *, integer *);
@@ -15801,7 +15791,7 @@ doublereal snrm2_(integer *n, real *x, integer *incx)
        Set  NOTA  and  NOTB  as  true if  A  and  B  respectively are not
        conjugated or transposed, set  CONJA and CONJB  as true if  A  and
        B  respectively are to be  transposed but  not conjugated  and set
-       NROWA, NCOLA and  NROWB  as the number of rows and  columns  of  A
+       NROWA and  NROWB  as the number of rows and  columns  of  A
        and the number of rows of  B  respectively.
 */
 
@@ -15823,10 +15813,8 @@ doublereal snrm2_(integer *n, real *x, integer *incx)
     conjb = lsame_(transb, "C");
     if (nota) {
 	nrowa = *m;
-	ncola = *k;
     } else {
 	nrowa = *k;
-	ncola = *m;
     }
     if (notb) {
 	nrowb = *k;
diff --git a/numpy/linalg/lapack_lite/f2c_blas.c.patch b/numpy/linalg/lapack_lite/f2c_blas.c.patch
new file mode 100644
index 000000000000..59a6a1919b11
--- /dev/null
+++ b/numpy/linalg/lapack_lite/f2c_blas.c.patch
@@ -0,0 +1,112 @@
+@@ -380,7 +380,6 @@ L20:
+     static logical nota, notb;
+     static complex temp;
+     static logical conja, conjb;
+-    static integer ncola;
+     extern logical lsame_(char *, char *);
+     static integer nrowa, nrowb;
+     extern /* Subroutine */ int xerbla_(char *, integer *);
+@@ -514,7 +513,7 @@ L20:
+        Set  NOTA  and  NOTB  as  true if  A  and  B  respectively are not
+        conjugated or transposed, set  CONJA and CONJB  as true if  A  and
+        B  respectively are to be  transposed but  not conjugated  and set
+-       NROWA, NCOLA and  NROWB  as the number of rows and  columns  of  A
++       NROWA and  NROWB  as the number of rows and  columns  of  A
+        and the number of rows of  B  respectively.
+ */
+ 
+@@ -536,10 +535,8 @@ L20:
+     conjb = lsame_(transb, "C");
+     if (nota) {
+ 	nrowa = *m;
+-	ncola = *k;
+     } else {
+ 	nrowa = *k;
+-	ncola = *m;
+     }
+     if (notb) {
+ 	nrowb = *k;
+@@ -6850,7 +6847,6 @@ L60:
+     static integer i__, j, l, info;
+     static logical nota, notb;
+     static doublereal temp;
+-    static integer ncola;
+     extern logical lsame_(char *, char *);
+     static integer nrowa, nrowb;
+     extern /* Subroutine */ int xerbla_(char *, integer *);
+@@ -6982,7 +6978,7 @@ L60:
+ 
+ 
+        Set  NOTA  and  NOTB  as  true if  A  and  B  respectively are not
+-       transposed and set  NROWA, NCOLA and  NROWB  as the number of rows
++       transposed and set  NROWA and  NROWB  as the number of rows
+        and  columns of  A  and the  number of  rows  of  B  respectively.
+ */
+ 
+@@ -7002,10 +6998,8 @@ L60:
+     notb = lsame_(transb, "N");
+     if (nota) {
+ 	nrowa = *m;
+-	ncola = *k;
+     } else {
+ 	nrowa = *k;
+-	ncola = *m;
+     }
+     if (notb) {
+ 	nrowb = *k;
+@@ -11454,7 +11448,6 @@ L60:
+     static integer i__, j, l, info;
+     static logical nota, notb;
+     static real temp;
+-    static integer ncola;
+     extern logical lsame_(char *, char *);
+     static integer nrowa, nrowb;
+     extern /* Subroutine */ int xerbla_(char *, integer *);
+@@ -11586,7 +11579,7 @@ L60:
+ 
+ 
+        Set  NOTA  and  NOTB  as  true if  A  and  B  respectively are not
+-       transposed and set  NROWA, NCOLA and  NROWB  as the number of rows
++       transposed and set  NROWA and  NROWB  as the number of rows
+        and  columns of  A  and the  number of  rows  of  B  respectively.
+ */
+ 
+@@ -11606,10 +11599,8 @@ L60:
+     notb = lsame_(transb, "N");
+     if (nota) {
+ 	nrowa = *m;
+-	ncola = *k;
+     } else {
+ 	nrowa = *k;
+-	ncola = *m;
+     }
+     if (notb) {
+ 	nrowb = *k;
+@@ -15667,7 +15658,6 @@ L20:
+     static logical nota, notb;
+     static doublecomplex temp;
+     static logical conja, conjb;
+-    static integer ncola;
+     extern logical lsame_(char *, char *);
+     static integer nrowa, nrowb;
+     extern /* Subroutine */ int xerbla_(char *, integer *);
+@@ -15801,7 +15791,7 @@ L20:
+        Set  NOTA  and  NOTB  as  true if  A  and  B  respectively are not
+        conjugated or transposed, set  CONJA and CONJB  as true if  A  and
+        B  respectively are to be  transposed but  not conjugated  and set
+-       NROWA, NCOLA and  NROWB  as the number of rows and  columns  of  A
++       NROWA and  NROWB  as the number of rows and  columns  of  A
+        and the number of rows of  B  respectively.
+ */
+ 
+@@ -15823,10 +15813,8 @@ L20:
+     conjb = lsame_(transb, "C");
+     if (nota) {
+ 	nrowa = *m;
+-	ncola = *k;
+     } else {
+ 	nrowa = *k;
+-	ncola = *m;
+     }
+     if (notb) {
+ 	nrowb = *k;
diff --git a/numpy/linalg/lapack_lite/f2c_c_lapack.c b/numpy/linalg/lapack_lite/f2c_c_lapack.c
index c36c0e3683a8..a7d1f836b613 100644
--- a/numpy/linalg/lapack_lite/f2c_c_lapack.c
+++ b/numpy/linalg/lapack_lite/f2c_c_lapack.c
@@ -14509,7 +14509,7 @@ doublereal clanhe_(char *norm, char *uplo, integer *n, complex *a, integer *
 		}
 
 /*
-                ==== Use up to NS of the the smallest magnatiude
+                ==== Use up to NS of the smallest magnatiude
                 .    shifts.  If there aren't NS shifts available,
                 .    then use them all, possibly dropping one to
                 .    make the number of shifts even. ====
@@ -16624,7 +16624,7 @@ doublereal clanhe_(char *norm, char *uplo, integer *n, complex *a, integer *
 		}
 
 /*
-                ==== Use up to NS of the the smallest magnatiude
+                ==== Use up to NS of the smallest magnatiude
                 .    shifts.  If there aren't NS shifts available,
                 .    then use them all, possibly dropping one to
                 .    make the number of shifts even. ====
@@ -17341,7 +17341,7 @@ doublereal clanhe_(char *norm, char *uplo, integer *n, complex *a, integer *
 
 /*
                       ==== Accumulate U. (If necessary, update Z later
-                      .    with with an efficient matrix-matrix
+                      .    with an efficient matrix-matrix
                       .    multiply.) ====
 */
 
@@ -25242,7 +25242,7 @@ doublereal clanhe_(char *norm, char *uplo, integer *n, complex *a, integer *
     ===============
 
     The algorithm used in this program is basically backward (forward)
-    substitution, with scaling to make the the code robust against
+    substitution, with scaling to make the code robust against
     possible overflow.
 
     Each eigenvector is normalized so that the element of largest
diff --git a/numpy/linalg/lapack_lite/f2c_d_lapack.c b/numpy/linalg/lapack_lite/f2c_d_lapack.c
index 233db74b996f..10e22ff1ba01 100644
--- a/numpy/linalg/lapack_lite/f2c_d_lapack.c
+++ b/numpy/linalg/lapack_lite/f2c_d_lapack.c
@@ -16423,7 +16423,7 @@ logical dlaisnan_(doublereal *din1, doublereal *din2)
 
     N1     (input) INTEGER
     N2     (input) INTEGER
-           These arguements contain the respective lengths of the two
+           These arguments contain the respective lengths of the two
            sorted lists to be merged.
 
     A      (input) DOUBLE PRECISION array, dimension (N1+N2)
@@ -18032,7 +18032,7 @@ doublereal dlapy3_(doublereal *x, doublereal *y, doublereal *z__)
 		}
 
 /*
-                ==== Use up to NS of the the smallest magnatiude
+                ==== Use up to NS of the smallest magnatiude
                 .    shifts.  If there aren't NS shifts available,
                 .    then use them all, possibly dropping one to
                 .    make the number of shifts even. ====
@@ -20271,7 +20271,7 @@ doublereal dlapy3_(doublereal *x, doublereal *y, doublereal *z__)
 		}
 
 /*
-                ==== Use up to NS of the the smallest magnatiude
+                ==== Use up to NS of the smallest magnatiude
                 .    shifts.  If there aren't NS shifts available,
                 .    then use them all, possibly dropping one to
                 .    make the number of shifts even. ====
@@ -20870,7 +20870,7 @@ doublereal dlapy3_(doublereal *x, doublereal *y, doublereal *z__)
 
 /*
                       ==== Accumulate U. (If necessary, update Z later
-                      .    with with an efficient matrix-matrix
+                      .    with an efficient matrix-matrix
                       .    multiply.) ====
 */
 
@@ -40074,7 +40074,7 @@ doublereal dlapy3_(doublereal *x, doublereal *y, doublereal *z__)
     ===============
 
     The algorithm used in this program is basically backward (forward)
-    substitution, with scaling to make the the code robust against
+    substitution, with scaling to make the code robust against
     possible overflow.
 
     Each eigenvector is normalized so that the element of largest
diff --git a/numpy/linalg/lapack_lite/f2c_s_lapack.c b/numpy/linalg/lapack_lite/f2c_s_lapack.c
index 2a32315c71b5..26e7c18ac97a 100644
--- a/numpy/linalg/lapack_lite/f2c_s_lapack.c
+++ b/numpy/linalg/lapack_lite/f2c_s_lapack.c
@@ -16365,7 +16365,7 @@ logical slaisnan_(real *sin1, real *sin2)
 
     N1     (input) INTEGER
     N2     (input) INTEGER
-           These arguements contain the respective lengths of the two
+           These arguments contain the respective lengths of the two
            sorted lists to be merged.
 
     A      (input) REAL array, dimension (N1+N2)
@@ -17968,7 +17968,7 @@ doublereal slapy3_(real *x, real *y, real *z__)
 		}
 
 /*
-                ==== Use up to NS of the the smallest magnatiude
+                ==== Use up to NS of the smallest magnatiude
                 .    shifts.  If there aren't NS shifts available,
                 .    then use them all, possibly dropping one to
                 .    make the number of shifts even. ====
@@ -20194,7 +20194,7 @@ doublereal slapy3_(real *x, real *y, real *z__)
 		}
 
 /*
-                ==== Use up to NS of the the smallest magnatiude
+                ==== Use up to NS of the smallest magnatiude
                 .    shifts.  If there aren't NS shifts available,
                 .    then use them all, possibly dropping one to
                 .    make the number of shifts even. ====
@@ -20794,7 +20794,7 @@ doublereal slapy3_(real *x, real *y, real *z__)
 
 /*
                       ==== Accumulate U. (If necessary, update Z later
-                      .    with with an efficient matrix-matrix
+                      .    with an efficient matrix-matrix
                       .    multiply.) ====
 */
 
@@ -39901,7 +39901,7 @@ doublereal slapy3_(real *x, real *y, real *z__)
     ===============
 
     The algorithm used in this program is basically backward (forward)
-    substitution, with scaling to make the the code robust against
+    substitution, with scaling to make the code robust against
     possible overflow.
 
     Each eigenvector is normalized so that the element of largest
diff --git a/numpy/linalg/lapack_lite/f2c_z_lapack.c b/numpy/linalg/lapack_lite/f2c_z_lapack.c
index 8234eca41080..64e41d082f10 100644
--- a/numpy/linalg/lapack_lite/f2c_z_lapack.c
+++ b/numpy/linalg/lapack_lite/f2c_z_lapack.c
@@ -14582,7 +14582,7 @@ doublereal zlanhe_(char *norm, char *uplo, integer *n, doublecomplex *a,
 		}
 
 /*
-                ==== Use up to NS of the the smallest magnatiude
+                ==== Use up to NS of the smallest magnatiude
                 .    shifts.  If there aren't NS shifts available,
                 .    then use them all, possibly dropping one to
                 .    make the number of shifts even. ====
@@ -16718,7 +16718,7 @@ doublereal zlanhe_(char *norm, char *uplo, integer *n, doublecomplex *a,
 		}
 
 /*
-                ==== Use up to NS of the the smallest magnatiude
+                ==== Use up to NS of the smallest magnatiude
                 .    shifts.  If there aren't NS shifts available,
                 .    then use them all, possibly dropping one to
                 .    make the number of shifts even. ====
@@ -17439,7 +17439,7 @@ doublereal zlanhe_(char *norm, char *uplo, integer *n, doublecomplex *a,
 
 /*
                       ==== Accumulate U. (If necessary, update Z later
-                      .    with with an efficient matrix-matrix
+                      .    with an efficient matrix-matrix
                       .    multiply.) ====
 */
 
@@ -25358,7 +25358,7 @@ doublereal zlanhe_(char *norm, char *uplo, integer *n, doublecomplex *a,
     ===============
 
     The algorithm used in this program is basically backward (forward)
-    substitution, with scaling to make the the code robust against
+    substitution, with scaling to make the code robust against
     possible overflow.
 
     Each eigenvector is normalized so that the element of largest
diff --git a/numpy/linalg/linalg.py b/numpy/linalg/linalg.py
index 0c27e063175a..697193321bef 100644
--- a/numpy/linalg/linalg.py
+++ b/numpy/linalg/linalg.py
@@ -21,10 +21,11 @@
 from numpy.core import (
     array, asarray, zeros, empty, empty_like, intc, single, double,
     csingle, cdouble, inexact, complexfloating, newaxis, all, Inf, dot,
-    add, multiply, sqrt, fastCopyAndTranspose, sum, isfinite,
+    add, multiply, sqrt, sum, isfinite,
     finfo, errstate, geterrobj, moveaxis, amin, amax, product, abs,
     atleast_2d, intp, asanyarray, object_, matmul,
-    swapaxes, divide, count_nonzero, isnan, sign, argsort, sort
+    swapaxes, divide, count_nonzero, isnan, sign, argsort, sort,
+    reciprocal
 )
 from numpy.core.multiarray import normalize_axis_index
 from numpy.core.overrides import set_module
@@ -157,10 +158,6 @@ def _commonType(*arrays):
     return t, result_type
 
 
-# _fastCopyAndTranpose assumes the input is 2D (as all the calls in here are).
-
-_fastCT = fastCopyAndTranspose
-
 def _to_native_byte_order(*arrays):
     ret = []
     for arr in arrays:
@@ -173,16 +170,6 @@ def _to_native_byte_order(*arrays):
     else:
         return ret
 
-def _fastCopyAndTranspose(type, *arrays):
-    cast_arrays = ()
-    for a in arrays:
-        if a.dtype.type is not type:
-            a = a.astype(type)
-        cast_arrays = cast_arrays + (_fastCT(a),)
-    if len(cast_arrays) == 1:
-        return cast_arrays[0]
-    else:
-        return cast_arrays
 
 def _assert_2d(*arrays):
     for a in arrays:
@@ -242,7 +229,7 @@ def tensorsolve(a, b, axes=None):
 
     It is assumed that all indices of `x` are summed over in the product,
     together with the rightmost indices of `a`, as is done in, for example,
-    ``tensordot(a, x, axes=b.ndim)``.
+    ``tensordot(a, x, axes=x.ndim)``.
 
     Parameters
     ----------
@@ -299,7 +286,13 @@ def tensorsolve(a, b, axes=None):
     for k in oldshape:
         prod *= k
 
-    a = a.reshape(-1, prod)
+    if a.size != prod ** 2:
+        raise LinAlgError(
+            "Input arrays must satisfy the requirement \
+            prod(a.shape[b.ndim:]) == prod(a.shape[:b.ndim])"
+        )
+
+    a = a.reshape(prod, prod)
     b = b.ravel()
     res = wrap(solve(a, b))
     res.shape = oldshape
@@ -691,8 +684,8 @@ def cholesky(a):
     Returns
     -------
     L : (..., M, M) array_like
-        Upper or lower-triangular Cholesky factor of `a`.  Returns a
-        matrix object if `a` is a matrix object.
+        Lower-triangular Cholesky factor of `a`.  Returns a matrix object if
+        `a` is a matrix object.
 
     Raises
     ------
@@ -893,11 +886,11 @@ def qr(a, mode='reduced'):
            [1, 1],
            [1, 1],
            [2, 1]])
-    >>> b = np.array([1, 0, 2, 1])
+    >>> b = np.array([1, 2, 2, 3])
     >>> q, r = np.linalg.qr(A)
     >>> p = np.dot(q.T, b)
     >>> np.dot(np.linalg.inv(r), p)
-    array([  1.1e-16,   1.0e+00])
+    array([  1.,   1.])
 
     """
     if mode not in ('reduced', 'complete', 'r', 'raw'):
@@ -1165,7 +1158,7 @@ def eigvalsh(a, UPLO='L'):
 
 def _convertarray(a):
     t, result_t = _commonType(a)
-    a = _fastCT(a.astype(t))
+    a = a.astype(t).T.copy()
     return a, t, result_t
 
 
@@ -1472,10 +1465,12 @@ def svd(a, full_matrices=True, compute_uv=True, hermitian=False):
     """
     Singular Value Decomposition.
 
-    When `a` is a 2D array, it is factorized as ``u @ np.diag(s) @ vh
-    = (u * s) @ vh``, where `u` and `vh` are 2D unitary arrays and `s` is a 1D
-    array of `a`'s singular values. When `a` is higher-dimensional, SVD is
-    applied in stacked mode as explained below.
+    When `a` is a 2D array, and ``full_matrices=False``, then it is
+    factorized as ``u @ np.diag(s) @ vh = (u * s) @ vh``, where
+    `u` and the Hermitian transpose of `vh` are 2D arrays with
+    orthonormal columns and `s` is a 1D array of `a`'s singular
+    values. When `a` is higher-dimensional, SVD is applied in
+    stacked mode as explained below.
 
     Parameters
     ----------
@@ -1622,7 +1617,6 @@ def svd(a, full_matrices=True, compute_uv=True, hermitian=False):
             return wrap(u), s, wrap(vt)
         else:
             s = eigvalsh(a)
-            s = s[..., ::-1]
             s = abs(s)
             return sort(s)[..., ::-1]
 
@@ -1942,7 +1936,6 @@ def pinv(a, rcond=1e-15, hermitian=False):
     See Also
     --------
     scipy.linalg.pinv : Similar function in SciPy.
-    scipy.linalg.pinv2 : Similar function in SciPy (SVD-based).
     scipy.linalg.pinvh : Compute the (Moore-Penrose) pseudo-inverse of a
                          Hermitian matrix.
 
@@ -2511,9 +2504,11 @@ def norm(x, ord=None, axis=None, keepdims=False):
 
             x = x.ravel(order='K')
             if isComplexType(x.dtype.type):
-                sqnorm = dot(x.real, x.real) + dot(x.imag, x.imag)
+                x_real = x.real
+                x_imag = x.imag
+                sqnorm = x_real.dot(x_real) + x_imag.dot(x_imag)
             else:
-                sqnorm = dot(x, x)
+                sqnorm = x.dot(x)
             ret = sqrt(sqnorm)
             if keepdims:
                 ret = ret.reshape(ndim*[1])
@@ -2553,7 +2548,7 @@ def norm(x, ord=None, axis=None, keepdims=False):
             absx = abs(x)
             absx **= ord
             ret = add.reduce(absx, axis=axis, keepdims=keepdims)
-            ret **= (1 / ord)
+            ret **= reciprocal(ord, dtype=ret.dtype)
             return ret
     elif len(axis) == 2:
         row_axis, col_axis = axis
diff --git a/numpy/linalg/linalg.pyi b/numpy/linalg/linalg.pyi
index a60b9539e848..20cdb708b692 100644
--- a/numpy/linalg/linalg.pyi
+++ b/numpy/linalg/linalg.pyi
@@ -1,13 +1,11 @@
+from collections.abc import Iterable
 from typing import (
     Literal as L,
-    List,
-    Iterable,
     overload,
     TypeVar,
     Any,
     SupportsIndex,
     SupportsInt,
-    Tuple,
 )
 
 from numpy import (
@@ -21,7 +19,7 @@ from numpy import (
 
 from numpy.linalg import LinAlgError as LinAlgError
 
-from numpy.typing import (
+from numpy._typing import (
     NDArray,
     ArrayLike,
     _ArrayLikeInt_co,
@@ -34,10 +32,10 @@ from numpy.typing import (
 _T = TypeVar("_T")
 _ArrayType = TypeVar("_ArrayType", bound=NDArray[Any])
 
-_2Tuple = Tuple[_T, _T]
+_2Tuple = tuple[_T, _T]
 _ModeKind = L["reduced", "complete", "r", "raw"]
 
-__all__: List[str]
+__all__: list[str]
 
 @overload
 def tensorsolve(
@@ -141,17 +139,17 @@ def eig(a: _ArrayLikeComplex_co) -> _2Tuple[NDArray[complexfloating[Any, Any]]]:
 def eigh(
     a: _ArrayLikeInt_co,
     UPLO: L["L", "U", "l", "u"] = ...,
-) -> Tuple[NDArray[float64], NDArray[float64]]: ...
+) -> tuple[NDArray[float64], NDArray[float64]]: ...
 @overload
 def eigh(
     a: _ArrayLikeFloat_co,
     UPLO: L["L", "U", "l", "u"] = ...,
-) -> Tuple[NDArray[floating[Any]], NDArray[floating[Any]]]: ...
+) -> tuple[NDArray[floating[Any]], NDArray[floating[Any]]]: ...
 @overload
 def eigh(
     a: _ArrayLikeComplex_co,
     UPLO: L["L", "U", "l", "u"] = ...,
-) -> Tuple[NDArray[floating[Any]], NDArray[complexfloating[Any, Any]]]: ...
+) -> tuple[NDArray[floating[Any]], NDArray[complexfloating[Any, Any]]]: ...
 
 @overload
 def svd(
@@ -159,7 +157,7 @@ def svd(
     full_matrices: bool = ...,
     compute_uv: L[True] = ...,
     hermitian: bool = ...,
-) -> Tuple[
+) -> tuple[
     NDArray[float64],
     NDArray[float64],
     NDArray[float64],
@@ -170,7 +168,7 @@ def svd(
     full_matrices: bool = ...,
     compute_uv: L[True] = ...,
     hermitian: bool = ...,
-) -> Tuple[
+) -> tuple[
     NDArray[floating[Any]],
     NDArray[floating[Any]],
     NDArray[floating[Any]],
@@ -181,7 +179,7 @@ def svd(
     full_matrices: bool = ...,
     compute_uv: L[True] = ...,
     hermitian: bool = ...,
-) -> Tuple[
+) -> tuple[
     NDArray[complexfloating[Any, Any]],
     NDArray[floating[Any]],
     NDArray[complexfloating[Any, Any]],
@@ -240,21 +238,21 @@ def slogdet(a: _ArrayLikeComplex_co) -> _2Tuple[Any]: ...
 def det(a: _ArrayLikeComplex_co) -> Any: ...
 
 @overload
-def lstsq(a: _ArrayLikeInt_co, b: _ArrayLikeInt_co, rcond: None | float = ...) -> Tuple[
+def lstsq(a: _ArrayLikeInt_co, b: _ArrayLikeInt_co, rcond: None | float = ...) -> tuple[
     NDArray[float64],
     NDArray[float64],
     int32,
     NDArray[float64],
 ]: ...
 @overload
-def lstsq(a: _ArrayLikeFloat_co, b: _ArrayLikeFloat_co, rcond: None | float = ...) -> Tuple[
+def lstsq(a: _ArrayLikeFloat_co, b: _ArrayLikeFloat_co, rcond: None | float = ...) -> tuple[
     NDArray[floating[Any]],
     NDArray[floating[Any]],
     int32,
     NDArray[floating[Any]],
 ]: ...
 @overload
-def lstsq(a: _ArrayLikeComplex_co, b: _ArrayLikeComplex_co, rcond: None | float = ...) -> Tuple[
+def lstsq(a: _ArrayLikeComplex_co, b: _ArrayLikeComplex_co, rcond: None | float = ...) -> tuple[
     NDArray[complexfloating[Any, Any]],
     NDArray[floating[Any]],
     int32,
@@ -272,7 +270,7 @@ def norm(
 def norm(
     x: ArrayLike,
     ord: None | float | L["fro", "nuc"] = ...,
-    axis: SupportsInt | SupportsIndex | Tuple[int, ...] = ...,
+    axis: SupportsInt | SupportsIndex | tuple[int, ...] = ...,
     keepdims: bool = ...,
 ) -> Any: ...
 
diff --git a/numpy/linalg/setup.py b/numpy/linalg/setup.py
index 94536bb2c055..1c4e1295e3cf 100644
--- a/numpy/linalg/setup.py
+++ b/numpy/linalg/setup.py
@@ -1,8 +1,10 @@
 import os
 import sys
+import sysconfig
 
 def configuration(parent_package='', top_path=None):
     from numpy.distutils.misc_util import Configuration
+    from numpy.distutils.ccompiler_opt import NPY_CXX_FLAGS
     from numpy.distutils.system_info import get_info, system_info
     config = Configuration('linalg', parent_package, top_path)
 
@@ -37,7 +39,14 @@ def configuration(parent_package='', top_path=None):
         class numpy_linalg_lapack_lite(system_info):
             def calc_info(self):
                 info = {'language': 'c'}
-                if sys.maxsize > 2**32:
+                size_t_size = sysconfig.get_config_var("SIZEOF_SIZE_T")
+                if size_t_size:
+                    maxsize = 2**(size_t_size - 1) - 1
+                else:
+                    # We prefer using sysconfig as it allows cross-compilation
+                    # but the information may be missing (e.g. on windows).
+                    maxsize = sys.maxsize
+                if maxsize > 2**32:
                     # Build lapack-lite in 64-bit integer mode.
                     # The suffix is arbitrary (lapack_lite symbols follow it),
                     # but use the "64_" convention here.
@@ -69,9 +78,10 @@ def get_lapack_lite_sources(ext, build_dir):
     # umath_linalg module
     config.add_extension(
         '_umath_linalg',
-        sources=['umath_linalg.c.src', get_lapack_lite_sources],
+        sources=['umath_linalg.cpp', get_lapack_lite_sources],
         depends=['lapack_lite/f2c.h'],
         extra_info=lapack_info,
+        extra_cxx_compile_args=NPY_CXX_FLAGS,
         libraries=['npymath'],
     )
     config.add_data_files('*.pyi')
diff --git a/numpy/linalg/tests/test_build.py b/numpy/linalg/tests/test_build.py
deleted file mode 100644
index 868341ff298c..000000000000
--- a/numpy/linalg/tests/test_build.py
+++ /dev/null
@@ -1,53 +0,0 @@
-from subprocess import PIPE, Popen
-import sys
-import re
-import pytest
-
-from numpy.linalg import lapack_lite
-from numpy.testing import assert_
-
-
-class FindDependenciesLdd:
-
-    def __init__(self):
-        self.cmd = ['ldd']
-
-        try:
-            p = Popen(self.cmd, stdout=PIPE, stderr=PIPE)
-            stdout, stderr = p.communicate()
-        except OSError as e:
-            raise RuntimeError(f'command {self.cmd} cannot be run') from e
-
-    def get_dependencies(self, lfile):
-        p = Popen(self.cmd + [lfile], stdout=PIPE, stderr=PIPE)
-        stdout, stderr = p.communicate()
-        if not (p.returncode == 0):
-            raise RuntimeError(f'failed dependencies check for {lfile}')
-
-        return stdout
-
-    def grep_dependencies(self, lfile, deps):
-        stdout = self.get_dependencies(lfile)
-
-        rdeps = dict([(dep, re.compile(dep)) for dep in deps])
-        founds = []
-        for l in stdout.splitlines():
-            for k, v in rdeps.items():
-                if v.search(l):
-                    founds.append(k)
-
-        return founds
-
-
-class TestF77Mismatch:
-
-    @pytest.mark.skipif(not(sys.platform[:5] == 'linux'),
-                        reason="no fortran compiler on non-Linux platform")
-    def test_lapack(self):
-        f = FindDependenciesLdd()
-        deps = f.grep_dependencies(lapack_lite.__file__,
-                                   [b'libg2c', b'libgfortran'])
-        assert_(len(deps) <= 1,
-                         """Both g77 and gfortran runtimes linked in lapack_lite ! This is likely to
-cause random crashes and wrong results. See numpy INSTALL.txt for more
-information.""")
diff --git a/numpy/linalg/tests/test_linalg.py b/numpy/linalg/tests/test_linalg.py
index c1ba84a8e674..b1dbd4c2228e 100644
--- a/numpy/linalg/tests/test_linalg.py
+++ b/numpy/linalg/tests/test_linalg.py
@@ -19,7 +19,7 @@
 from numpy.testing import (
     assert_, assert_equal, assert_raises, assert_array_equal,
     assert_almost_equal, assert_allclose, suppress_warnings,
-    assert_raises_regex, HAS_LAPACK64,
+    assert_raises_regex, HAS_LAPACK64, IS_WASM
     )
 
 
@@ -1063,6 +1063,7 @@ def test_exceptions_non_square(self, dt):
         assert_raises(LinAlgError, matrix_power, np.array([[1], [2]], dt), 1)
         assert_raises(LinAlgError, matrix_power, np.ones((4, 3, 2), dt), 1)
 
+    @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm")
     def test_exceptions_not_invertible(self, dt):
         if dt in self.dtnoinv:
             return
@@ -1223,6 +1224,14 @@ class _TestNormBase:
     dt = None
     dec = None
 
+    @staticmethod
+    def check_dtype(x, res):
+        if issubclass(x.dtype.type, np.inexact):
+            assert_equal(res.dtype, x.real.dtype)
+        else:
+            # For integer input, don't have to test float precision of output.
+            assert_(issubclass(res.dtype.type, np.floating))
+
 
 class _TestNormGeneral(_TestNormBase):
 
@@ -1239,37 +1248,37 @@ def test_vector_return_type(self):
 
         all_types = exact_types + inexact_types
 
-        for each_inexact_types in all_types:
-            at = a.astype(each_inexact_types)
+        for each_type in all_types:
+            at = a.astype(each_type)
 
             an = norm(at, -np.inf)
-            assert_(issubclass(an.dtype.type, np.floating))
+            self.check_dtype(at, an)
             assert_almost_equal(an, 0.0)
 
             with suppress_warnings() as sup:
                 sup.filter(RuntimeWarning, "divide by zero encountered")
                 an = norm(at, -1)
-                assert_(issubclass(an.dtype.type, np.floating))
+                self.check_dtype(at, an)
                 assert_almost_equal(an, 0.0)
 
             an = norm(at, 0)
-            assert_(issubclass(an.dtype.type, np.floating))
+            self.check_dtype(at, an)
             assert_almost_equal(an, 2)
 
             an = norm(at, 1)
-            assert_(issubclass(an.dtype.type, np.floating))
+            self.check_dtype(at, an)
             assert_almost_equal(an, 2.0)
 
             an = norm(at, 2)
-            assert_(issubclass(an.dtype.type, np.floating))
+            self.check_dtype(at, an)
             assert_almost_equal(an, an.dtype.type(2.0)**an.dtype.type(1.0/2.0))
 
             an = norm(at, 4)
-            assert_(issubclass(an.dtype.type, np.floating))
+            self.check_dtype(at, an)
             assert_almost_equal(an, an.dtype.type(2.0)**an.dtype.type(1.0/4.0))
 
             an = norm(at, np.inf)
-            assert_(issubclass(an.dtype.type, np.floating))
+            self.check_dtype(at, an)
             assert_almost_equal(an, 1.0)
 
     def test_vector(self):
@@ -1402,41 +1411,41 @@ def test_matrix_return_type(self):
 
         all_types = exact_types + inexact_types
 
-        for each_inexact_types in all_types:
-            at = a.astype(each_inexact_types)
+        for each_type in all_types:
+            at = a.astype(each_type)
 
             an = norm(at, -np.inf)
-            assert_(issubclass(an.dtype.type, np.floating))
+            self.check_dtype(at, an)
             assert_almost_equal(an, 2.0)
 
             with suppress_warnings() as sup:
                 sup.filter(RuntimeWarning, "divide by zero encountered")
                 an = norm(at, -1)
-                assert_(issubclass(an.dtype.type, np.floating))
+                self.check_dtype(at, an)
                 assert_almost_equal(an, 1.0)
 
             an = norm(at, 1)
-            assert_(issubclass(an.dtype.type, np.floating))
+            self.check_dtype(at, an)
             assert_almost_equal(an, 2.0)
 
             an = norm(at, 2)
-            assert_(issubclass(an.dtype.type, np.floating))
+            self.check_dtype(at, an)
             assert_almost_equal(an, 3.0**(1.0/2.0))
 
             an = norm(at, -2)
-            assert_(issubclass(an.dtype.type, np.floating))
+            self.check_dtype(at, an)
             assert_almost_equal(an, 1.0)
 
             an = norm(at, np.inf)
-            assert_(issubclass(an.dtype.type, np.floating))
+            self.check_dtype(at, an)
             assert_almost_equal(an, 2.0)
 
             an = norm(at, 'fro')
-            assert_(issubclass(an.dtype.type, np.floating))
+            self.check_dtype(at, an)
             assert_almost_equal(an, 2.0)
 
             an = norm(at, 'nuc')
-            assert_(issubclass(an.dtype.type, np.floating))
+            self.check_dtype(at, an)
             # Lower bar needed to support low precision floats.
             # They end up being off by 1 in the 7th place.
             np.testing.assert_almost_equal(an, 2.7320508075688772, decimal=6)
@@ -1773,29 +1782,31 @@ def test_stacked_inputs(self, outer_size, size, dt):
 class TestCholesky:
     # TODO: are there no other tests for cholesky?
 
-    def test_basic_property(self):
+    @pytest.mark.parametrize(
+        'shape', [(1, 1), (2, 2), (3, 3), (50, 50), (3, 10, 10)]
+    )
+    @pytest.mark.parametrize(
+        'dtype', (np.float32, np.float64, np.complex64, np.complex128)
+    )
+    def test_basic_property(self, shape, dtype):
         # Check A = L L^H
-        shapes = [(1, 1), (2, 2), (3, 3), (50, 50), (3, 10, 10)]
-        dtypes = (np.float32, np.float64, np.complex64, np.complex128)
-
-        for shape, dtype in itertools.product(shapes, dtypes):
-            np.random.seed(1)
-            a = np.random.randn(*shape)
-            if np.issubdtype(dtype, np.complexfloating):
-                a = a + 1j*np.random.randn(*shape)
+        np.random.seed(1)
+        a = np.random.randn(*shape)
+        if np.issubdtype(dtype, np.complexfloating):
+            a = a + 1j*np.random.randn(*shape)
 
-            t = list(range(len(shape)))
-            t[-2:] = -1, -2
+        t = list(range(len(shape)))
+        t[-2:] = -1, -2
 
-            a = np.matmul(a.transpose(t).conj(), a)
-            a = np.asarray(a, dtype=dtype)
+        a = np.matmul(a.transpose(t).conj(), a)
+        a = np.asarray(a, dtype=dtype)
 
-            c = np.linalg.cholesky(a)
+        c = np.linalg.cholesky(a)
 
-            b = np.matmul(c, c.transpose(t).conj())
-            assert_allclose(b, a,
-                            err_msg=f'{shape} {dtype}\n{a}\n{c}',
-                            atol=500 * a.shape[0] * np.finfo(dtype).eps)
+        b = np.matmul(c, c.transpose(t).conj())
+        with np._no_nep50_warning():
+            atol = 500 * a.shape[0] * np.finfo(dtype).eps
+        assert_allclose(b, a, atol=atol, err_msg=f'{shape} {dtype}\n{a}\n{c}')
 
     def test_0_size(self):
         class ArraySubclass(np.ndarray):
@@ -1835,6 +1846,7 @@ def test_byteorder_check():
             assert_array_equal(res, routine(sw_arr))
 
 
+@pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm")
 def test_generalized_raise_multiloop():
     # It should raise an error even if the error doesn't occur in the
     # last iteration of the ufunc inner loop
@@ -1898,6 +1910,7 @@ def test_xerbla_override():
             pytest.skip('Numpy xerbla not linked in.')
 
 
+@pytest.mark.skipif(IS_WASM, reason="Cannot start subprocess")
 @pytest.mark.slow
 def test_sdot_bug_8577():
     # Regression test that loading certain other libraries does not
@@ -2103,6 +2116,27 @@ def test_tensorinv_result(self):
         assert_allclose(np.tensordot(ainv, b, 1), np.linalg.tensorsolve(a, b))
 
 
+class TestTensorsolve:
+
+    @pytest.mark.parametrize("a, axes", [
+        (np.ones((4, 6, 8, 2)), None),
+        (np.ones((3, 3, 2)), (0, 2)),
+        ])
+    def test_non_square_handling(self, a, axes):
+        with assert_raises(LinAlgError):
+            b = np.ones(a.shape[:2])
+            linalg.tensorsolve(a, b, axes=axes)
+
+    @pytest.mark.parametrize("shape",
+        [(2, 3, 6), (3, 4, 4, 3), (0, 3, 3, 0)],
+    )
+    def test_tensorsolve_result(self, shape):
+        a = np.random.randn(*shape)
+        b = np.ones(a.shape[:2])
+        x = np.linalg.tensorsolve(a, b)
+        assert_allclose(np.tensordot(a, x, axes=len(x.shape)), b)
+
+
 def test_unsupported_commontype():
     # linalg gracefully handles unsupported type
     arr = np.array([[1, -2], [2, 5]], dtype='float16')
diff --git a/numpy/linalg/umath_linalg.c.src b/numpy/linalg/umath_linalg.cpp
similarity index 64%
rename from numpy/linalg/umath_linalg.c.src
rename to numpy/linalg/umath_linalg.cpp
index ff63ea218860..639de6ee0258 100644
--- a/numpy/linalg/umath_linalg.c.src
+++ b/numpy/linalg/umath_linalg.cpp
@@ -18,14 +18,21 @@
 
 #include "npy_cblas.h"
 
-#include 
-#include 
-#include 
-#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
 
 
 static const char* umath_linalg_version_string = "0.1.5";
 
+struct scalar_trait {};
+struct complex_trait {};
+template
+using dispatch_scalar = typename std::conditional::value, scalar_trait, complex_trait>::type;
+
 /*
  ****************************************************************************
  *                        Debugging support                                 *
@@ -44,7 +51,11 @@ static const char* umath_linalg_version_string = "0.1.5";
     } while (0)
 
 #if 0
+#if defined HAVE_EXECINFO_H
 #include 
+#elif defined HAVE_LIBUNWIND_H
+#include 
+#endif
 void
 dbg_stack_trace()
 {
@@ -78,28 +89,28 @@ typedef double            fortran_doublereal;
 typedef f2c_complex       fortran_complex;
 typedef f2c_doublecomplex fortran_doublecomplex;
 
-extern fortran_int
+extern "C" fortran_int
 FNAME(sgeev)(char *jobvl, char *jobvr, fortran_int *n,
              float a[], fortran_int *lda, float wr[], float wi[],
              float vl[], fortran_int *ldvl, float vr[], fortran_int *ldvr,
              float work[], fortran_int lwork[],
              fortran_int *info);
-extern fortran_int
+extern "C" fortran_int
 FNAME(dgeev)(char *jobvl, char *jobvr, fortran_int *n,
              double a[], fortran_int *lda, double wr[], double wi[],
              double vl[], fortran_int *ldvl, double vr[], fortran_int *ldvr,
              double work[], fortran_int lwork[],
              fortran_int *info);
-extern fortran_int
+extern "C" fortran_int
 FNAME(cgeev)(char *jobvl, char *jobvr, fortran_int *n,
-             f2c_doublecomplex a[], fortran_int *lda,
-             f2c_doublecomplex w[],
-             f2c_doublecomplex vl[], fortran_int *ldvl,
-             f2c_doublecomplex vr[], fortran_int *ldvr,
-             f2c_doublecomplex work[], fortran_int *lwork,
-             double rwork[],
+             f2c_complex a[], fortran_int *lda,
+             f2c_complex w[],
+             f2c_complex vl[], fortran_int *ldvl,
+             f2c_complex vr[], fortran_int *ldvr,
+             f2c_complex work[], fortran_int *lwork,
+             float rwork[],
              fortran_int *info);
-extern fortran_int
+extern "C" fortran_int
 FNAME(zgeev)(char *jobvl, char *jobvr, fortran_int *n,
              f2c_doublecomplex a[], fortran_int *lda,
              f2c_doublecomplex w[],
@@ -109,24 +120,24 @@ FNAME(zgeev)(char *jobvl, char *jobvr, fortran_int *n,
              double rwork[],
              fortran_int *info);
 
-extern fortran_int
+extern "C" fortran_int
 FNAME(ssyevd)(char *jobz, char *uplo, fortran_int *n,
               float a[], fortran_int *lda, float w[], float work[],
               fortran_int *lwork, fortran_int iwork[], fortran_int *liwork,
               fortran_int *info);
-extern fortran_int
+extern "C" fortran_int
 FNAME(dsyevd)(char *jobz, char *uplo, fortran_int *n,
               double a[], fortran_int *lda, double w[], double work[],
               fortran_int *lwork, fortran_int iwork[], fortran_int *liwork,
               fortran_int *info);
-extern fortran_int
+extern "C" fortran_int
 FNAME(cheevd)(char *jobz, char *uplo, fortran_int *n,
               f2c_complex a[], fortran_int *lda,
               float w[], f2c_complex work[],
               fortran_int *lwork, float rwork[], fortran_int *lrwork, fortran_int iwork[],
               fortran_int *liwork,
               fortran_int *info);
-extern fortran_int
+extern "C" fortran_int
 FNAME(zheevd)(char *jobz, char *uplo, fortran_int *n,
               f2c_doublecomplex a[], fortran_int *lda,
               double w[], f2c_doublecomplex work[],
@@ -134,19 +145,19 @@ FNAME(zheevd)(char *jobz, char *uplo, fortran_int *n,
               fortran_int *liwork,
               fortran_int *info);
 
-extern fortran_int
+extern "C" fortran_int
 FNAME(sgelsd)(fortran_int *m, fortran_int *n, fortran_int *nrhs,
               float a[], fortran_int *lda, float b[], fortran_int *ldb,
               float s[], float *rcond, fortran_int *rank,
               float work[], fortran_int *lwork, fortran_int iwork[],
               fortran_int *info);
-extern fortran_int
+extern "C" fortran_int
 FNAME(dgelsd)(fortran_int *m, fortran_int *n, fortran_int *nrhs,
               double a[], fortran_int *lda, double b[], fortran_int *ldb,
               double s[], double *rcond, fortran_int *rank,
               double work[], fortran_int *lwork, fortran_int iwork[],
               fortran_int *info);
-extern fortran_int
+extern "C" fortran_int
 FNAME(cgelsd)(fortran_int *m, fortran_int *n, fortran_int *nrhs,
               f2c_complex a[], fortran_int *lda,
               f2c_complex b[], fortran_int *ldb,
@@ -154,7 +165,7 @@ FNAME(cgelsd)(fortran_int *m, fortran_int *n, fortran_int *nrhs,
               f2c_complex work[], fortran_int *lwork,
               float rwork[], fortran_int iwork[],
               fortran_int *info);
-extern fortran_int
+extern "C" fortran_int
 FNAME(zgelsd)(fortran_int *m, fortran_int *n, fortran_int *nrhs,
               f2c_doublecomplex a[], fortran_int *lda,
               f2c_doublecomplex b[], fortran_int *ldb,
@@ -163,105 +174,105 @@ FNAME(zgelsd)(fortran_int *m, fortran_int *n, fortran_int *nrhs,
               double rwork[], fortran_int iwork[],
               fortran_int *info);
 
-extern fortran_int
+extern "C" fortran_int
 FNAME(dgeqrf)(fortran_int *m, fortran_int *n, double a[], fortran_int *lda,
               double tau[], double work[],
               fortran_int *lwork, fortran_int *info);
-extern fortran_int
+extern "C" fortran_int
 FNAME(zgeqrf)(fortran_int *m, fortran_int *n, f2c_doublecomplex a[], fortran_int *lda,
               f2c_doublecomplex tau[], f2c_doublecomplex work[],
               fortran_int *lwork, fortran_int *info);
 
-extern fortran_int
+extern "C" fortran_int
 FNAME(dorgqr)(fortran_int *m, fortran_int *n, fortran_int *k, double a[], fortran_int *lda,
               double tau[], double work[],
               fortran_int *lwork, fortran_int *info);
-extern fortran_int
+extern "C" fortran_int
 FNAME(zungqr)(fortran_int *m, fortran_int *n, fortran_int *k, f2c_doublecomplex a[],
               fortran_int *lda, f2c_doublecomplex tau[],
               f2c_doublecomplex work[], fortran_int *lwork, fortran_int *info);
 
-extern fortran_int
+extern "C" fortran_int
 FNAME(sgesv)(fortran_int *n, fortran_int *nrhs,
              float a[], fortran_int *lda,
              fortran_int ipiv[],
              float b[], fortran_int *ldb,
              fortran_int *info);
-extern fortran_int
+extern "C" fortran_int
 FNAME(dgesv)(fortran_int *n, fortran_int *nrhs,
              double a[], fortran_int *lda,
              fortran_int ipiv[],
              double b[], fortran_int *ldb,
              fortran_int *info);
-extern fortran_int
+extern "C" fortran_int
 FNAME(cgesv)(fortran_int *n, fortran_int *nrhs,
              f2c_complex a[], fortran_int *lda,
              fortran_int ipiv[],
              f2c_complex b[], fortran_int *ldb,
              fortran_int *info);
-extern fortran_int
+extern "C" fortran_int
 FNAME(zgesv)(fortran_int *n, fortran_int *nrhs,
              f2c_doublecomplex a[], fortran_int *lda,
              fortran_int ipiv[],
              f2c_doublecomplex b[], fortran_int *ldb,
              fortran_int *info);
 
-extern fortran_int
+extern "C" fortran_int
 FNAME(sgetrf)(fortran_int *m, fortran_int *n,
               float a[], fortran_int *lda,
               fortran_int ipiv[],
               fortran_int *info);
-extern fortran_int
+extern "C" fortran_int
 FNAME(dgetrf)(fortran_int *m, fortran_int *n,
               double a[], fortran_int *lda,
               fortran_int ipiv[],
               fortran_int *info);
-extern fortran_int
+extern "C" fortran_int
 FNAME(cgetrf)(fortran_int *m, fortran_int *n,
               f2c_complex a[], fortran_int *lda,
               fortran_int ipiv[],
               fortran_int *info);
-extern fortran_int
+extern "C" fortran_int
 FNAME(zgetrf)(fortran_int *m, fortran_int *n,
               f2c_doublecomplex a[], fortran_int *lda,
               fortran_int ipiv[],
               fortran_int *info);
 
-extern fortran_int
+extern "C" fortran_int
 FNAME(spotrf)(char *uplo, fortran_int *n,
               float a[], fortran_int *lda,
               fortran_int *info);
-extern fortran_int
+extern "C" fortran_int
 FNAME(dpotrf)(char *uplo, fortran_int *n,
               double a[], fortran_int *lda,
               fortran_int *info);
-extern fortran_int
+extern "C" fortran_int
 FNAME(cpotrf)(char *uplo, fortran_int *n,
               f2c_complex a[], fortran_int *lda,
               fortran_int *info);
-extern fortran_int
+extern "C" fortran_int
 FNAME(zpotrf)(char *uplo, fortran_int *n,
               f2c_doublecomplex a[], fortran_int *lda,
               fortran_int *info);
 
-extern fortran_int
+extern "C" fortran_int
 FNAME(sgesdd)(char *jobz, fortran_int *m, fortran_int *n,
               float a[], fortran_int *lda, float s[], float u[],
               fortran_int *ldu, float vt[], fortran_int *ldvt, float work[],
               fortran_int *lwork, fortran_int iwork[], fortran_int *info);
-extern fortran_int
+extern "C" fortran_int
 FNAME(dgesdd)(char *jobz, fortran_int *m, fortran_int *n,
               double a[], fortran_int *lda, double s[], double u[],
               fortran_int *ldu, double vt[], fortran_int *ldvt, double work[],
               fortran_int *lwork, fortran_int iwork[], fortran_int *info);
-extern fortran_int
+extern "C" fortran_int
 FNAME(cgesdd)(char *jobz, fortran_int *m, fortran_int *n,
               f2c_complex a[], fortran_int *lda,
               float s[], f2c_complex u[], fortran_int *ldu,
               f2c_complex vt[], fortran_int *ldvt,
               f2c_complex work[], fortran_int *lwork,
               float rwork[], fortran_int iwork[], fortran_int *info);
-extern fortran_int
+extern "C" fortran_int
 FNAME(zgesdd)(char *jobz, fortran_int *m, fortran_int *n,
               f2c_doublecomplex a[], fortran_int *lda,
               double s[], f2c_doublecomplex u[], fortran_int *ldu,
@@ -269,87 +280,87 @@ FNAME(zgesdd)(char *jobz, fortran_int *m, fortran_int *n,
               f2c_doublecomplex work[], fortran_int *lwork,
               double rwork[], fortran_int iwork[], fortran_int *info);
 
-extern fortran_int
+extern "C" fortran_int
 FNAME(spotrs)(char *uplo, fortran_int *n, fortran_int *nrhs,
               float a[], fortran_int *lda,
               float b[], fortran_int *ldb,
               fortran_int *info);
-extern fortran_int
+extern "C" fortran_int
 FNAME(dpotrs)(char *uplo, fortran_int *n, fortran_int *nrhs,
               double a[], fortran_int *lda,
               double b[], fortran_int *ldb,
               fortran_int *info);
-extern fortran_int
+extern "C" fortran_int
 FNAME(cpotrs)(char *uplo, fortran_int *n, fortran_int *nrhs,
               f2c_complex a[], fortran_int *lda,
               f2c_complex b[], fortran_int *ldb,
               fortran_int *info);
-extern fortran_int
+extern "C" fortran_int
 FNAME(zpotrs)(char *uplo, fortran_int *n, fortran_int *nrhs,
               f2c_doublecomplex a[], fortran_int *lda,
               f2c_doublecomplex b[], fortran_int *ldb,
               fortran_int *info);
 
-extern fortran_int
+extern "C" fortran_int
 FNAME(spotri)(char *uplo, fortran_int *n,
               float a[], fortran_int *lda,
               fortran_int *info);
-extern fortran_int
+extern "C" fortran_int
 FNAME(dpotri)(char *uplo, fortran_int *n,
               double a[], fortran_int *lda,
               fortran_int *info);
-extern fortran_int
+extern "C" fortran_int
 FNAME(cpotri)(char *uplo, fortran_int *n,
               f2c_complex a[], fortran_int *lda,
               fortran_int *info);
-extern fortran_int
+extern "C" fortran_int
 FNAME(zpotri)(char *uplo, fortran_int *n,
               f2c_doublecomplex a[], fortran_int *lda,
               fortran_int *info);
 
-extern fortran_int
+extern "C" fortran_int
 FNAME(scopy)(fortran_int *n,
              float *sx, fortran_int *incx,
              float *sy, fortran_int *incy);
-extern fortran_int
+extern "C" fortran_int
 FNAME(dcopy)(fortran_int *n,
              double *sx, fortran_int *incx,
              double *sy, fortran_int *incy);
-extern fortran_int
+extern "C" fortran_int
 FNAME(ccopy)(fortran_int *n,
              f2c_complex *sx, fortran_int *incx,
              f2c_complex *sy, fortran_int *incy);
-extern fortran_int
+extern "C" fortran_int
 FNAME(zcopy)(fortran_int *n,
              f2c_doublecomplex *sx, fortran_int *incx,
              f2c_doublecomplex *sy, fortran_int *incy);
 
-extern float
+extern "C" float
 FNAME(sdot)(fortran_int *n,
             float *sx, fortran_int *incx,
             float *sy, fortran_int *incy);
-extern double
+extern "C" double
 FNAME(ddot)(fortran_int *n,
             double *sx, fortran_int *incx,
             double *sy, fortran_int *incy);
-extern void
+extern "C" void
 FNAME(cdotu)(f2c_complex *ret, fortran_int *n,
              f2c_complex *sx, fortran_int *incx,
              f2c_complex *sy, fortran_int *incy);
-extern void
+extern "C" void
 FNAME(zdotu)(f2c_doublecomplex *ret, fortran_int *n,
              f2c_doublecomplex *sx, fortran_int *incx,
              f2c_doublecomplex *sy, fortran_int *incy);
-extern void
+extern "C" void
 FNAME(cdotc)(f2c_complex *ret, fortran_int *n,
              f2c_complex *sx, fortran_int *incx,
              f2c_complex *sy, fortran_int *incy);
-extern void
+extern "C" void
 FNAME(zdotc)(f2c_doublecomplex *ret, fortran_int *n,
              f2c_doublecomplex *sx, fortran_int *incx,
              f2c_doublecomplex *sy, fortran_int *incy);
 
-extern fortran_int
+extern "C" fortran_int
 FNAME(sgemm)(char *transa, char *transb,
              fortran_int *m, fortran_int *n, fortran_int *k,
              float *alpha,
@@ -357,7 +368,7 @@ FNAME(sgemm)(char *transa, char *transb,
              float *b, fortran_int *ldb,
              float *beta,
              float *c, fortran_int *ldc);
-extern fortran_int
+extern "C" fortran_int
 FNAME(dgemm)(char *transa, char *transb,
              fortran_int *m, fortran_int *n, fortran_int *k,
              double *alpha,
@@ -365,7 +376,7 @@ FNAME(dgemm)(char *transa, char *transb,
              double *b, fortran_int *ldb,
              double *beta,
              double *c, fortran_int *ldc);
-extern fortran_int
+extern "C" fortran_int
 FNAME(cgemm)(char *transa, char *transb,
              fortran_int *m, fortran_int *n, fortran_int *k,
              f2c_complex *alpha,
@@ -373,7 +384,7 @@ FNAME(cgemm)(char *transa, char *transb,
              f2c_complex *b, fortran_int *ldb,
              f2c_complex *beta,
              f2c_complex *c, fortran_int *ldc);
-extern fortran_int
+extern "C" fortran_int
 FNAME(zgemm)(char *transa, char *transb,
              fortran_int *m, fortran_int *n, fortran_int *k,
              f2c_doublecomplex *alpha,
@@ -400,7 +411,7 @@ FNAME(zgemm)(char *transa, char *transb,
  *****************************************************************************
  */
 
-static NPY_INLINE int
+static inline int
 get_fp_invalid_and_clear(void)
 {
     int status;
@@ -408,7 +419,7 @@ get_fp_invalid_and_clear(void)
     return !!(status & NPY_FPE_INVALID);
 }
 
-static NPY_INLINE void
+static inline void
 set_fp_invalid_or_clear(int error_occurred)
 {
     if (error_occurred) {
@@ -427,80 +438,92 @@ set_fp_invalid_or_clear(int error_occurred)
 
 #define UMATH_LINALG_MODULE_NAME "_umath_linalg"
 
-typedef union {
-    fortran_complex f;
-    npy_cfloat npy;
-    float array[2];
-} COMPLEX_t;
-
-typedef union {
-    fortran_doublecomplex f;
-    npy_cdouble npy;
-    double array[2];
-} DOUBLECOMPLEX_t;
-
-static float s_one;
-static float s_zero;
-static float s_minus_one;
-static float s_ninf;
-static float s_nan;
-static double d_one;
-static double d_zero;
-static double d_minus_one;
-static double d_ninf;
-static double d_nan;
-static COMPLEX_t c_one;
-static COMPLEX_t c_zero;
-static COMPLEX_t c_minus_one;
-static COMPLEX_t c_ninf;
-static COMPLEX_t c_nan;
-static DOUBLECOMPLEX_t z_one;
-static DOUBLECOMPLEX_t z_zero;
-static DOUBLECOMPLEX_t z_minus_one;
-static DOUBLECOMPLEX_t z_ninf;
-static DOUBLECOMPLEX_t z_nan;
-
-static void init_constants(void)
-{
-    /*
-       this is needed as NPY_INFINITY and NPY_NAN macros
-       can't be used as initializers. I prefer to just set
-       all the constants the same way.
-    */
-    s_one  = 1.0f;
-    s_zero = 0.0f;
-    s_minus_one = -1.0f;
-    s_ninf = -NPY_INFINITYF;
-    s_nan = NPY_NANF;
-
-    d_one  = 1.0;
-    d_zero = 0.0;
-    d_minus_one = -1.0;
-    d_ninf = -NPY_INFINITY;
-    d_nan = NPY_NAN;
-
-    c_one.array[0]  = 1.0f;
-    c_one.array[1]  = 0.0f;
-    c_zero.array[0] = 0.0f;
-    c_zero.array[1] = 0.0f;
-    c_minus_one.array[0] = -1.0f;
-    c_minus_one.array[1] = 0.0f;
-    c_ninf.array[0] = -NPY_INFINITYF;
-    c_ninf.array[1] = 0.0f;
-    c_nan.array[0] = NPY_NANF;
-    c_nan.array[1] = NPY_NANF;
-
-    z_one.array[0]  = 1.0;
-    z_one.array[1]  = 0.0;
-    z_zero.array[0] = 0.0;
-    z_zero.array[1] = 0.0;
-    z_minus_one.array[0] = -1.0;
-    z_minus_one.array[1] = 0.0;
-    z_ninf.array[0] = -NPY_INFINITY;
-    z_ninf.array[1] = 0.0;
-    z_nan.array[0] = NPY_NAN;
-    z_nan.array[1] = NPY_NAN;
-}
+template
+struct numeric_limits;
+
+template<>
+struct numeric_limits {
+static constexpr float one = 1.0f;
+static constexpr float zero = 0.0f;
+static constexpr float minus_one = -1.0f;
+static const float ninf;
+static const float nan;
+};
+constexpr float numeric_limits::one;
+constexpr float numeric_limits::zero;
+constexpr float numeric_limits::minus_one;
+const float numeric_limits::ninf = -NPY_INFINITYF;
+const float numeric_limits::nan = NPY_NANF;
+
+template<>
+struct numeric_limits {
+static constexpr double one = 1.0;
+static constexpr double zero = 0.0;
+static constexpr double minus_one = -1.0;
+static const double ninf;
+static const double nan;
+};
+constexpr double numeric_limits::one;
+constexpr double numeric_limits::zero;
+constexpr double numeric_limits::minus_one;
+const double numeric_limits::ninf = -NPY_INFINITY;
+const double numeric_limits::nan = NPY_NAN;
+
+template<>
+struct numeric_limits {
+static constexpr npy_cfloat one = {1.0f, 0.0f};
+static constexpr npy_cfloat zero = {0.0f, 0.0f};
+static constexpr npy_cfloat minus_one = {-1.0f, 0.0f};
+static const npy_cfloat ninf;
+static const npy_cfloat nan;
+};
+constexpr npy_cfloat numeric_limits::one;
+constexpr npy_cfloat numeric_limits::zero;
+constexpr npy_cfloat numeric_limits::minus_one;
+const npy_cfloat numeric_limits::ninf = {-NPY_INFINITYF, 0.0f};
+const npy_cfloat numeric_limits::nan = {NPY_NANF, NPY_NANF};
+
+template<>
+struct numeric_limits {
+static constexpr f2c_complex one = {1.0f, 0.0f};
+static constexpr f2c_complex zero = {0.0f, 0.0f};
+static constexpr f2c_complex minus_one = {-1.0f, 0.0f};
+static const f2c_complex ninf;
+static const f2c_complex nan;
+};
+constexpr f2c_complex numeric_limits::one;
+constexpr f2c_complex numeric_limits::zero;
+constexpr f2c_complex numeric_limits::minus_one;
+const f2c_complex numeric_limits::ninf = {-NPY_INFINITYF, 0.0f};
+const f2c_complex numeric_limits::nan = {NPY_NANF, NPY_NANF};
+
+template<>
+struct numeric_limits {
+static constexpr npy_cdouble one = {1.0, 0.0};
+static constexpr npy_cdouble zero = {0.0, 0.0};
+static constexpr npy_cdouble minus_one = {-1.0, 0.0};
+static const npy_cdouble ninf;
+static const npy_cdouble nan;
+};
+constexpr npy_cdouble numeric_limits::one;
+constexpr npy_cdouble numeric_limits::zero;
+constexpr npy_cdouble numeric_limits::minus_one;
+const npy_cdouble numeric_limits::ninf = {-NPY_INFINITY, 0.0};
+const npy_cdouble numeric_limits::nan = {NPY_NAN, NPY_NAN};
+
+template<>
+struct numeric_limits {
+static constexpr f2c_doublecomplex one = {1.0, 0.0};
+static constexpr f2c_doublecomplex zero = {0.0, 0.0};
+static constexpr f2c_doublecomplex minus_one = {-1.0, 0.0};
+static const f2c_doublecomplex ninf;
+static const f2c_doublecomplex nan;
+};
+constexpr f2c_doublecomplex numeric_limits::one;
+constexpr f2c_doublecomplex numeric_limits::zero;
+constexpr f2c_doublecomplex numeric_limits::minus_one;
+const f2c_doublecomplex numeric_limits::ninf = {-NPY_INFINITY, 0.0};
+const f2c_doublecomplex numeric_limits::nan = {NPY_NAN, NPY_NAN};
 
 /*
  *****************************************************************************
@@ -529,7 +552,7 @@ typedef struct linearize_data_struct
   npy_intp output_lead_dim;
 } LINEARIZE_DATA_t;
 
-static NPY_INLINE void
+static inline void
 init_linearize_data_ex(LINEARIZE_DATA_t *lin_data,
                        npy_intp rows,
                        npy_intp columns,
@@ -544,7 +567,7 @@ init_linearize_data_ex(LINEARIZE_DATA_t *lin_data,
     lin_data->output_lead_dim = output_lead_dim;
 }
 
-static NPY_INLINE void
+static inline void
 init_linearize_data(LINEARIZE_DATA_t *lin_data,
                     npy_intp rows,
                     npy_intp columns,
@@ -555,7 +578,7 @@ init_linearize_data(LINEARIZE_DATA_t *lin_data,
         lin_data, rows, columns, row_strides, column_strides, columns);
 }
 
-static NPY_INLINE void
+static inline void
 dump_ufunc_object(PyUFuncObject* ufunc)
 {
     TRACE_TXT("\n\n%s '%s' (%d input(s), %d output(s), %d specialization(s).\n",
@@ -580,7 +603,7 @@ dump_ufunc_object(PyUFuncObject* ufunc)
     }
 }
 
-static NPY_INLINE void
+static inline void
 dump_linearize_data(const char* name, const LINEARIZE_DATA_t* params)
 {
     TRACE_TXT("\n\t%s rows: %zd columns: %zd"\
@@ -589,37 +612,34 @@ dump_linearize_data(const char* name, const LINEARIZE_DATA_t* params)
               params->row_strides, params->column_strides);
 }
 
-static NPY_INLINE void
-print_FLOAT(npy_float s)
+static inline void
+print(npy_float s)
 {
     TRACE_TXT(" %8.4f", s);
 }
-static NPY_INLINE void
-print_DOUBLE(npy_double d)
+static inline void
+print(npy_double d)
 {
     TRACE_TXT(" %10.6f", d);
 }
-static NPY_INLINE void
-print_CFLOAT(npy_cfloat c)
+static inline void
+print(npy_cfloat c)
 {
     float* c_parts = (float*)&c;
     TRACE_TXT("(%8.4f, %8.4fj)", c_parts[0], c_parts[1]);
 }
-static NPY_INLINE void
-print_CDOUBLE(npy_cdouble z)
+static inline void
+print(npy_cdouble z)
 {
     double* z_parts = (double*)&z;
     TRACE_TXT("(%8.4f, %8.4fj)", z_parts[0], z_parts[1]);
 }
 
-/**begin repeat
-   #TYPE = FLOAT, DOUBLE, CFLOAT, CDOUBLE#
-   #typ = npy_float, npy_double, npy_cfloat, npy_cdouble#
- */
-static NPY_INLINE void
-dump_@TYPE@_matrix(const char* name,
+template
+static inline void
+dump_matrix(const char* name,
                    size_t rows, size_t columns,
-                   const @typ@* ptr)
+                  const typ* ptr)
 {
     size_t i, j;
 
@@ -629,13 +649,12 @@ dump_@TYPE@_matrix(const char* name,
         TRACE_TXT("| ");
         for (j = 0; j < columns; j++)
         {
-            print_@TYPE@(ptr[j*rows + i]);
+            print(ptr[j*rows + i]);
             TRACE_TXT(", ");
         }
         TRACE_TXT(" |\n");
     }
 }
-/**end repeat**/
 
 
 /*
@@ -644,12 +663,12 @@ dump_@TYPE@_matrix(const char* name,
  *****************************************************************************
  */
 
-static NPY_INLINE fortran_int
+static inline fortran_int
 fortran_int_min(fortran_int x, fortran_int y) {
     return x < y ? x : y;
 }
 
-static NPY_INLINE fortran_int
+static inline fortran_int
 fortran_int_max(fortran_int x, fortran_int y) {
     return x > y ? x : y;
 }
@@ -736,7 +755,7 @@ fortran_int_max(fortran_int x, fortran_int y) {
 
 #define END_OUTER_LOOP  }
 
-static NPY_INLINE void
+static inline void
 update_pointers(npy_uint8** bases, ptrdiff_t* offsets, size_t count)
 {
     size_t i;
@@ -752,47 +771,102 @@ update_pointers(npy_uint8** bases, ptrdiff_t* offsets, size_t count)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
 
+/*
+ *****************************************************************************
+ **                             DISPATCHER FUNCS                            **
+ *****************************************************************************
+ */
+static fortran_int copy(fortran_int *n,
+        float *sx, fortran_int *incx,
+        float *sy, fortran_int *incy) { return FNAME(scopy)(n, sx, incx,
+            sy, incy);
+}
+static fortran_int copy(fortran_int *n,
+        double *sx, fortran_int *incx,
+        double *sy, fortran_int *incy) { return FNAME(dcopy)(n, sx, incx,
+            sy, incy);
+}
+static fortran_int copy(fortran_int *n,
+        f2c_complex *sx, fortran_int *incx,
+        f2c_complex *sy, fortran_int *incy) { return FNAME(ccopy)(n, sx, incx,
+            sy, incy);
+}
+static fortran_int copy(fortran_int *n,
+        f2c_doublecomplex *sx, fortran_int *incx,
+        f2c_doublecomplex *sy, fortran_int *incy) { return FNAME(zcopy)(n, sx, incx,
+            sy, incy);
+}
+
+static fortran_int getrf(fortran_int *m, fortran_int *n, float a[], fortran_int
+*lda, fortran_int ipiv[], fortran_int *info) {
+ return LAPACK(sgetrf)(m, n, a, lda, ipiv, info);
+}
+static fortran_int getrf(fortran_int *m, fortran_int *n, double a[], fortran_int
+*lda, fortran_int ipiv[], fortran_int *info) {
+ return LAPACK(dgetrf)(m, n, a, lda, ipiv, info);
+}
+static fortran_int getrf(fortran_int *m, fortran_int *n, f2c_complex a[], fortran_int
+*lda, fortran_int ipiv[], fortran_int *info) {
+ return LAPACK(cgetrf)(m, n, a, lda, ipiv, info);
+}
+static fortran_int getrf(fortran_int *m, fortran_int *n, f2c_doublecomplex a[], fortran_int
+*lda, fortran_int ipiv[], fortran_int *info) {
+ return LAPACK(zgetrf)(m, n, a, lda, ipiv, info);
+}
+
 /*
  *****************************************************************************
  **                             HELPER FUNCS                                **
  *****************************************************************************
  */
+template
+struct fortran_type {
+using type = T;
+};
+
+template<> struct fortran_type { using type = f2c_complex;};
+template<> struct fortran_type { using type = f2c_doublecomplex;};
+template
+using fortran_type_t = typename fortran_type::type;
+
+template
+struct basetype {
+using type = T;
+};
+template<> struct basetype { using type = npy_float;};
+template<> struct basetype { using type = npy_double;};
+template<> struct basetype { using type = fortran_real;};
+template<> struct basetype { using type = fortran_doublereal;};
+template
+using basetype_t = typename basetype::type;
 
              /* rearranging of 2D matrices using blas */
 
-/**begin repeat
-    #TYPE = FLOAT, DOUBLE, CFLOAT, CDOUBLE#
-    #typ = float, double, COMPLEX_t, DOUBLECOMPLEX_t#
-    #copy = scopy, dcopy, ccopy, zcopy#
-    #nan = s_nan, d_nan, c_nan, z_nan#
-    #zero = s_zero, d_zero, c_zero, z_zero#
- */
-static NPY_INLINE void *
-linearize_@TYPE@_matrix(void *dst_in,
-                        void *src_in,
+template
+static inline void *
+linearize_matrix(typ *dst,
+                        typ *src,
                         const LINEARIZE_DATA_t* data)
 {
-    @typ@ *src = (@typ@ *) src_in;
-    @typ@ *dst = (@typ@ *) dst_in;
-
+    using ftyp = fortran_type_t;
     if (dst) {
         int i, j;
-        @typ@* rv = dst;
+        typ* rv = dst;
         fortran_int columns = (fortran_int)data->columns;
         fortran_int column_strides =
-            (fortran_int)(data->column_strides/sizeof(@typ@));
+            (fortran_int)(data->column_strides/sizeof(typ));
         fortran_int one = 1;
         for (i = 0; i < data->rows; i++) {
             if (column_strides > 0) {
-                FNAME(@copy@)(&columns,
-                              (void*)src, &column_strides,
-                              (void*)dst, &one);
+                copy(&columns,
+                              (ftyp*)src, &column_strides,
+                              (ftyp*)dst, &one);
             }
             else if (column_strides < 0) {
-                FNAME(@copy@)(&columns,
-                              (void*)((@typ@*)src + (columns-1)*column_strides),
+                copy(&columns,
+                              ((ftyp*)src + (columns-1)*column_strides),
                               &column_strides,
-                              (void*)dst, &one);
+                              (ftyp*)dst, &one);
             }
             else {
                 /*
@@ -801,10 +875,10 @@ linearize_@TYPE@_matrix(void *dst_in,
                  * manually
                  */
                 for (j = 0; j < columns; ++j) {
-                    memcpy((@typ@*)dst + j, (@typ@*)src, sizeof(@typ@));
+                    memcpy(dst + j, src, sizeof(typ));
                 }
             }
-            src += data->row_strides/sizeof(@typ@);
+            src += data->row_strides/sizeof(typ);
             dst += data->output_lead_dim;
         }
         return rv;
@@ -813,31 +887,31 @@ linearize_@TYPE@_matrix(void *dst_in,
     }
 }
 
-static NPY_INLINE void *
-delinearize_@TYPE@_matrix(void *dst_in,
-                          void *src_in,
+template
+static inline void *
+delinearize_matrix(typ *dst,
+                          typ *src,
                           const LINEARIZE_DATA_t* data)
 {
-    @typ@ *src = (@typ@ *) src_in;
-    @typ@ *dst = (@typ@ *) dst_in;
+using ftyp = fortran_type_t;
 
     if (src) {
         int i;
-        @typ@ *rv = src;
+        typ *rv = src;
         fortran_int columns = (fortran_int)data->columns;
         fortran_int column_strides =
-            (fortran_int)(data->column_strides/sizeof(@typ@));
+            (fortran_int)(data->column_strides/sizeof(typ));
         fortran_int one = 1;
         for (i = 0; i < data->rows; i++) {
             if (column_strides > 0) {
-                FNAME(@copy@)(&columns,
-                              (void*)src, &one,
-                              (void*)dst, &column_strides);
+                copy(&columns,
+                              (ftyp*)src, &one,
+                              (ftyp*)dst, &column_strides);
             }
             else if (column_strides < 0) {
-                FNAME(@copy@)(&columns,
-                              (void*)src, &one,
-                              (void*)((@typ@*)dst + (columns-1)*column_strides),
+                copy(&columns,
+                              (ftyp*)src, &one,
+                              ((ftyp*)dst + (columns-1)*column_strides),
                               &column_strides);
             }
             else {
@@ -847,13 +921,13 @@ delinearize_@TYPE@_matrix(void *dst_in,
                  * manually
                  */
                 if (columns > 0) {
-                    memcpy((@typ@*)dst,
-                           (@typ@*)src + (columns-1),
-                           sizeof(@typ@));
+                    memcpy(dst,
+                           src + (columns-1),
+                           sizeof(typ));
                 }
             }
             src += data->output_lead_dim;
-            dst += data->row_strides/sizeof(@typ@);
+            dst += data->row_strides/sizeof(typ);
         }
 
         return rv;
@@ -862,116 +936,97 @@ delinearize_@TYPE@_matrix(void *dst_in,
     }
 }
 
-static NPY_INLINE void
-nan_@TYPE@_matrix(void *dst_in, const LINEARIZE_DATA_t* data)
+template
+static inline void
+nan_matrix(typ *dst, const LINEARIZE_DATA_t* data)
 {
-    @typ@ *dst = (@typ@ *) dst_in;
-
     int i, j;
     for (i = 0; i < data->rows; i++) {
-        @typ@ *cp = dst;
-        ptrdiff_t cs = data->column_strides/sizeof(@typ@);
+        typ *cp = dst;
+        ptrdiff_t cs = data->column_strides/sizeof(typ);
         for (j = 0; j < data->columns; ++j) {
-            *cp = @nan@;
+            *cp = numeric_limits::nan;
             cp += cs;
         }
-        dst += data->row_strides/sizeof(@typ@);
+        dst += data->row_strides/sizeof(typ);
     }
 }
 
-static NPY_INLINE void
-zero_@TYPE@_matrix(void *dst_in, const LINEARIZE_DATA_t* data)
+template
+static inline void
+zero_matrix(typ *dst, const LINEARIZE_DATA_t* data)
 {
-    @typ@ *dst = (@typ@ *) dst_in;
-
     int i, j;
     for (i = 0; i < data->rows; i++) {
-        @typ@ *cp = dst;
-        ptrdiff_t cs = data->column_strides/sizeof(@typ@);
+        typ *cp = dst;
+        ptrdiff_t cs = data->column_strides/sizeof(typ);
         for (j = 0; j < data->columns; ++j) {
-            *cp = @zero@;
+            *cp = numeric_limits::zero;
             cp += cs;
         }
-        dst += data->row_strides/sizeof(@typ@);
+        dst += data->row_strides/sizeof(typ);
     }
 }
 
-/**end repeat**/
-
                /* identity square matrix generation */
-/**begin repeat
-   #TYPE = FLOAT, DOUBLE, CFLOAT, CDOUBLE#
-   #typ = float, double, COMPLEX_t, DOUBLECOMPLEX_t#
-   #cblas_type = s, d, c, z#
- */
-static NPY_INLINE void
-identity_@TYPE@_matrix(void *ptr, size_t n)
+template
+static inline void
+identity_matrix(typ *matrix, size_t n)
 {
     size_t i;
-    @typ@ *matrix = (@typ@*) ptr;
     /* in IEEE floating point, zeroes are represented as bitwise 0 */
-    memset(matrix, 0, n*n*sizeof(@typ@));
+    memset(matrix, 0, n*n*sizeof(typ));
 
     for (i = 0; i < n; ++i)
     {
-        *matrix = @cblas_type@_one;
+        *matrix = numeric_limits::one;
         matrix += n+1;
     }
 }
-/**end repeat**/
 
          /* lower/upper triangular matrix using blas (in place) */
-/**begin repeat
-
-   #TYPE = FLOAT, DOUBLE, CFLOAT, CDOUBLE#
-   #typ = float, double, COMPLEX_t, DOUBLECOMPLEX_t#
-   #cblas_type = s, d, c, z#
- */
 
-static NPY_INLINE void
-triu_@TYPE@_matrix(void *ptr, size_t n)
+template
+static inline void
+triu_matrix(typ *matrix, size_t n)
 {
     size_t i, j;
-    @typ@ *matrix = (@typ@*)ptr;
     matrix += n;
     for (i = 1; i < n; ++i) {
         for (j = 0; j < i; ++j) {
-            matrix[j] = @cblas_type@_zero;
+            matrix[j] = numeric_limits::zero;
         }
         matrix += n;
     }
 }
-/**end repeat**/
 
 
 /* -------------------------------------------------------------------------- */
                           /* Determinants */
 
-/**begin repeat
-   #TYPE = FLOAT, DOUBLE#
-   #typ = npy_float, npy_double#
-   #log_func = npy_logf, npy_log#
-   #exp_func = npy_expf, npy_exp#
-   #zero = 0.0f, 0.0#
-*/
+static npy_float npylog(npy_float f) { return npy_logf(f);}
+static npy_double npylog(npy_double d) { return npy_log(d);}
+static npy_float npyexp(npy_float f) { return npy_expf(f);}
+static npy_double npyexp(npy_double d) { return npy_exp(d);}
 
-static NPY_INLINE void
-@TYPE@_slogdet_from_factored_diagonal(@typ@* src,
+template
+static inline void
+slogdet_from_factored_diagonal(typ* src,
                                       fortran_int m,
-                                      @typ@ *sign,
-                                      @typ@ *logdet)
+                                      typ *sign,
+                                      typ *logdet)
 {
-    @typ@ acc_sign = *sign;
-    @typ@ acc_logdet = @zero@;
+    typ acc_sign = *sign;
+    typ acc_logdet = numeric_limits::zero;
     int i;
     for (i = 0; i < m; i++) {
-        @typ@ abs_element = *src;
-        if (abs_element < @zero@) {
+        typ abs_element = *src;
+        if (abs_element < numeric_limits::zero) {
             acc_sign = -acc_sign;
             abs_element = -abs_element;
         }
 
-        acc_logdet += @log_func@(abs_element);
+        acc_logdet += npylog(abs_element);
         src += m+1;
     }
 
@@ -979,32 +1034,26 @@ static NPY_INLINE void
     *logdet = acc_logdet;
 }
 
-static NPY_INLINE @typ@
-@TYPE@_det_from_slogdet(@typ@ sign, @typ@ logdet)
+template
+static inline typ
+det_from_slogdet(typ sign, typ logdet)
 {
-    @typ@ result = sign * @exp_func@(logdet);
+    typ result = sign * npyexp(logdet);
     return result;
 }
 
-/**end repeat**/
 
+npy_float npyabs(npy_cfloat z) { return npy_cabsf(z);}
+npy_double npyabs(npy_cdouble z) { return npy_cabs(z);}
 
-/**begin repeat
-   #TYPE = CFLOAT, CDOUBLE#
-   #typ = npy_cfloat, npy_cdouble#
-   #basetyp = npy_float, npy_double#
-   #abs_func = npy_cabsf, npy_cabs#
-   #log_func = npy_logf, npy_log#
-   #exp_func = npy_expf, npy_exp#
-   #zero = 0.0f, 0.0#
-*/
-#define RE(COMPLEX) (((@basetyp@*)(&COMPLEX))[0])
-#define IM(COMPLEX) (((@basetyp@*)(&COMPLEX))[1])
+#define RE(COMPLEX) (COMPLEX).real
+#define IM(COMPLEX) (COMPLEX).imag
 
-static NPY_INLINE @typ@
-@TYPE@_mult(@typ@ op1, @typ@ op2)
+template
+static inline typ
+mult(typ op1, typ op2)
 {
-    @typ@ rv;
+    typ rv;
 
     RE(rv) = RE(op1)*RE(op2) - IM(op1)*IM(op2);
     IM(rv) = RE(op1)*IM(op2) + IM(op1)*RE(op2);
@@ -1013,25 +1062,26 @@ static NPY_INLINE @typ@
 }
 
 
-static NPY_INLINE void
-@TYPE@_slogdet_from_factored_diagonal(@typ@* src,
+template
+static inline void
+slogdet_from_factored_diagonal(typ* src,
                                       fortran_int m,
-                                      @typ@ *sign,
-                                      @basetyp@ *logdet)
+                                      typ *sign,
+                                      basetyp *logdet)
 {
     int i;
-    @typ@ sign_acc = *sign;
-    @basetyp@ logdet_acc = @zero@;
+    typ sign_acc = *sign;
+    basetyp logdet_acc = numeric_limits::zero;
 
     for (i = 0; i < m; i++)
     {
-        @basetyp@ abs_element = @abs_func@(*src);
-        @typ@ sign_element;
+        basetyp abs_element = npyabs(*src);
+        typ sign_element;
         RE(sign_element) = RE(*src) / abs_element;
         IM(sign_element) = IM(*src) / abs_element;
 
-        sign_acc = @TYPE@_mult(sign_acc, sign_element);
-        logdet_acc += @log_func@(abs_element);
+        sign_acc = mult(sign_acc, sign_element);
+        logdet_acc += npylog(abs_element);
         src += m + 1;
     }
 
@@ -1039,17 +1089,17 @@ static NPY_INLINE void
     *logdet = logdet_acc;
 }
 
-static NPY_INLINE @typ@
-@TYPE@_det_from_slogdet(@typ@ sign, @basetyp@ logdet)
+template
+static inline typ
+det_from_slogdet(typ sign, basetyp logdet)
 {
-    @typ@ tmp;
-    RE(tmp) = @exp_func@(logdet);
-    IM(tmp) = @zero@;
-    return @TYPE@_mult(sign, tmp);
+    typ tmp;
+    RE(tmp) = npyexp(logdet);
+    IM(tmp) = numeric_limits::zero;
+    return mult(sign, tmp);
 }
 #undef RE
 #undef IM
-/**end repeat**/
 
 
 /* As in the linalg package, the determinant is computed via LU factorization
@@ -1057,26 +1107,20 @@ static NPY_INLINE @typ@
  * slogdet computes sign + log(determinant).
  * det computes sign * exp(slogdet).
  */
-/**begin repeat
-
-   #TYPE = FLOAT, DOUBLE, CFLOAT, CDOUBLE#
-   #typ = npy_float, npy_double, npy_cfloat, npy_cdouble#
-   #basetyp = npy_float, npy_double, npy_float, npy_double#
-   #cblas_type = s, d, c, z#
-*/
-
-static NPY_INLINE void
-@TYPE@_slogdet_single_element(fortran_int m,
-                              void* src,
+template
+static inline void
+slogdet_single_element(fortran_int m,
+                              typ* src,
                               fortran_int* pivots,
-                              @typ@ *sign,
-                              @basetyp@ *logdet)
+                              typ *sign,
+                              basetyp *logdet)
 {
+using ftyp = fortran_type_t;
     fortran_int info = 0;
     fortran_int lda = fortran_int_max(m, 1);
     int i;
     /* note: done in place */
-    LAPACK(@cblas_type@getrf)(&m, &m, (void *)src, &lda, pivots, &info);
+    getrf(&m, &m, (ftyp*)src, &lda, pivots, &info);
 
     if (info == 0) {
         int change_sign = 0;
@@ -1086,23 +1130,20 @@ static NPY_INLINE void
             change_sign += (pivots[i] != (i+1));
         }
 
-        memcpy(sign,
-               (change_sign % 2)?
-                   &@cblas_type@_minus_one :
-                   &@cblas_type@_one
-               , sizeof(*sign));
-        @TYPE@_slogdet_from_factored_diagonal(src, m, sign, logdet);
+        *sign = (change_sign % 2)?numeric_limits::minus_one:numeric_limits::one;
+        slogdet_from_factored_diagonal(src, m, sign, logdet);
     } else {
         /*
           if getrf fails, use 0 as sign and -inf as logdet
         */
-        memcpy(sign, &@cblas_type@_zero, sizeof(*sign));
-        memcpy(logdet, &@cblas_type@_ninf, sizeof(*logdet));
+        *sign = numeric_limits::zero;
+        *logdet = numeric_limits::ninf;
     }
 }
 
+template
 static void
-@TYPE@_slogdet(char **args,
+slogdet(char **args,
                npy_intp const *dimensions,
                npy_intp const *steps,
                void *NPY_UNUSED(func))
@@ -1123,7 +1164,7 @@ static void
     INIT_OUTER_LOOP_3
     m = (fortran_int) dimensions[0];
     safe_m = m;
-    matrix_size = safe_m * safe_m * sizeof(@typ@);
+    matrix_size = safe_m * safe_m * sizeof(typ);
     pivot_size = safe_m * sizeof(fortran_int);
     tmp_buff = (npy_uint8 *)malloc(matrix_size + pivot_size);
 
@@ -1132,20 +1173,21 @@ static void
         /* swapped steps to get matrix in FORTRAN order */
         init_linearize_data(&lin_data, m, m, steps[1], steps[0]);
         BEGIN_OUTER_LOOP_3
-            linearize_@TYPE@_matrix(tmp_buff, args[0], &lin_data);
-            @TYPE@_slogdet_single_element(m,
-                                          (void*)tmp_buff,
+            linearize_matrix((typ*)tmp_buff, (typ*)args[0], &lin_data);
+            slogdet_single_element(m,
+                                   (typ*)tmp_buff,
                                           (fortran_int*)(tmp_buff+matrix_size),
-                                          (@typ@*)args[1],
-                                          (@basetyp@*)args[2]);
+                                          (typ*)args[1],
+                                          (basetyp*)args[2]);
         END_OUTER_LOOP
 
         free(tmp_buff);
     }
 }
 
+template
 static void
-@TYPE@_det(char **args,
+det(char **args,
            npy_intp const *dimensions,
            npy_intp const *steps,
            void *NPY_UNUSED(func))
@@ -1166,42 +1208,42 @@ static void
     INIT_OUTER_LOOP_2
     m = (fortran_int) dimensions[0];
     safe_m = m;
-    matrix_size = safe_m * safe_m * sizeof(@typ@);
+    matrix_size = safe_m * safe_m * sizeof(typ);
     pivot_size = safe_m * sizeof(fortran_int);
     tmp_buff = (npy_uint8 *)malloc(matrix_size + pivot_size);
 
     if (tmp_buff) {
         LINEARIZE_DATA_t lin_data;
-        @typ@ sign;
-        @basetyp@ logdet;
+        typ sign;
+        basetyp logdet;
         /* swapped steps to get matrix in FORTRAN order */
         init_linearize_data(&lin_data, m, m, steps[1], steps[0]);
 
         BEGIN_OUTER_LOOP_2
-            linearize_@TYPE@_matrix(tmp_buff, args[0], &lin_data);
-            @TYPE@_slogdet_single_element(m,
-                                          (void*)tmp_buff,
+            linearize_matrix((typ*)tmp_buff, (typ*)args[0], &lin_data);
+            slogdet_single_element(m,
+                                         (typ*)tmp_buff,
                                           (fortran_int*)(tmp_buff + matrix_size),
                                           &sign,
                                           &logdet);
-            *(@typ@ *)args[1] = @TYPE@_det_from_slogdet(sign, logdet);
+            *(typ *)args[1] = det_from_slogdet(sign, logdet);
         END_OUTER_LOOP
 
         free(tmp_buff);
     }
 }
-/**end repeat**/
 
 
 /* -------------------------------------------------------------------------- */
                           /* Eigh family */
 
-typedef struct eigh_params_struct {
-    void *A;     /* matrix */
-    void *W;     /* eigenvalue vector */
-    void *WORK;  /* main work buffer */
-    void *RWORK; /* secondary work buffer (for complex versions) */
-    void *IWORK;
+template
+struct EIGH_PARAMS_t {
+    typ *A;     /* matrix */
+    basetype_t *W;     /* eigenvalue vector */
+    typ *WORK;  /* main work buffer */
+    basetype_t *RWORK; /* secondary work buffer (for complex versions) */
+    fortran_int *IWORK;
     fortran_int N;
     fortran_int LWORK;
     fortran_int LRWORK;
@@ -1209,20 +1251,24 @@ typedef struct eigh_params_struct {
     char JOBZ;
     char UPLO;
     fortran_int LDA;
-} EIGH_PARAMS_t;
+} ;
 
-/**begin repeat
-   #TYPE = FLOAT, DOUBLE#
-   #typ = npy_float, npy_double#
-   #ftyp = fortran_real, fortran_doublereal#
-   #lapack_func = ssyevd, dsyevd#
-*/
-
-static NPY_INLINE fortran_int
-call_@lapack_func@(EIGH_PARAMS_t *params)
+static inline fortran_int
+call_evd(EIGH_PARAMS_t *params)
+{
+    fortran_int rv;
+    LAPACK(ssyevd)(¶ms->JOBZ, ¶ms->UPLO, ¶ms->N,
+                          params->A, ¶ms->LDA, params->W,
+                          params->WORK, ¶ms->LWORK,
+                          params->IWORK, ¶ms->LIWORK,
+                          &rv);
+    return rv;
+}
+static inline fortran_int
+call_evd(EIGH_PARAMS_t *params)
 {
     fortran_int rv;
-    LAPACK(@lapack_func@)(¶ms->JOBZ, ¶ms->UPLO, ¶ms->N,
+    LAPACK(dsyevd)(¶ms->JOBZ, ¶ms->UPLO, ¶ms->N,
                           params->A, ¶ms->LDA, params->W,
                           params->WORK, ¶ms->LWORK,
                           params->IWORK, ¶ms->LIWORK,
@@ -1230,13 +1276,15 @@ call_@lapack_func@(EIGH_PARAMS_t *params)
     return rv;
 }
 
+
 /*
  * Initialize the parameters to use in for the lapack function _syevd
  * Handles buffer allocation
  */
-static NPY_INLINE int
-init_@lapack_func@(EIGH_PARAMS_t* params, char JOBZ, char UPLO,
-                   fortran_int N)
+template
+static inline int
+init_evd(EIGH_PARAMS_t* params, char JOBZ, char UPLO,
+                   fortran_int N, scalar_trait)
 {
     npy_uint8 *mem_buff = NULL;
     npy_uint8 *mem_buff2 = NULL;
@@ -1244,19 +1292,19 @@ init_@lapack_func@(EIGH_PARAMS_t* params, char JOBZ, char UPLO,
     fortran_int liwork;
     npy_uint8 *a, *w, *work, *iwork;
     size_t safe_N = N;
-    size_t alloc_size = safe_N * (safe_N + 1) * sizeof(@typ@);
+    size_t alloc_size = safe_N * (safe_N + 1) * sizeof(typ);
     fortran_int lda = fortran_int_max(N, 1);
 
-    mem_buff = malloc(alloc_size);
+    mem_buff = (npy_uint8 *)malloc(alloc_size);
 
     if (!mem_buff) {
         goto error;
     }
     a = mem_buff;
-    w = mem_buff + safe_N * safe_N * sizeof(@typ@);
+    w = mem_buff + safe_N * safe_N * sizeof(typ);
 
-    params->A = a;
-    params->W = w;
+    params->A = (typ*)a;
+    params->W = (typ*)w;
     params->RWORK = NULL; /* unused */
     params->N = N;
     params->LRWORK = 0; /* unused */
@@ -1266,7 +1314,7 @@ init_@lapack_func@(EIGH_PARAMS_t* params, char JOBZ, char UPLO,
 
     /* Work size query */
     {
-        @typ@ query_work_size;
+        typ query_work_size;
         fortran_int query_iwork_size;
 
         params->LWORK = -1;
@@ -1274,7 +1322,7 @@ init_@lapack_func@(EIGH_PARAMS_t* params, char JOBZ, char UPLO,
         params->WORK = &query_work_size;
         params->IWORK = &query_iwork_size;
 
-        if (call_@lapack_func@(params) != 0) {
+        if (call_evd(params) != 0) {
             goto error;
         }
 
@@ -1282,18 +1330,18 @@ init_@lapack_func@(EIGH_PARAMS_t* params, char JOBZ, char UPLO,
         liwork = query_iwork_size;
     }
 
-    mem_buff2 = malloc(lwork*sizeof(@typ@) + liwork*sizeof(fortran_int));
+    mem_buff2 = (npy_uint8 *)malloc(lwork*sizeof(typ) + liwork*sizeof(fortran_int));
     if (!mem_buff2) {
         goto error;
     }
 
     work = mem_buff2;
-    iwork = mem_buff2 + lwork*sizeof(@typ@);
+    iwork = mem_buff2 + lwork*sizeof(typ);
 
     params->LWORK = lwork;
-    params->WORK = work;
+    params->WORK = (typ*)work;
     params->LIWORK = liwork;
-    params->IWORK = iwork;
+    params->IWORK = (fortran_int*)iwork;
 
     return 1;
 
@@ -1305,40 +1353,44 @@ init_@lapack_func@(EIGH_PARAMS_t* params, char JOBZ, char UPLO,
 
     return 0;
 }
-/**end repeat**/
 
 
-/**begin repeat
-   #TYPE = CFLOAT, CDOUBLE#
-   #typ = npy_cfloat, npy_cdouble#
-   #basetyp = npy_float, npy_double#
-   #ftyp = fortran_complex, fortran_doublecomplex#
-   #fbasetyp = fortran_real, fortran_doublereal#
-   #lapack_func = cheevd, zheevd#
-*/
-static NPY_INLINE fortran_int
-call_@lapack_func@(EIGH_PARAMS_t *params)
+static inline fortran_int
+call_evd(EIGH_PARAMS_t *params)
 {
     fortran_int rv;
-    LAPACK(@lapack_func@)(¶ms->JOBZ, ¶ms->UPLO, ¶ms->N,
-                          params->A, ¶ms->LDA, params->W,
-                          params->WORK, ¶ms->LWORK,
+    LAPACK(cheevd)(¶ms->JOBZ, ¶ms->UPLO, ¶ms->N,
+                          (fortran_type_t*)params->A, ¶ms->LDA, params->W,
+                          (fortran_type_t*)params->WORK, ¶ms->LWORK,
                           params->RWORK, ¶ms->LRWORK,
                           params->IWORK, ¶ms->LIWORK,
                           &rv);
     return rv;
 }
 
-/*
- * Initialize the parameters to use in for the lapack function _heev
- * Handles buffer allocation
- */
-static NPY_INLINE int
-init_@lapack_func@(EIGH_PARAMS_t *params,
+static inline fortran_int
+call_evd(EIGH_PARAMS_t *params)
+{
+    fortran_int rv;
+    LAPACK(zheevd)(¶ms->JOBZ, ¶ms->UPLO, ¶ms->N,
+                          (fortran_type_t*)params->A, ¶ms->LDA, params->W,
+                          (fortran_type_t*)params->WORK, ¶ms->LWORK,
+                          params->RWORK, ¶ms->LRWORK,
+                          params->IWORK, ¶ms->LIWORK,
+                          &rv);
+    return rv;
+}
+
+template
+static inline int
+init_evd(EIGH_PARAMS_t *params,
                    char JOBZ,
                    char UPLO,
-                   fortran_int N)
+                   fortran_int N, complex_trait)
 {
+    using basetyp = basetype_t;
+using ftyp = fortran_type_t;
+using fbasetyp = fortran_type_t;
     npy_uint8 *mem_buff = NULL;
     npy_uint8 *mem_buff2 = NULL;
     fortran_int lwork;
@@ -1348,16 +1400,16 @@ init_@lapack_func@(EIGH_PARAMS_t *params,
     size_t safe_N = N;
     fortran_int lda = fortran_int_max(N, 1);
 
-    mem_buff = malloc(safe_N * safe_N * sizeof(@typ@) +
-                      safe_N * sizeof(@basetyp@));
+    mem_buff = (npy_uint8 *)malloc(safe_N * safe_N * sizeof(typ) +
+                      safe_N * sizeof(basetyp));
     if (!mem_buff) {
         goto error;
     }
     a = mem_buff;
-    w = mem_buff + safe_N * safe_N * sizeof(@typ@);
+    w = mem_buff + safe_N * safe_N * sizeof(typ);
 
-    params->A = a;
-    params->W = w;
+    params->A = (typ*)a;
+    params->W = (basetyp*)w;
     params->N = N;
     params->JOBZ = JOBZ;
     params->UPLO = UPLO;
@@ -1365,40 +1417,40 @@ init_@lapack_func@(EIGH_PARAMS_t *params,
 
     /* Work size query */
     {
-        @ftyp@ query_work_size;
-        @fbasetyp@ query_rwork_size;
+        ftyp query_work_size;
+        fbasetyp query_rwork_size;
         fortran_int query_iwork_size;
 
         params->LWORK = -1;
         params->LRWORK = -1;
         params->LIWORK = -1;
-        params->WORK = &query_work_size;
-        params->RWORK = &query_rwork_size;
+        params->WORK = (typ*)&query_work_size;
+        params->RWORK = (basetyp*)&query_rwork_size;
         params->IWORK = &query_iwork_size;
 
-        if (call_@lapack_func@(params) != 0) {
+        if (call_evd(params) != 0) {
             goto error;
         }
 
-        lwork = (fortran_int)*(@fbasetyp@*)&query_work_size;
+        lwork = (fortran_int)*(fbasetyp*)&query_work_size;
         lrwork = (fortran_int)query_rwork_size;
         liwork = query_iwork_size;
     }
 
-    mem_buff2 = malloc(lwork*sizeof(@typ@) +
-                       lrwork*sizeof(@basetyp@) +
+    mem_buff2 = (npy_uint8 *)malloc(lwork*sizeof(typ) +
+                       lrwork*sizeof(basetyp) +
                        liwork*sizeof(fortran_int));
     if (!mem_buff2) {
         goto error;
     }
 
     work = mem_buff2;
-    rwork = work + lwork*sizeof(@typ@);
-    iwork = rwork + lrwork*sizeof(@basetyp@);
+    rwork = work + lwork*sizeof(typ);
+    iwork = rwork + lrwork*sizeof(basetyp);
 
-    params->WORK = work;
-    params->RWORK = rwork;
-    params->IWORK = iwork;
+    params->WORK = (typ*)work;
+    params->RWORK = (basetyp*)rwork;
+    params->IWORK = (fortran_int*)iwork;
     params->LWORK = lwork;
     params->LRWORK = lrwork;
     params->LIWORK = liwork;
@@ -1413,16 +1465,7 @@ init_@lapack_func@(EIGH_PARAMS_t *params,
 
     return 0;
 }
-/**end repeat**/
 
-
-/**begin repeat
-   #TYPE = FLOAT, DOUBLE, CFLOAT, CDOUBLE#
-   #BASETYPE = FLOAT, DOUBLE, FLOAT, DOUBLE#
-   #typ = npy_float, npy_double, npy_cfloat, npy_cdouble#
-   #basetyp = npy_float, npy_double, npy_float, npy_double#
-   #lapack_func = ssyevd, dsyevd, cheevd, zheevd#
-**/
 /*
  * (M, M)->(M,)(M, M)
  * dimensions[1] -> M
@@ -1431,8 +1474,9 @@ init_@lapack_func@(EIGH_PARAMS_t *params,
  * args[2] -> A[out]
  */
 
-static NPY_INLINE void
-release_@lapack_func@(EIGH_PARAMS_t *params)
+template
+static inline void
+release_evd(EIGH_PARAMS_t *params)
 {
     /* allocated memory in A and WORK */
     free(params->A);
@@ -1441,18 +1485,20 @@ release_@lapack_func@(EIGH_PARAMS_t *params)
 }
 
 
-static NPY_INLINE void
-@TYPE@_eigh_wrapper(char JOBZ,
+template
+static inline void
+eigh_wrapper(char JOBZ,
                     char UPLO,
                     char**args,
                     npy_intp const *dimensions,
                     npy_intp const *steps)
 {
+    using basetyp = basetype_t;
     ptrdiff_t outer_steps[3];
     size_t iter;
     size_t outer_dim = *dimensions++;
     size_t op_count = (JOBZ=='N')?2:3;
-    EIGH_PARAMS_t eigh_params;
+    EIGH_PARAMS_t eigh_params;
     int error_occurred = get_fp_invalid_and_clear();
 
     for (iter = 0; iter < op_count; ++iter) {
@@ -1460,10 +1506,10 @@ static NPY_INLINE void
     }
     steps += op_count;
 
-    if (init_@lapack_func@(&eigh_params,
+    if (init_evd(&eigh_params,
                            JOBZ,
                            UPLO,
-                           (fortran_int)dimensions[0])) {
+                           (fortran_int)dimensions[0], dispatch_scalar())) {
         LINEARIZE_DATA_t matrix_in_ld;
         LINEARIZE_DATA_t eigenvectors_out_ld;
         LINEARIZE_DATA_t eigenvalues_out_ld;
@@ -1483,106 +1529,98 @@ static NPY_INLINE void
         for (iter = 0; iter < outer_dim; ++iter) {
             int not_ok;
             /* copy the matrix in */
-            linearize_@TYPE@_matrix(eigh_params.A, args[0], &matrix_in_ld);
-            not_ok = call_@lapack_func@(&eigh_params);
+            linearize_matrix((typ*)eigh_params.A, (typ*)args[0], &matrix_in_ld);
+            not_ok = call_evd(&eigh_params);
             if (!not_ok) {
                 /* lapack ok, copy result out */
-                delinearize_@BASETYPE@_matrix(args[1],
-                                              eigh_params.W,
+                delinearize_matrix((basetyp*)args[1],
+                                              (basetyp*)eigh_params.W,
                                               &eigenvalues_out_ld);
 
                 if ('V' == eigh_params.JOBZ) {
-                    delinearize_@TYPE@_matrix(args[2],
-                                              eigh_params.A,
+                    delinearize_matrix((typ*)args[2],
+                                              (typ*)eigh_params.A,
                                               &eigenvectors_out_ld);
                 }
             } else {
                 /* lapack fail, set result to nan */
                 error_occurred = 1;
-                nan_@BASETYPE@_matrix(args[1], &eigenvalues_out_ld);
+                nan_matrix((basetyp*)args[1], &eigenvalues_out_ld);
                 if ('V' == eigh_params.JOBZ) {
-                    nan_@TYPE@_matrix(args[2], &eigenvectors_out_ld);
+                    nan_matrix((typ*)args[2], &eigenvectors_out_ld);
                 }
             }
             update_pointers((npy_uint8**)args, outer_steps, op_count);
         }
 
-        release_@lapack_func@(&eigh_params);
+        release_evd(&eigh_params);
     }
 
     set_fp_invalid_or_clear(error_occurred);
 }
-/**end repeat**/
 
 
-/**begin repeat
-   #TYPE = FLOAT, DOUBLE, CFLOAT, CDOUBLE#
- */
+template
 static void
-@TYPE@_eighlo(char **args,
+eighlo(char **args,
               npy_intp const *dimensions,
               npy_intp const *steps,
               void *NPY_UNUSED(func))
 {
-    @TYPE@_eigh_wrapper('V', 'L', args, dimensions, steps);
+    eigh_wrapper('V', 'L', args, dimensions, steps);
 }
 
+template
 static void
-@TYPE@_eighup(char **args,
+eighup(char **args,
               npy_intp const *dimensions,
               npy_intp const *steps,
               void* NPY_UNUSED(func))
 {
-    @TYPE@_eigh_wrapper('V', 'U', args, dimensions, steps);
+    eigh_wrapper('V', 'U', args, dimensions, steps);
 }
 
+template
 static void
-@TYPE@_eigvalshlo(char **args,
+eigvalshlo(char **args,
                   npy_intp const *dimensions,
                   npy_intp const *steps,
                   void* NPY_UNUSED(func))
 {
-    @TYPE@_eigh_wrapper('N', 'L', args, dimensions, steps);
+    eigh_wrapper('N', 'L', args, dimensions, steps);
 }
 
+template
 static void
-@TYPE@_eigvalshup(char **args,
+eigvalshup(char **args,
                   npy_intp const *dimensions,
                   npy_intp const *steps,
                   void* NPY_UNUSED(func))
 {
-    @TYPE@_eigh_wrapper('N', 'U', args, dimensions, steps);
+    eigh_wrapper('N', 'U', args, dimensions, steps);
 }
-/**end repeat**/
 
 /* -------------------------------------------------------------------------- */
                   /* Solve family (includes inv) */
 
-typedef struct gesv_params_struct
+template
+struct GESV_PARAMS_t
 {
-    void *A; /* A is (N, N) of base type */
-    void *B; /* B is (N, NRHS) of base type */
+    typ *A; /* A is (N, N) of base type */
+    typ *B; /* B is (N, NRHS) of base type */
     fortran_int * IPIV; /* IPIV is (N) */
 
     fortran_int N;
     fortran_int NRHS;
     fortran_int LDA;
     fortran_int LDB;
-} GESV_PARAMS_t;
-
-/**begin repeat
-   #TYPE = FLOAT, DOUBLE, CFLOAT, CDOUBLE#
-   #typ = npy_float, npy_double, npy_cfloat, npy_cdouble#
-   #ftyp = fortran_real, fortran_doublereal,
-           fortran_complex, fortran_doublecomplex#
-   #lapack_func = sgesv, dgesv, cgesv, zgesv#
-*/
+};
 
-static NPY_INLINE fortran_int
-call_@lapack_func@(GESV_PARAMS_t *params)
+static inline fortran_int
+call_gesv(GESV_PARAMS_t *params)
 {
     fortran_int rv;
-    LAPACK(@lapack_func@)(¶ms->N, ¶ms->NRHS,
+    LAPACK(sgesv)(¶ms->N, ¶ms->NRHS,
                           params->A, ¶ms->LDA,
                           params->IPIV,
                           params->B, ¶ms->LDB,
@@ -1590,30 +1628,68 @@ call_@lapack_func@(GESV_PARAMS_t *params)
     return rv;
 }
 
+static inline fortran_int
+call_gesv(GESV_PARAMS_t *params)
+{
+    fortran_int rv;
+    LAPACK(dgesv)(¶ms->N, ¶ms->NRHS,
+                          params->A, ¶ms->LDA,
+                          params->IPIV,
+                          params->B, ¶ms->LDB,
+                          &rv);
+    return rv;
+}
+
+static inline fortran_int
+call_gesv(GESV_PARAMS_t *params)
+{
+    fortran_int rv;
+    LAPACK(cgesv)(¶ms->N, ¶ms->NRHS,
+                          params->A, ¶ms->LDA,
+                          params->IPIV,
+                          params->B, ¶ms->LDB,
+                          &rv);
+    return rv;
+}
+
+static inline fortran_int
+call_gesv(GESV_PARAMS_t *params)
+{
+    fortran_int rv;
+    LAPACK(zgesv)(¶ms->N, ¶ms->NRHS,
+                          params->A, ¶ms->LDA,
+                          params->IPIV,
+                          params->B, ¶ms->LDB,
+                          &rv);
+    return rv;
+}
+
+
 /*
  * Initialize the parameters to use in for the lapack function _heev
  * Handles buffer allocation
  */
-static NPY_INLINE int
-init_@lapack_func@(GESV_PARAMS_t *params, fortran_int N, fortran_int NRHS)
+template
+static inline int
+init_gesv(GESV_PARAMS_t *params, fortran_int N, fortran_int NRHS)
 {
     npy_uint8 *mem_buff = NULL;
     npy_uint8 *a, *b, *ipiv;
     size_t safe_N = N;
     size_t safe_NRHS = NRHS;
     fortran_int ld = fortran_int_max(N, 1);
-    mem_buff = malloc(safe_N * safe_N * sizeof(@ftyp@) +
-                      safe_N * safe_NRHS*sizeof(@ftyp@) +
+    mem_buff = (npy_uint8 *)malloc(safe_N * safe_N * sizeof(ftyp) +
+                      safe_N * safe_NRHS*sizeof(ftyp) +
                       safe_N * sizeof(fortran_int));
     if (!mem_buff) {
         goto error;
     }
     a = mem_buff;
-    b = a + safe_N * safe_N * sizeof(@ftyp@);
-    ipiv = b + safe_N * safe_NRHS * sizeof(@ftyp@);
+    b = a + safe_N * safe_N * sizeof(ftyp);
+    ipiv = b + safe_N * safe_NRHS * sizeof(ftyp);
 
-    params->A = a;
-    params->B = b;
+    params->A = (ftyp*)a;
+    params->B = (ftyp*)b;
     params->IPIV = (fortran_int*)ipiv;
     params->N = N;
     params->NRHS = NRHS;
@@ -1628,26 +1704,29 @@ init_@lapack_func@(GESV_PARAMS_t *params, fortran_int N, fortran_int NRHS)
     return 0;
 }
 
-static NPY_INLINE void
-release_@lapack_func@(GESV_PARAMS_t *params)
+template
+static inline void
+release_gesv(GESV_PARAMS_t *params)
 {
     /* memory block base is in A */
     free(params->A);
     memset(params, 0, sizeof(*params));
 }
 
+template
 static void
-@TYPE@_solve(char **args, npy_intp const *dimensions, npy_intp const *steps,
+solve(char **args, npy_intp const *dimensions, npy_intp const *steps,
              void *NPY_UNUSED(func))
 {
-    GESV_PARAMS_t params;
+using ftyp = fortran_type_t;
+    GESV_PARAMS_t params;
     fortran_int n, nrhs;
     int error_occurred = get_fp_invalid_and_clear();
     INIT_OUTER_LOOP_3
 
     n = (fortran_int)dimensions[0];
     nrhs = (fortran_int)dimensions[1];
-    if (init_@lapack_func@(¶ms, n, nrhs)) {
+    if (init_gesv(¶ms, n, nrhs)) {
         LINEARIZE_DATA_t a_in, b_in, r_out;
 
         init_linearize_data(&a_in, n, n, steps[1], steps[0]);
@@ -1656,34 +1735,37 @@ static void
 
         BEGIN_OUTER_LOOP_3
             int not_ok;
-            linearize_@TYPE@_matrix(params.A, args[0], &a_in);
-            linearize_@TYPE@_matrix(params.B, args[1], &b_in);
-            not_ok =call_@lapack_func@(¶ms);
+            linearize_matrix((typ*)params.A, (typ*)args[0], &a_in);
+            linearize_matrix((typ*)params.B, (typ*)args[1], &b_in);
+            not_ok =call_gesv(¶ms);
             if (!not_ok) {
-                delinearize_@TYPE@_matrix(args[2], params.B, &r_out);
+                delinearize_matrix((typ*)args[2], (typ*)params.B, &r_out);
             } else {
                 error_occurred = 1;
-                nan_@TYPE@_matrix(args[2], &r_out);
+                nan_matrix((typ*)args[2], &r_out);
             }
         END_OUTER_LOOP
 
-        release_@lapack_func@(¶ms);
+        release_gesv(¶ms);
     }
 
     set_fp_invalid_or_clear(error_occurred);
 }
 
+
+template
 static void
-@TYPE@_solve1(char **args, npy_intp const *dimensions, npy_intp const *steps,
+solve1(char **args, npy_intp const *dimensions, npy_intp const *steps,
               void *NPY_UNUSED(func))
 {
-    GESV_PARAMS_t params;
+using ftyp = fortran_type_t;
+    GESV_PARAMS_t params;
     int error_occurred = get_fp_invalid_and_clear();
     fortran_int n;
     INIT_OUTER_LOOP_3
 
     n = (fortran_int)dimensions[0];
-    if (init_@lapack_func@(¶ms, n, 1)) {
+    if (init_gesv(¶ms, n, 1)) {
         LINEARIZE_DATA_t a_in, b_in, r_out;
         init_linearize_data(&a_in, n, n, steps[1], steps[0]);
         init_linearize_data(&b_in, 1, n, 1, steps[2]);
@@ -1691,105 +1773,130 @@ static void
 
         BEGIN_OUTER_LOOP_3
             int not_ok;
-            linearize_@TYPE@_matrix(params.A, args[0], &a_in);
-            linearize_@TYPE@_matrix(params.B, args[1], &b_in);
-            not_ok = call_@lapack_func@(¶ms);
+            linearize_matrix((typ*)params.A, (typ*)args[0], &a_in);
+            linearize_matrix((typ*)params.B, (typ*)args[1], &b_in);
+            not_ok = call_gesv(¶ms);
             if (!not_ok) {
-                delinearize_@TYPE@_matrix(args[2], params.B, &r_out);
+                delinearize_matrix((typ*)args[2], (typ*)params.B, &r_out);
             } else {
                 error_occurred = 1;
-                nan_@TYPE@_matrix(args[2], &r_out);
+                nan_matrix((typ*)args[2], &r_out);
             }
         END_OUTER_LOOP
 
-        release_@lapack_func@(¶ms);
+        release_gesv(¶ms);
     }
 
     set_fp_invalid_or_clear(error_occurred);
 }
 
+template
 static void
-@TYPE@_inv(char **args, npy_intp const *dimensions, npy_intp const *steps,
+inv(char **args, npy_intp const *dimensions, npy_intp const *steps,
            void *NPY_UNUSED(func))
 {
-    GESV_PARAMS_t params;
+using ftyp = fortran_type_t;
+    GESV_PARAMS_t params;
     fortran_int n;
     int error_occurred = get_fp_invalid_and_clear();
     INIT_OUTER_LOOP_2
 
     n = (fortran_int)dimensions[0];
-    if (init_@lapack_func@(¶ms, n, n)) {
+    if (init_gesv(¶ms, n, n)) {
         LINEARIZE_DATA_t a_in, r_out;
         init_linearize_data(&a_in, n, n, steps[1], steps[0]);
         init_linearize_data(&r_out, n, n, steps[3], steps[2]);
 
         BEGIN_OUTER_LOOP_2
             int not_ok;
-            linearize_@TYPE@_matrix(params.A, args[0], &a_in);
-            identity_@TYPE@_matrix(params.B, n);
-            not_ok = call_@lapack_func@(¶ms);
+            linearize_matrix((typ*)params.A, (typ*)args[0], &a_in);
+            identity_matrix((typ*)params.B, n);
+            not_ok = call_gesv(¶ms);
             if (!not_ok) {
-                delinearize_@TYPE@_matrix(args[1], params.B, &r_out);
+                delinearize_matrix((typ*)args[1], (typ*)params.B, &r_out);
             } else {
                 error_occurred = 1;
-                nan_@TYPE@_matrix(args[1], &r_out);
+                nan_matrix((typ*)args[1], &r_out);
             }
         END_OUTER_LOOP
 
-        release_@lapack_func@(¶ms);
+        release_gesv(¶ms);
     }
 
     set_fp_invalid_or_clear(error_occurred);
 }
 
-/**end repeat**/
-
 
 /* -------------------------------------------------------------------------- */
                      /* Cholesky decomposition */
 
-typedef struct potr_params_struct
+template
+struct POTR_PARAMS_t
 {
-    void *A;
+    typ *A;
     fortran_int N;
     fortran_int LDA;
     char UPLO;
-} POTR_PARAMS_t;
+};
 
-/**begin repeat
 
-   #TYPE = FLOAT, DOUBLE, CFLOAT, CDOUBLE#
-   #ftyp = fortran_real, fortran_doublereal,
-           fortran_complex, fortran_doublecomplex#
-   #lapack_func = spotrf, dpotrf, cpotrf, zpotrf#
- */
+static inline fortran_int
+call_potrf(POTR_PARAMS_t *params)
+{
+    fortran_int rv;
+    LAPACK(spotrf)(¶ms->UPLO,
+                          ¶ms->N, params->A, ¶ms->LDA,
+                          &rv);
+    return rv;
+}
+
+static inline fortran_int
+call_potrf(POTR_PARAMS_t *params)
+{
+    fortran_int rv;
+    LAPACK(dpotrf)(¶ms->UPLO,
+                          ¶ms->N, params->A, ¶ms->LDA,
+                          &rv);
+    return rv;
+}
+
+static inline fortran_int
+call_potrf(POTR_PARAMS_t *params)
+{
+    fortran_int rv;
+    LAPACK(cpotrf)(¶ms->UPLO,
+                          ¶ms->N, params->A, ¶ms->LDA,
+                          &rv);
+    return rv;
+}
 
-static NPY_INLINE fortran_int
-call_@lapack_func@(POTR_PARAMS_t *params)
+static inline fortran_int
+call_potrf(POTR_PARAMS_t *params)
 {
     fortran_int rv;
-    LAPACK(@lapack_func@)(¶ms->UPLO,
+    LAPACK(zpotrf)(¶ms->UPLO,
                           ¶ms->N, params->A, ¶ms->LDA,
                           &rv);
     return rv;
 }
 
-static NPY_INLINE int
-init_@lapack_func@(POTR_PARAMS_t *params, char UPLO, fortran_int N)
+template
+static inline int
+init_potrf(POTR_PARAMS_t *params, char UPLO, fortran_int N)
 {
     npy_uint8 *mem_buff = NULL;
     npy_uint8 *a;
     size_t safe_N = N;
     fortran_int lda = fortran_int_max(N, 1);
 
-    mem_buff = malloc(safe_N * safe_N * sizeof(@ftyp@));
+    mem_buff = (npy_uint8 *)malloc(safe_N * safe_N * sizeof(ftyp));
     if (!mem_buff) {
         goto error;
     }
 
     a = mem_buff;
 
-    params->A = a;
+    params->A = (ftyp*)a;
     params->N = N;
     params->LDA = lda;
     params->UPLO = UPLO;
@@ -1802,18 +1909,21 @@ init_@lapack_func@(POTR_PARAMS_t *params, char UPLO, fortran_int N)
     return 0;
 }
 
-static NPY_INLINE void
-release_@lapack_func@(POTR_PARAMS_t *params)
+template
+static inline void
+release_potrf(POTR_PARAMS_t *params)
 {
     /* memory block base in A */
     free(params->A);
     memset(params, 0, sizeof(*params));
 }
 
+template
 static void
-@TYPE@_cholesky(char uplo, char **args, npy_intp const *dimensions, npy_intp const *steps)
+cholesky(char uplo, char **args, npy_intp const *dimensions, npy_intp const *steps)
 {
-    POTR_PARAMS_t params;
+    using ftyp = fortran_type_t;
+    POTR_PARAMS_t params;
     int error_occurred = get_fp_invalid_and_clear();
     fortran_int n;
     INIT_OUTER_LOOP_2
@@ -1821,50 +1931,50 @@ static void
     assert(uplo == 'L');
 
     n = (fortran_int)dimensions[0];
-    if (init_@lapack_func@(¶ms, uplo, n)) {
+    if (init_potrf(¶ms, uplo, n)) {
         LINEARIZE_DATA_t a_in, r_out;
         init_linearize_data(&a_in, n, n, steps[1], steps[0]);
         init_linearize_data(&r_out, n, n, steps[3], steps[2]);
         BEGIN_OUTER_LOOP_2
             int not_ok;
-            linearize_@TYPE@_matrix(params.A, args[0], &a_in);
-            not_ok = call_@lapack_func@(¶ms);
+            linearize_matrix(params.A, (ftyp*)args[0], &a_in);
+            not_ok = call_potrf(¶ms);
             if (!not_ok) {
-                triu_@TYPE@_matrix(params.A, params.N);
-                delinearize_@TYPE@_matrix(args[1], params.A, &r_out);
+                triu_matrix(params.A, params.N);
+                delinearize_matrix((ftyp*)args[1], params.A, &r_out);
             } else {
                 error_occurred = 1;
-                nan_@TYPE@_matrix(args[1], &r_out);
+                nan_matrix((ftyp*)args[1], &r_out);
             }
         END_OUTER_LOOP
-        release_@lapack_func@(¶ms);
+        release_potrf(¶ms);
     }
 
     set_fp_invalid_or_clear(error_occurred);
 }
 
+template
 static void
-@TYPE@_cholesky_lo(char **args, npy_intp const *dimensions, npy_intp const *steps,
+cholesky_lo(char **args, npy_intp const *dimensions, npy_intp const *steps,
                 void *NPY_UNUSED(func))
 {
-    @TYPE@_cholesky('L', args, dimensions, steps);
+    cholesky('L', args, dimensions, steps);
 }
 
-/**end repeat**/
-
 /* -------------------------------------------------------------------------- */
                           /* eig family  */
 
-typedef struct geev_params_struct {
-    void *A;
-    void *WR; /* RWORK in complex versions, REAL W buffer for (sd)geev*/
-    void *WI;
-    void *VLR; /* REAL VL buffers for _geev where _ is s, d */
-    void *VRR; /* REAL VR buffers for _geev where _ is s, d */
-    void *WORK;
-    void *W;  /* final w */
-    void *VL; /* final vl */
-    void *VR; /* final vr */
+template
+struct GEEV_PARAMS_t {
+    typ *A;
+    basetype_t *WR; /* RWORK in complex versions, REAL W buffer for (sd)geev*/
+    typ *WI;
+    typ *VLR; /* REAL VL buffers for _geev where _ is s, d */
+    typ *VRR; /* REAL VR buffers for _geev where _ is s, d */
+    typ *WORK;
+    typ *W;  /* final w */
+    typ *VL; /* final vl */
+    typ *VR; /* final vr */
 
     fortran_int N;
     fortran_int LDA;
@@ -1874,10 +1984,11 @@ typedef struct geev_params_struct {
 
     char JOBVL;
     char JOBVR;
-} GEEV_PARAMS_t;
+};
 
-static NPY_INLINE void
-dump_geev_params(const char *name, GEEV_PARAMS_t* params)
+template
+static inline void
+dump_geev_params(const char *name, GEEV_PARAMS_t* params)
 {
     TRACE_TXT("\n%s\n"
 
@@ -1922,20 +2033,25 @@ dump_geev_params(const char *name, GEEV_PARAMS_t* params)
               "JOBVR", params->JOBVR);
 }
 
-/**begin repeat
-   #TYPE = FLOAT, DOUBLE#
-   #CTYPE = CFLOAT, CDOUBLE#
-   #typ = float, double#
-   #complextyp = COMPLEX_t, DOUBLECOMPLEX_t#
-   #lapack_func = sgeev, dgeev#
-   #zero = 0.0f, 0.0#
-*/
+static inline fortran_int
+call_geev(GEEV_PARAMS_t* params)
+{
+    fortran_int rv;
+    LAPACK(sgeev)(¶ms->JOBVL, ¶ms->JOBVR,
+                          ¶ms->N, params->A, ¶ms->LDA,
+                          params->WR, params->WI,
+                          params->VLR, ¶ms->LDVL,
+                          params->VRR, ¶ms->LDVR,
+                          params->WORK, ¶ms->LWORK,
+                          &rv);
+    return rv;
+}
 
-static NPY_INLINE fortran_int
-call_@lapack_func@(GEEV_PARAMS_t* params)
+static inline fortran_int
+call_geev(GEEV_PARAMS_t* params)
 {
     fortran_int rv;
-    LAPACK(@lapack_func@)(¶ms->JOBVL, ¶ms->JOBVR,
+    LAPACK(dgeev)(¶ms->JOBVL, ¶ms->JOBVR,
                           ¶ms->N, params->A, ¶ms->LDA,
                           params->WR, params->WI,
                           params->VLR, ¶ms->LDVL,
@@ -1945,18 +2061,21 @@ call_@lapack_func@(GEEV_PARAMS_t* params)
     return rv;
 }
 
-static NPY_INLINE int
-init_@lapack_func@(GEEV_PARAMS_t *params, char jobvl, char jobvr, fortran_int n)
+
+template
+static inline int
+init_geev(GEEV_PARAMS_t *params, char jobvl, char jobvr, fortran_int n,
+scalar_trait)
 {
     npy_uint8 *mem_buff = NULL;
     npy_uint8 *mem_buff2 = NULL;
     npy_uint8 *a, *wr, *wi, *vlr, *vrr, *work, *w, *vl, *vr;
     size_t safe_n = n;
-    size_t a_size = safe_n * safe_n * sizeof(@typ@);
-    size_t wr_size = safe_n * sizeof(@typ@);
-    size_t wi_size = safe_n * sizeof(@typ@);
-    size_t vlr_size = jobvl=='V' ? safe_n * safe_n * sizeof(@typ@) : 0;
-    size_t vrr_size = jobvr=='V' ? safe_n * safe_n * sizeof(@typ@) : 0;
+    size_t a_size = safe_n * safe_n * sizeof(typ);
+    size_t wr_size = safe_n * sizeof(typ);
+    size_t wi_size = safe_n * sizeof(typ);
+    size_t vlr_size = jobvl=='V' ? safe_n * safe_n * sizeof(typ) : 0;
+    size_t vrr_size = jobvr=='V' ? safe_n * safe_n * sizeof(typ) : 0;
     size_t w_size = wr_size*2;
     size_t vl_size = vlr_size*2;
     size_t vr_size = vrr_size*2;
@@ -1964,7 +2083,7 @@ init_@lapack_func@(GEEV_PARAMS_t *params, char jobvl, char jobvr, fortran_int n)
     fortran_int ld = fortran_int_max(n, 1);
 
     /* allocate data for known sizes (all but work) */
-    mem_buff = malloc(a_size + wr_size + wi_size +
+    mem_buff = (npy_uint8 *)malloc(a_size + wr_size + wi_size +
                       vlr_size + vrr_size +
                       w_size + vl_size + vr_size);
     if (!mem_buff) {
@@ -1980,14 +2099,14 @@ init_@lapack_func@(GEEV_PARAMS_t *params, char jobvl, char jobvr, fortran_int n)
     vl = w + w_size;
     vr = vl + vl_size;
 
-    params->A = a;
-    params->WR = wr;
-    params->WI = wi;
-    params->VLR = vlr;
-    params->VRR = vrr;
-    params->W = w;
-    params->VL = vl;
-    params->VR = vr;
+    params->A = (typ*)a;
+    params->WR = (typ*)wr;
+    params->WI = (typ*)wi;
+    params->VLR = (typ*)vlr;
+    params->VRR = (typ*)vrr;
+    params->W = (typ*)w;
+    params->VL = (typ*)vl;
+    params->VR = (typ*)vr;
     params->N = n;
     params->LDA = ld;
     params->LDVL = ld;
@@ -1997,26 +2116,26 @@ init_@lapack_func@(GEEV_PARAMS_t *params, char jobvl, char jobvr, fortran_int n)
 
     /* Work size query */
     {
-        @typ@ work_size_query;
+        typ work_size_query;
 
         params->LWORK = -1;
         params->WORK = &work_size_query;
 
-        if (call_@lapack_func@(params) != 0) {
+        if (call_geev(params) != 0) {
             goto error;
         }
 
         work_count = (size_t)work_size_query;
     }
 
-    mem_buff2 = malloc(work_count*sizeof(@typ@));
+    mem_buff2 = (npy_uint8 *)malloc(work_count*sizeof(typ));
     if (!mem_buff2) {
         goto error;
     }
     work = mem_buff2;
 
     params->LWORK = (fortran_int)work_count;
-    params->WORK = work;
+    params->WORK = (typ*)work;
 
     return 1;
  error:
@@ -2027,42 +2146,45 @@ init_@lapack_func@(GEEV_PARAMS_t *params, char jobvl, char jobvr, fortran_int n)
     return 0;
 }
 
-static NPY_INLINE void
-mk_@TYPE@_complex_array_from_real(@complextyp@ *c, const @typ@ *re, size_t n)
+template
+static inline void
+mk_complex_array_from_real(complextyp *c, const typ *re, size_t n)
 {
     size_t iter;
     for (iter = 0; iter < n; ++iter) {
-        c[iter].array[0] = re[iter];
-        c[iter].array[1] = @zero@;
+        c[iter].r = re[iter];
+        c[iter].i = numeric_limits::zero;
     }
 }
 
-static NPY_INLINE void
-mk_@TYPE@_complex_array(@complextyp@ *c,
-                        const @typ@ *re,
-                        const @typ@ *im,
+template
+static inline void
+mk_complex_array(complextyp *c,
+                        const typ *re,
+                        const typ *im,
                         size_t n)
 {
     size_t iter;
     for (iter = 0; iter < n; ++iter) {
-        c[iter].array[0] = re[iter];
-        c[iter].array[1] = im[iter];
+        c[iter].r = re[iter];
+        c[iter].i = im[iter];
     }
 }
 
-static NPY_INLINE void
-mk_@TYPE@_complex_array_conjugate_pair(@complextyp@ *c,
-                                       const @typ@ *r,
+template
+static inline void
+mk_complex_array_conjugate_pair(complextyp *c,
+                                       const typ *r,
                                        size_t n)
 {
     size_t iter;
     for (iter = 0; iter < n; ++iter) {
-        @typ@ re = r[iter];
-        @typ@ im = r[iter+n];
-        c[iter].array[0] = re;
-        c[iter].array[1] = im;
-        c[iter+n].array[0] = re;
-        c[iter+n].array[1] = -im;
+        typ re = r[iter];
+        typ im = r[iter+n];
+        c[iter].r = re;
+        c[iter].i = im;
+        c[iter+n].r = re;
+        c[iter+n].i = -im;
     }
 }
 
@@ -2073,24 +2195,25 @@ mk_@TYPE@_complex_array_conjugate_pair(@complextyp@ *c,
  * i is the eigenvalue imaginary part produced by sgeev/zgeev
  * n is so that the order of the matrix is n by n
  */
-static NPY_INLINE void
-mk_@lapack_func@_complex_eigenvectors(@complextyp@ *c,
-                                      const @typ@ *r,
-                                      const @typ@ *i,
+template
+static inline void
+mk_geev_complex_eigenvectors(complextyp *c,
+                                      const typ *r,
+                                      const typ *i,
                                       size_t n)
 {
     size_t iter = 0;
     while (iter < n)
     {
-        if (i[iter] ==  @zero@) {
+        if (i[iter] ==  numeric_limits::zero) {
             /* eigenvalue was real, eigenvectors as well...  */
-            mk_@TYPE@_complex_array_from_real(c, r, n);
+            mk_complex_array_from_real(c, r, n);
             c += n;
             r += n;
             iter ++;
         } else {
             /* eigenvalue was complex, generate a pair of eigenvectors */
-            mk_@TYPE@_complex_array_conjugate_pair(c, r, n);
+            mk_complex_array_conjugate_pair(c, r, n);
             c += 2*n;
             r += 2*n;
             iter += 2;
@@ -2099,43 +2222,49 @@ mk_@lapack_func@_complex_eigenvectors(@complextyp@ *c,
 }
 
 
-static NPY_INLINE void
-process_@lapack_func@_results(GEEV_PARAMS_t *params)
+template
+static inline void
+process_geev_results(GEEV_PARAMS_t *params, scalar_trait)
 {
     /* REAL versions of geev need the results to be translated
      * into complex versions. This is the way to deal with imaginary
      * results. In our gufuncs we will always return complex arrays!
      */
-    mk_@TYPE@_complex_array(params->W, params->WR, params->WI, params->N);
+    mk_complex_array((complextyp*)params->W, (typ*)params->WR, (typ*)params->WI, params->N);
 
     /* handle the eigenvectors */
     if ('V' == params->JOBVL) {
-        mk_@lapack_func@_complex_eigenvectors(params->VL, params->VLR,
-                                              params->WI, params->N);
+        mk_geev_complex_eigenvectors((complextyp*)params->VL, (typ*)params->VLR,
+                                              (typ*)params->WI, params->N);
     }
     if ('V' == params->JOBVR) {
-        mk_@lapack_func@_complex_eigenvectors(params->VR, params->VRR,
-                                              params->WI, params->N);
+        mk_geev_complex_eigenvectors((complextyp*)params->VR, (typ*)params->VRR,
+                                              (typ*)params->WI, params->N);
     }
 }
 
-/**end repeat**/
 
+static inline fortran_int
+call_geev(GEEV_PARAMS_t* params)
+{
+    fortran_int rv;
 
-/**begin repeat
-   #TYPE = CFLOAT, CDOUBLE#
-   #typ = COMPLEX_t, DOUBLECOMPLEX_t#
-   #ftyp = fortran_complex, fortran_doublecomplex#
-   #realtyp = float, double#
-   #lapack_func = cgeev, zgeev#
- */
-
-static NPY_INLINE fortran_int
-call_@lapack_func@(GEEV_PARAMS_t* params)
+    LAPACK(cgeev)(¶ms->JOBVL, ¶ms->JOBVR,
+                          ¶ms->N, params->A, ¶ms->LDA,
+                          params->W,
+                          params->VL, ¶ms->LDVL,
+                          params->VR, ¶ms->LDVR,
+                          params->WORK, ¶ms->LWORK,
+                          params->WR, /* actually RWORK */
+                          &rv);
+    return rv;
+}
+static inline fortran_int
+call_geev(GEEV_PARAMS_t* params)
 {
     fortran_int rv;
 
-    LAPACK(@lapack_func@)(¶ms->JOBVL, ¶ms->JOBVR,
+    LAPACK(zgeev)(¶ms->JOBVL, ¶ms->JOBVR,
                           ¶ms->N, params->A, ¶ms->LDA,
                           params->W,
                           params->VL, ¶ms->LDVL,
@@ -2146,26 +2275,28 @@ call_@lapack_func@(GEEV_PARAMS_t* params)
     return rv;
 }
 
-static NPY_INLINE int
-init_@lapack_func@(GEEV_PARAMS_t* params,
+template
+static inline int
+init_geev(GEEV_PARAMS_t* params,
                    char jobvl,
                    char jobvr,
-                   fortran_int n)
+                   fortran_int n, complex_trait)
 {
+using realtyp = basetype_t;
     npy_uint8 *mem_buff = NULL;
     npy_uint8 *mem_buff2 = NULL;
     npy_uint8 *a, *w, *vl, *vr, *work, *rwork;
     size_t safe_n = n;
-    size_t a_size = safe_n * safe_n * sizeof(@ftyp@);
-    size_t w_size = safe_n * sizeof(@ftyp@);
-    size_t vl_size = jobvl=='V'? safe_n * safe_n * sizeof(@ftyp@) : 0;
-    size_t vr_size = jobvr=='V'? safe_n * safe_n * sizeof(@ftyp@) : 0;
-    size_t rwork_size = 2 * safe_n * sizeof(@realtyp@);
+    size_t a_size = safe_n * safe_n * sizeof(ftyp);
+    size_t w_size = safe_n * sizeof(ftyp);
+    size_t vl_size = jobvl=='V'? safe_n * safe_n * sizeof(ftyp) : 0;
+    size_t vr_size = jobvr=='V'? safe_n * safe_n * sizeof(ftyp) : 0;
+    size_t rwork_size = 2 * safe_n * sizeof(realtyp);
     size_t work_count = 0;
     size_t total_size = a_size + w_size + vl_size + vr_size + rwork_size;
     fortran_int ld = fortran_int_max(n, 1);
 
-    mem_buff = malloc(total_size);
+    mem_buff = (npy_uint8 *)malloc(total_size);
     if (!mem_buff) {
         goto error;
     }
@@ -2176,14 +2307,14 @@ init_@lapack_func@(GEEV_PARAMS_t* params,
     vr = vl + vl_size;
     rwork = vr + vr_size;
 
-    params->A = a;
-    params->WR = rwork;
+    params->A = (ftyp*)a;
+    params->WR = (realtyp*)rwork;
     params->WI = NULL;
     params->VLR = NULL;
     params->VRR = NULL;
-    params->VL = vl;
-    params->VR = vr;
-    params->W = w;
+    params->VL = (ftyp*)vl;
+    params->VR = (ftyp*)vr;
+    params->W = (ftyp*)w;
     params->N = n;
     params->LDA = ld;
     params->LDVL = ld;
@@ -2193,21 +2324,21 @@ init_@lapack_func@(GEEV_PARAMS_t* params,
 
     /* Work size query */
     {
-        @typ@ work_size_query;
+        ftyp work_size_query;
 
         params->LWORK = -1;
         params->WORK = &work_size_query;
 
-        if (call_@lapack_func@(params) != 0) {
+        if (call_geev(params) != 0) {
             goto error;
         }
 
-        work_count = (size_t) work_size_query.array[0];
+        work_count = (size_t) work_size_query.r;
         /* Fix a bug in lapack 3.0.0 */
         if(work_count == 0) work_count = 1;
     }
 
-    mem_buff2 = malloc(work_count*sizeof(@ftyp@));
+    mem_buff2 = (npy_uint8 *)malloc(work_count*sizeof(ftyp));
     if (!mem_buff2) {
         goto error;
     }
@@ -2215,7 +2346,7 @@ init_@lapack_func@(GEEV_PARAMS_t* params,
     work = mem_buff2;
 
     params->LWORK = (fortran_int)work_count;
-    params->WORK = work;
+    params->WORK = (ftyp*)work;
 
     return 1;
  error:
@@ -2226,32 +2357,27 @@ init_@lapack_func@(GEEV_PARAMS_t* params,
     return 0;
 }
 
-
-static NPY_INLINE void
-process_@lapack_func@_results(GEEV_PARAMS_t *NPY_UNUSED(params))
+template
+static inline void
+process_geev_results(GEEV_PARAMS_t *NPY_UNUSED(params), complex_trait)
 {
     /* nothing to do here, complex versions are ready to copy out */
 }
-/**end repeat**/
 
 
-/**begin repeat
-   #TYPE = FLOAT, DOUBLE, CDOUBLE#
-   #COMPLEXTYPE = CFLOAT, CDOUBLE, CDOUBLE#
-   #ftype = fortran_real, fortran_doublereal, fortran_doublecomplex#
-   #lapack_func = sgeev, dgeev, zgeev#
- */
 
-static NPY_INLINE void
-release_@lapack_func@(GEEV_PARAMS_t *params)
+template
+static inline void
+release_geev(GEEV_PARAMS_t *params)
 {
     free(params->WORK);
     free(params->A);
     memset(params, 0, sizeof(*params));
 }
 
-static NPY_INLINE void
-@TYPE@_eig_wrapper(char JOBVL,
+template
+static inline void
+eig_wrapper(char JOBVL,
                    char JOBVR,
                    char**args,
                    npy_intp const *dimensions,
@@ -2262,7 +2388,7 @@ static NPY_INLINE void
     size_t outer_dim = *dimensions++;
     size_t op_count = 2;
     int error_occurred = get_fp_invalid_and_clear();
-    GEEV_PARAMS_t geev_params;
+    GEEV_PARAMS_t geev_params;
 
     assert(JOBVL == 'N');
 
@@ -2275,9 +2401,9 @@ static NPY_INLINE void
     }
     steps += op_count;
 
-    if (init_@lapack_func@(&geev_params,
+    if (init_geev(&geev_params,
                            JOBVL, JOBVR,
-                           (fortran_int)dimensions[0])) {
+                           (fortran_int)dimensions[0], dispatch_scalar())) {
         LINEARIZE_DATA_t a_in;
         LINEARIZE_DATA_t w_out;
         LINEARIZE_DATA_t vl_out;
@@ -2307,78 +2433,81 @@ static NPY_INLINE void
             int not_ok;
             char **arg_iter = args;
             /* copy the matrix in */
-            linearize_@TYPE@_matrix(geev_params.A, *arg_iter++, &a_in);
-            not_ok = call_@lapack_func@(&geev_params);
+            linearize_matrix((ftype*)geev_params.A, (ftype*)*arg_iter++, &a_in);
+            not_ok = call_geev(&geev_params);
 
             if (!not_ok) {
-                process_@lapack_func@_results(&geev_params);
-                delinearize_@COMPLEXTYPE@_matrix(*arg_iter++,
-                                                 geev_params.W,
+                process_geev_results(&geev_params,
+dispatch_scalar{});
+                delinearize_matrix((fctype*)*arg_iter++,
+                                                 (fctype*)geev_params.W,
                                                  &w_out);
 
                 if ('V' == geev_params.JOBVL) {
-                    delinearize_@COMPLEXTYPE@_matrix(*arg_iter++,
-                                                     geev_params.VL,
+                    delinearize_matrix((fctype*)*arg_iter++,
+                                                     (fctype*)geev_params.VL,
                                                      &vl_out);
                 }
                 if ('V' == geev_params.JOBVR) {
-                    delinearize_@COMPLEXTYPE@_matrix(*arg_iter++,
-                                                     geev_params.VR,
+                    delinearize_matrix((fctype*)*arg_iter++,
+                                                     (fctype*)geev_params.VR,
                                                      &vr_out);
                 }
             } else {
                 /* geev failed */
                 error_occurred = 1;
-                nan_@COMPLEXTYPE@_matrix(*arg_iter++, &w_out);
+                nan_matrix((fctype*)*arg_iter++, &w_out);
                 if ('V' == geev_params.JOBVL) {
-                    nan_@COMPLEXTYPE@_matrix(*arg_iter++, &vl_out);
+                    nan_matrix((fctype*)*arg_iter++, &vl_out);
                 }
                 if ('V' == geev_params.JOBVR) {
-                    nan_@COMPLEXTYPE@_matrix(*arg_iter++, &vr_out);
+                    nan_matrix((fctype*)*arg_iter++, &vr_out);
                 }
             }
             update_pointers((npy_uint8**)args, outer_steps, op_count);
         }
 
-        release_@lapack_func@(&geev_params);
+        release_geev(&geev_params);
     }
 
     set_fp_invalid_or_clear(error_occurred);
 }
 
+template
 static void
-@TYPE@_eig(char **args,
+eig(char **args,
            npy_intp const *dimensions,
            npy_intp const *steps,
            void *NPY_UNUSED(func))
 {
-    @TYPE@_eig_wrapper('N', 'V', args, dimensions, steps);
+    eig_wrapper('N', 'V', args, dimensions, steps);
 }
 
+template
 static void
-@TYPE@_eigvals(char **args,
+eigvals(char **args,
                npy_intp const *dimensions,
                npy_intp const *steps,
                void *NPY_UNUSED(func))
 {
-    @TYPE@_eig_wrapper('N', 'N', args, dimensions, steps);
+    eig_wrapper('N', 'N', args, dimensions, steps);
 }
 
-/**end repeat**/
 
 
 /* -------------------------------------------------------------------------- */
                  /* singular value decomposition  */
 
-typedef struct gessd_params_struct
+template
+struct GESDD_PARAMS_t
 {
-    void *A;
-    void *S;
-    void *U;
-    void *VT;
-    void *WORK;
-    void *RWORK;
-    void *IWORK;
+    ftyp *A;
+    basetype_t *S;
+    ftyp *U;
+    ftyp *VT;
+    ftyp *WORK;
+    basetype_t *RWORK;
+    fortran_int *IWORK;
 
     fortran_int M;
     fortran_int N;
@@ -2387,12 +2516,13 @@ typedef struct gessd_params_struct
     fortran_int LDVT;
     fortran_int LWORK;
     char JOBZ;
-} GESDD_PARAMS_t;
+} ;
 
 
-static NPY_INLINE void
+template
+static inline void
 dump_gesdd_params(const char *name,
-                  GESDD_PARAMS_t *params)
+                  GESDD_PARAMS_t *params)
 {
     TRACE_TXT("\n%s:\n"\
 
@@ -2433,7 +2563,7 @@ dump_gesdd_params(const char *name,
               "JOBZ", ' ', params->JOBZ);
 }
 
-static NPY_INLINE int
+static inline int
 compute_urows_vtcolumns(char jobz,
                         fortran_int m, fortran_int n,
                         fortran_int *urows, fortran_int *vtcolumns)
@@ -2462,43 +2592,51 @@ compute_urows_vtcolumns(char jobz,
     return 1;
 }
 
-
-/**begin repeat
-   #TYPE = FLOAT, DOUBLE#
-   #lapack_func = sgesdd, dgesdd#
-   #ftyp = fortran_real, fortran_doublereal#
- */
-
-static NPY_INLINE fortran_int
-call_@lapack_func@(GESDD_PARAMS_t *params)
+static inline fortran_int
+call_gesdd(GESDD_PARAMS_t *params)
 {
     fortran_int rv;
-    LAPACK(@lapack_func@)(¶ms->JOBZ, ¶ms->M, ¶ms->N,
+    LAPACK(sgesdd)(¶ms->JOBZ, ¶ms->M, ¶ms->N,
                           params->A, ¶ms->LDA,
                           params->S,
                           params->U, ¶ms->LDU,
                           params->VT, ¶ms->LDVT,
                           params->WORK, ¶ms->LWORK,
-                          params->IWORK,
+                          (fortran_int*)params->IWORK,
+                          &rv);
+    return rv;
+}
+static inline fortran_int
+call_gesdd(GESDD_PARAMS_t *params)
+{
+    fortran_int rv;
+    LAPACK(dgesdd)(¶ms->JOBZ, ¶ms->M, ¶ms->N,
+                          params->A, ¶ms->LDA,
+                          params->S,
+                          params->U, ¶ms->LDU,
+                          params->VT, ¶ms->LDVT,
+                          params->WORK, ¶ms->LWORK,
+                          (fortran_int*)params->IWORK,
                           &rv);
     return rv;
 }
 
-static NPY_INLINE int
-init_@lapack_func@(GESDD_PARAMS_t *params,
+template
+static inline int
+init_gesdd(GESDD_PARAMS_t *params,
                    char jobz,
                    fortran_int m,
-                   fortran_int n)
+                   fortran_int n, scalar_trait)
 {
     npy_uint8 *mem_buff = NULL;
     npy_uint8 *mem_buff2 = NULL;
     npy_uint8 *a, *s, *u, *vt, *work, *iwork;
     size_t safe_m = m;
     size_t safe_n = n;
-    size_t a_size = safe_m * safe_n * sizeof(@ftyp@);
+    size_t a_size = safe_m * safe_n * sizeof(ftyp);
     fortran_int min_m_n = fortran_int_min(m, n);
     size_t safe_min_m_n = min_m_n;
-    size_t s_size = safe_min_m_n * sizeof(@ftyp@);
+    size_t s_size = safe_min_m_n * sizeof(ftyp);
     fortran_int u_row_count, vt_column_count;
     size_t safe_u_row_count, safe_vt_column_count;
     size_t u_size, vt_size;
@@ -2514,10 +2652,10 @@ init_@lapack_func@(GESDD_PARAMS_t *params,
     safe_u_row_count = u_row_count;
     safe_vt_column_count = vt_column_count;
 
-    u_size = safe_u_row_count * safe_m * sizeof(@ftyp@);
-    vt_size = safe_n * safe_vt_column_count * sizeof(@ftyp@);
+    u_size = safe_u_row_count * safe_m * sizeof(ftyp);
+    vt_size = safe_n * safe_vt_column_count * sizeof(ftyp);
 
-    mem_buff = malloc(a_size + s_size + u_size + vt_size + iwork_size);
+    mem_buff = (npy_uint8 *)malloc(a_size + s_size + u_size + vt_size + iwork_size);
 
     if (!mem_buff) {
         goto error;
@@ -2534,12 +2672,12 @@ init_@lapack_func@(GESDD_PARAMS_t *params,
 
     params->M = m;
     params->N = n;
-    params->A = a;
-    params->S = s;
-    params->U = u;
-    params->VT = vt;
+    params->A = (ftyp*)a;
+    params->S = (ftyp*)s;
+    params->U = (ftyp*)u;
+    params->VT = (ftyp*)vt;
     params->RWORK = NULL;
-    params->IWORK = iwork;
+    params->IWORK = (fortran_int*)iwork;
     params->LDA = ld;
     params->LDU = ld;
     params->LDVT = vt_column_count;
@@ -2547,22 +2685,22 @@ init_@lapack_func@(GESDD_PARAMS_t *params,
 
     /* Work size query */
     {
-        @ftyp@ work_size_query;
+        ftyp work_size_query;
 
         params->LWORK = -1;
         params->WORK = &work_size_query;
 
-        if (call_@lapack_func@(params) != 0) {
+        if (call_gesdd(params) != 0) {
             goto error;
         }
 
         work_count = (fortran_int)work_size_query;
         /* Fix a bug in lapack 3.0.0 */
         if(work_count == 0) work_count = 1;
-        work_size = (size_t)work_count * sizeof(@ftyp@);
+        work_size = (size_t)work_count * sizeof(ftyp);
     }
 
-    mem_buff2 = malloc(work_size);
+    mem_buff2 = (npy_uint8 *)malloc(work_size);
     if (!mem_buff2) {
         goto error;
     }
@@ -2570,7 +2708,7 @@ init_@lapack_func@(GESDD_PARAMS_t *params,
     work = mem_buff2;
 
     params->LWORK = work_count;
-    params->WORK = work;
+    params->WORK = (ftyp*)work;
 
     return 1;
  error:
@@ -2582,21 +2720,26 @@ init_@lapack_func@(GESDD_PARAMS_t *params,
     return 0;
 }
 
-/**end repeat**/
-
-/**begin repeat
-   #TYPE = CFLOAT, CDOUBLE#
-   #ftyp = fortran_complex, fortran_doublecomplex#
-   #frealtyp = fortran_real, fortran_doublereal#
-   #typ = COMPLEX_t, DOUBLECOMPLEX_t#
-   #lapack_func = cgesdd, zgesdd#
- */
-
-static NPY_INLINE fortran_int
-call_@lapack_func@(GESDD_PARAMS_t *params)
+static inline fortran_int
+call_gesdd(GESDD_PARAMS_t *params)
+{
+    fortran_int rv;
+    LAPACK(cgesdd)(¶ms->JOBZ, ¶ms->M, ¶ms->N,
+                          params->A, ¶ms->LDA,
+                          params->S,
+                          params->U, ¶ms->LDU,
+                          params->VT, ¶ms->LDVT,
+                          params->WORK, ¶ms->LWORK,
+                          params->RWORK,
+                          params->IWORK,
+                          &rv);
+    return rv;
+}
+static inline fortran_int
+call_gesdd(GESDD_PARAMS_t *params)
 {
     fortran_int rv;
-    LAPACK(@lapack_func@)(¶ms->JOBZ, ¶ms->M, ¶ms->N,
+    LAPACK(zgesdd)(¶ms->JOBZ, ¶ms->M, ¶ms->N,
                           params->A, ¶ms->LDA,
                           params->S,
                           params->U, ¶ms->LDU,
@@ -2608,12 +2751,14 @@ call_@lapack_func@(GESDD_PARAMS_t *params)
     return rv;
 }
 
-static NPY_INLINE int
-init_@lapack_func@(GESDD_PARAMS_t *params,
+template
+static inline int
+init_gesdd(GESDD_PARAMS_t *params,
                    char jobz,
                    fortran_int m,
-                   fortran_int n)
+                   fortran_int n, complex_trait)
 {
+using frealtyp = basetype_t;
     npy_uint8 *mem_buff = NULL, *mem_buff2 = NULL;
     npy_uint8 *a,*s, *u, *vt, *work, *rwork, *iwork;
     size_t a_size, s_size, u_size, vt_size, work_size, rwork_size, iwork_size;
@@ -2632,17 +2777,17 @@ init_@lapack_func@(GESDD_PARAMS_t *params,
     safe_u_row_count = u_row_count;
     safe_vt_column_count = vt_column_count;
 
-    a_size = safe_m * safe_n * sizeof(@ftyp@);
-    s_size = safe_min_m_n * sizeof(@frealtyp@);
-    u_size = safe_u_row_count * safe_m * sizeof(@ftyp@);
-    vt_size = safe_n * safe_vt_column_count * sizeof(@ftyp@);
+    a_size = safe_m * safe_n * sizeof(ftyp);
+    s_size = safe_min_m_n * sizeof(frealtyp);
+    u_size = safe_u_row_count * safe_m * sizeof(ftyp);
+    vt_size = safe_n * safe_vt_column_count * sizeof(ftyp);
     rwork_size = 'N'==jobz?
         (7 * safe_min_m_n) :
         (5*safe_min_m_n * safe_min_m_n + 5*safe_min_m_n);
-    rwork_size *= sizeof(@ftyp@);
+    rwork_size *= sizeof(ftyp);
     iwork_size = 8 * safe_min_m_n* sizeof(fortran_int);
 
-    mem_buff = malloc(a_size +
+    mem_buff = (npy_uint8 *)malloc(a_size +
                       s_size +
                       u_size +
                       vt_size +
@@ -2662,12 +2807,12 @@ init_@lapack_func@(GESDD_PARAMS_t *params,
     /* fix vt_column_count so that it is a valid lapack parameter (0 is not) */
     vt_column_count = fortran_int_max(1, vt_column_count);
 
-    params->A = a;
-    params->S = s;
-    params->U = u;
-    params->VT = vt;
-    params->RWORK = rwork;
-    params->IWORK = iwork;
+    params->A = (ftyp*)a;
+    params->S = (frealtyp*)s;
+    params->U = (ftyp*)u;
+    params->VT = (ftyp*)vt;
+    params->RWORK = (frealtyp*)rwork;
+    params->IWORK = (fortran_int*)iwork;
     params->M = m;
     params->N = n;
     params->LDA = ld;
@@ -2677,22 +2822,22 @@ init_@lapack_func@(GESDD_PARAMS_t *params,
 
     /* Work size query */
     {
-        @ftyp@ work_size_query;
+        ftyp work_size_query;
 
         params->LWORK = -1;
         params->WORK = &work_size_query;
 
-        if (call_@lapack_func@(params) != 0) {
+        if (call_gesdd(params) != 0) {
             goto error;
         }
 
-        work_count = (fortran_int)((@typ@*)&work_size_query)->array[0];
+        work_count = (fortran_int)(*(frealtyp*)&work_size_query);
         /* Fix a bug in lapack 3.0.0 */
         if(work_count == 0) work_count = 1;
-        work_size = (size_t)work_count * sizeof(@ftyp@);
+        work_size = (size_t)work_count * sizeof(ftyp);
     }
 
-    mem_buff2 = malloc(work_size);
+    mem_buff2 = (npy_uint8 *)malloc(work_size);
     if (!mem_buff2) {
         goto error;
     }
@@ -2700,7 +2845,7 @@ init_@lapack_func@(GESDD_PARAMS_t *params,
     work = mem_buff2;
 
     params->LWORK = work_count;
-    params->WORK = work;
+    params->WORK = (ftyp*)work;
 
     return 1;
  error:
@@ -2711,16 +2856,10 @@ init_@lapack_func@(GESDD_PARAMS_t *params,
 
     return 0;
 }
-/**end repeat**/
 
-
-/**begin repeat
-   #TYPE = FLOAT, DOUBLE, CFLOAT, CDOUBLE#
-   #REALTYPE = FLOAT, DOUBLE, FLOAT, DOUBLE#
-   #lapack_func = sgesdd, dgesdd, cgesdd, zgesdd#
- */
-static NPY_INLINE void
-release_@lapack_func@(GESDD_PARAMS_t* params)
+template
+static inline void
+release_gesdd(GESDD_PARAMS_t* params)
 {
     /* A and WORK contain allocated blocks */
     free(params->A);
@@ -2728,28 +2867,31 @@ release_@lapack_func@(GESDD_PARAMS_t* params)
     memset(params, 0, sizeof(*params));
 }
 
-static NPY_INLINE void
-@TYPE@_svd_wrapper(char JOBZ,
+template
+static inline void
+svd_wrapper(char JOBZ,
                    char **args,
                    npy_intp const *dimensions,
                    npy_intp const *steps)
 {
+using basetyp = basetype_t;
     ptrdiff_t outer_steps[4];
     int error_occurred = get_fp_invalid_and_clear();
     size_t iter;
     size_t outer_dim = *dimensions++;
     size_t op_count = (JOBZ=='N')?2:4;
-    GESDD_PARAMS_t params;
+    GESDD_PARAMS_t params;
 
     for (iter = 0; iter < op_count; ++iter) {
         outer_steps[iter] = (ptrdiff_t) steps[iter];
     }
     steps += op_count;
 
-    if (init_@lapack_func@(¶ms,
-                           JOBZ,
-                           (fortran_int)dimensions[0],
-                           (fortran_int)dimensions[1])) {
+    if (init_gesdd(¶ms,
+                   JOBZ,
+                   (fortran_int)dimensions[0],
+                   (fortran_int)dimensions[1],
+dispatch_scalar())) {
         LINEARIZE_DATA_t a_in, u_out, s_out, v_out;
         fortran_int min_m_n = params.M < params.N ? params.M : params.N;
 
@@ -2780,97 +2922,95 @@ static NPY_INLINE void
         for (iter = 0; iter < outer_dim; ++iter) {
             int not_ok;
             /* copy the matrix in */
-            linearize_@TYPE@_matrix(params.A, args[0], &a_in);
-            not_ok = call_@lapack_func@(¶ms);
+            linearize_matrix((typ*)params.A, (typ*)args[0], &a_in);
+            not_ok = call_gesdd(¶ms);
             if (!not_ok) {
                 if ('N' == params.JOBZ) {
-                    delinearize_@REALTYPE@_matrix(args[1], params.S, &s_out);
+                    delinearize_matrix((basetyp*)args[1], (basetyp*)params.S, &s_out);
                 } else {
                     if ('A' == params.JOBZ && min_m_n == 0) {
                         /* Lapack has betrayed us and left these uninitialized,
                          * so produce an identity matrix for whichever of u
                          * and v is not empty.
                          */
-                        identity_@TYPE@_matrix(params.U, params.M);
-                        identity_@TYPE@_matrix(params.VT, params.N);
+                        identity_matrix((typ*)params.U, params.M);
+                        identity_matrix((typ*)params.VT, params.N);
                     }
 
-                    delinearize_@TYPE@_matrix(args[1], params.U, &u_out);
-                    delinearize_@REALTYPE@_matrix(args[2], params.S, &s_out);
-                    delinearize_@TYPE@_matrix(args[3], params.VT, &v_out);
+                    delinearize_matrix((typ*)args[1], (typ*)params.U, &u_out);
+                    delinearize_matrix((basetyp*)args[2], (basetyp*)params.S, &s_out);
+                    delinearize_matrix((typ*)args[3], (typ*)params.VT, &v_out);
                 }
             } else {
                 error_occurred = 1;
                 if ('N' == params.JOBZ) {
-                    nan_@REALTYPE@_matrix(args[1], &s_out);
+                    nan_matrix((basetyp*)args[1], &s_out);
                 } else {
-                    nan_@TYPE@_matrix(args[1], &u_out);
-                    nan_@REALTYPE@_matrix(args[2], &s_out);
-                    nan_@TYPE@_matrix(args[3], &v_out);
+                    nan_matrix((typ*)args[1], &u_out);
+                    nan_matrix((basetyp*)args[2], &s_out);
+                    nan_matrix((typ*)args[3], &v_out);
                 }
             }
             update_pointers((npy_uint8**)args, outer_steps, op_count);
         }
 
-        release_@lapack_func@(¶ms);
+        release_gesdd(¶ms);
     }
 
     set_fp_invalid_or_clear(error_occurred);
 }
-/**end repeat*/
 
 
-/* svd gufunc entry points */
-/**begin repeat
-   #TYPE = FLOAT, DOUBLE, CFLOAT, CDOUBLE#
- */
+template
 static void
-@TYPE@_svd_N(char **args,
+svd_N(char **args,
              npy_intp const *dimensions,
              npy_intp const *steps,
              void *NPY_UNUSED(func))
 {
-    @TYPE@_svd_wrapper('N', args, dimensions, steps);
+    svd_wrapper>('N', args, dimensions, steps);
 }
 
+template
 static void
-@TYPE@_svd_S(char **args,
+svd_S(char **args,
              npy_intp const *dimensions,
              npy_intp const *steps,
              void *NPY_UNUSED(func))
 {
-    @TYPE@_svd_wrapper('S', args, dimensions, steps);
+    svd_wrapper>('S', args, dimensions, steps);
 }
 
+template
 static void
-@TYPE@_svd_A(char **args,
+svd_A(char **args,
              npy_intp const *dimensions,
              npy_intp const *steps,
              void *NPY_UNUSED(func))
 {
-    @TYPE@_svd_wrapper('A', args, dimensions, steps);
+    svd_wrapper>('A', args, dimensions, steps);
 }
 
-/**end repeat**/
-
 /* -------------------------------------------------------------------------- */
                  /* qr (modes - r, raw) */
 
-typedef struct geqfr_params_struct
+template
+struct GEQRF_PARAMS_t
 {
     fortran_int M;
     fortran_int N;
-    void *A;
+    typ *A;
     fortran_int LDA;
-    void* TAU;
-    void *WORK;
+    typ* TAU;
+    typ *WORK;
     fortran_int LWORK;
-} GEQRF_PARAMS_t;
+};
 
 
+template
 static inline void
 dump_geqrf_params(const char *name,
-                  GEQRF_PARAMS_t *params)
+                  GEQRF_PARAMS_t *params)
 {
     TRACE_TXT("\n%s:\n"\
 
@@ -2894,15 +3034,22 @@ dump_geqrf_params(const char *name,
               "LWORK", (int)params->LWORK);
 }
 
-/**begin repeat
-   #lapack_func=dgeqrf,zgeqrf#
- */
-
 static inline fortran_int
-call_@lapack_func@(GEQRF_PARAMS_t *params)
+call_geqrf(GEQRF_PARAMS_t *params)
+{
+    fortran_int rv;
+    LAPACK(dgeqrf)(¶ms->M, ¶ms->N,
+                          params->A, ¶ms->LDA,
+                          params->TAU,
+                          params->WORK, ¶ms->LWORK,
+                          &rv);
+    return rv;
+}
+static inline fortran_int
+call_geqrf(GEQRF_PARAMS_t *params)
 {
     fortran_int rv;
-    LAPACK(@lapack_func@)(¶ms->M, ¶ms->N,
+    LAPACK(zgeqrf)(¶ms->M, ¶ms->N,
                           params->A, ¶ms->LDA,
                           params->TAU,
                           params->WORK, ¶ms->LWORK,
@@ -2910,18 +3057,13 @@ call_@lapack_func@(GEQRF_PARAMS_t *params)
     return rv;
 }
 
-/**end repeat**/
 
-/**begin repeat
-   #TYPE=DOUBLE#
-   #lapack_func=dgeqrf#
-   #ftyp=fortran_doublereal#
- */
 static inline int
-init_@lapack_func@(GEQRF_PARAMS_t *params,
+init_geqrf(GEQRF_PARAMS_t *params,
                    fortran_int m,
                    fortran_int n)
 {
+using ftyp = fortran_doublereal;
     npy_uint8 *mem_buff = NULL;
     npy_uint8 *mem_buff2 = NULL;
     npy_uint8 *a, *tau, *work;
@@ -2930,14 +3072,14 @@ init_@lapack_func@(GEQRF_PARAMS_t *params,
     size_t safe_m = m;
     size_t safe_n = n;
 
-    size_t a_size = safe_m * safe_n * sizeof(@ftyp@);
-    size_t tau_size = safe_min_m_n * sizeof(@ftyp@);
+    size_t a_size = safe_m * safe_n * sizeof(ftyp);
+    size_t tau_size = safe_min_m_n * sizeof(ftyp);
 
     fortran_int work_count;
     size_t work_size;
     fortran_int lda = fortran_int_max(1, m);
 
-    mem_buff = malloc(a_size + tau_size);
+    mem_buff = (npy_uint8 *)malloc(a_size + tau_size);
 
     if (!mem_buff)
         goto error;
@@ -2949,35 +3091,35 @@ init_@lapack_func@(GEQRF_PARAMS_t *params,
 
     params->M = m;
     params->N = n;
-    params->A = a;
-    params->TAU = tau;
+    params->A = (ftyp*)a;
+    params->TAU = (ftyp*)tau;
     params->LDA = lda;
 
     {
         /* compute optimal work size */
 
-        @ftyp@ work_size_query;
+        ftyp work_size_query;
 
         params->WORK = &work_size_query;
         params->LWORK = -1;
 
-        if (call_@lapack_func@(params) != 0)
+        if (call_geqrf(params) != 0)
             goto error;
 
-        work_count = (fortran_int) *(@ftyp@*) params->WORK;
+        work_count = (fortran_int) *(ftyp*) params->WORK;
 
     }
 
     params->LWORK = fortran_int_max(fortran_int_max(1, n), work_count);
 
-    work_size = (size_t) params->LWORK * sizeof(@ftyp@);
-    mem_buff2 = malloc(work_size);
+    work_size = (size_t) params->LWORK * sizeof(ftyp);
+    mem_buff2 = (npy_uint8 *)malloc(work_size);
     if (!mem_buff2)
         goto error;
 
     work = mem_buff2;
 
-    params->WORK = work;
+    params->WORK = (ftyp*)work;
 
     return 1;
  error:
@@ -2989,18 +3131,13 @@ init_@lapack_func@(GEQRF_PARAMS_t *params,
     return 0;
 }
 
-/**end repeat**/
 
-/**begin repeat
-   #TYPE=CDOUBLE#
-   #lapack_func=zgeqrf#
-   #ftyp=fortran_doublecomplex#
- */
 static inline int
-init_@lapack_func@(GEQRF_PARAMS_t *params,
+init_geqrf(GEQRF_PARAMS_t *params,
                    fortran_int m,
                    fortran_int n)
 {
+using ftyp = fortran_doublecomplex;
     npy_uint8 *mem_buff = NULL;
     npy_uint8 *mem_buff2 = NULL;
     npy_uint8 *a, *tau, *work;
@@ -3009,14 +3146,14 @@ init_@lapack_func@(GEQRF_PARAMS_t *params,
     size_t safe_m = m;
     size_t safe_n = n;
 
-    size_t a_size = safe_m * safe_n * sizeof(@ftyp@);
-    size_t tau_size = safe_min_m_n * sizeof(@ftyp@);
+    size_t a_size = safe_m * safe_n * sizeof(ftyp);
+    size_t tau_size = safe_min_m_n * sizeof(ftyp);
 
     fortran_int work_count;
     size_t work_size;
     fortran_int lda = fortran_int_max(1, m);
 
-    mem_buff = malloc(a_size + tau_size);
+    mem_buff = (npy_uint8 *)malloc(a_size + tau_size);
 
     if (!mem_buff)
         goto error;
@@ -3028,37 +3165,37 @@ init_@lapack_func@(GEQRF_PARAMS_t *params,
 
     params->M = m;
     params->N = n;
-    params->A = a;
-    params->TAU = tau;
+    params->A = (ftyp*)a;
+    params->TAU = (ftyp*)tau;
     params->LDA = lda;
 
     {
         /* compute optimal work size */
 
-        @ftyp@ work_size_query;
+        ftyp work_size_query;
 
         params->WORK = &work_size_query;
         params->LWORK = -1;
 
-        if (call_@lapack_func@(params) != 0)
+        if (call_geqrf(params) != 0)
             goto error;
 
-        work_count = (fortran_int) ((@ftyp@*)params->WORK)->r;
+        work_count = (fortran_int) ((ftyp*)params->WORK)->r;
 
     }
 
     params->LWORK = fortran_int_max(fortran_int_max(1, n),
                                     work_count);
 
-    work_size = (size_t) params->LWORK * sizeof(@ftyp@);
+    work_size = (size_t) params->LWORK * sizeof(ftyp);
 
-    mem_buff2 = malloc(work_size);
+    mem_buff2 = (npy_uint8 *)malloc(work_size);
     if (!mem_buff2)
         goto error;
 
     work = mem_buff2;
 
-    params->WORK = work;
+    params->WORK = (ftyp*)work;
 
     return 1;
  error:
@@ -3070,13 +3207,10 @@ init_@lapack_func@(GEQRF_PARAMS_t *params,
     return 0;
 }
 
-/**end repeat**/
 
-/**begin repeat
-   #lapack_func=dgeqrf,zgeqrf#
- */
+template
 static inline void
-release_@lapack_func@(GEQRF_PARAMS_t* params)
+release_geqrf(GEQRF_PARAMS_t* params)
 {
     /* A and WORK contain allocated blocks */
     free(params->A);
@@ -3084,22 +3218,14 @@ release_@lapack_func@(GEQRF_PARAMS_t* params)
     memset(params, 0, sizeof(*params));
 }
 
-/**end repeat**/
-
-/**begin repeat
-   #TYPE=DOUBLE,CDOUBLE#
-   #REALTYPE=DOUBLE,DOUBLE#
-   #lapack_func=dgeqrf,zgeqrf#
-   #typ     = npy_double,npy_cdouble#
-   #basetyp = npy_double,npy_double#
-   #ftyp = fortran_doublereal,fortran_doublecomplex#
-   #cmplx = 0, 1#
- */
+template
 static void
-@TYPE@_qr_r_raw(char **args, npy_intp const *dimensions, npy_intp const *steps,
+qr_r_raw(char **args, npy_intp const *dimensions, npy_intp const *steps,
           void *NPY_UNUSED(func))
 {
-    GEQRF_PARAMS_t params;
+using ftyp = fortran_type_t;
+
+    GEQRF_PARAMS_t params;
     int error_occurred = get_fp_invalid_and_clear();
     fortran_int n, m;
 
@@ -3108,7 +3234,7 @@ static void
     m = (fortran_int)dimensions[0];
     n = (fortran_int)dimensions[1];
 
-    if (init_@lapack_func@(¶ms, m, n)) {
+    if (init_geqrf(¶ms, m, n)) {
         LINEARIZE_DATA_t a_in, tau_out;
 
         init_linearize_data(&a_in, n, m, steps[1], steps[0]);
@@ -3116,50 +3242,57 @@ static void
 
         BEGIN_OUTER_LOOP_2
             int not_ok;
-            linearize_@TYPE@_matrix(params.A, args[0], &a_in);
-            not_ok = call_@lapack_func@(¶ms);
+            linearize_matrix((typ*)params.A, (typ*)args[0], &a_in);
+            not_ok = call_geqrf(¶ms);
             if (!not_ok) {
-                delinearize_@TYPE@_matrix(args[0], params.A, &a_in);
-                delinearize_@TYPE@_matrix(args[1], params.TAU, &tau_out);
+                delinearize_matrix((typ*)args[0], (typ*)params.A, &a_in);
+                delinearize_matrix((typ*)args[1], (typ*)params.TAU, &tau_out);
             } else {
                 error_occurred = 1;
-                nan_@TYPE@_matrix(args[1], &tau_out);
+                nan_matrix((typ*)args[1], &tau_out);
             }
         END_OUTER_LOOP
 
-        release_@lapack_func@(¶ms);
+        release_geqrf(¶ms);
     }
 
     set_fp_invalid_or_clear(error_occurred);
 }
 
-/**end repeat**/
 
 /* -------------------------------------------------------------------------- */
                  /* qr common code (modes - reduced and complete) */ 
 
-typedef struct gqr_params_struct
+template
+struct GQR_PARAMS_t
 {
     fortran_int M;
     fortran_int MC;
     fortran_int MN;
     void* A;
-    void *Q;
+    typ *Q;
     fortran_int LDA;
-    void* TAU;
-    void *WORK;
+    typ* TAU;
+    typ *WORK;
     fortran_int LWORK;
-} GQR_PARAMS_t;
-
-/**begin repeat
-   #lapack_func=dorgqr,zungqr#
- */
+} ;
 
 static inline fortran_int
-call_@lapack_func@(GQR_PARAMS_t *params)
+call_gqr(GQR_PARAMS_t *params)
 {
     fortran_int rv;
-    LAPACK(@lapack_func@)(¶ms->M, ¶ms->MC, ¶ms->MN,
+    LAPACK(dorgqr)(¶ms->M, ¶ms->MC, ¶ms->MN,
+                          params->Q, ¶ms->LDA,
+                          params->TAU,
+                          params->WORK, ¶ms->LWORK,
+                          &rv);
+    return rv;
+}
+static inline fortran_int
+call_gqr(GQR_PARAMS_t *params)
+{
+    fortran_int rv;
+    LAPACK(zungqr)(¶ms->M, ¶ms->MC, ¶ms->MN,
                           params->Q, ¶ms->LDA,
                           params->TAU,
                           params->WORK, ¶ms->LWORK,
@@ -3167,18 +3300,13 @@ call_@lapack_func@(GQR_PARAMS_t *params)
     return rv;
 }
 
-/**end repeat**/
-
-/**begin repeat
-   #lapack_func=dorgqr#
-   #ftyp=fortran_doublereal#
- */
 static inline int
-init_@lapack_func@_common(GQR_PARAMS_t *params,
+init_gqr_common(GQR_PARAMS_t *params,
                           fortran_int m,
                           fortran_int n,
                           fortran_int mc)
 {
+using ftyp = fortran_doublereal;
     npy_uint8 *mem_buff = NULL;
     npy_uint8 *mem_buff2 = NULL;
     npy_uint8 *a, *q, *tau, *work;
@@ -3187,15 +3315,15 @@ init_@lapack_func@_common(GQR_PARAMS_t *params,
     size_t safe_min_m_n = min_m_n;
     size_t safe_m = m;
     size_t safe_n = n;
-    size_t a_size = safe_m * safe_n * sizeof(@ftyp@);
-    size_t q_size = safe_m * safe_mc * sizeof(@ftyp@);
-    size_t tau_size = safe_min_m_n * sizeof(@ftyp@);
+    size_t a_size = safe_m * safe_n * sizeof(ftyp);
+    size_t q_size = safe_m * safe_mc * sizeof(ftyp);
+    size_t tau_size = safe_min_m_n * sizeof(ftyp);
 
     fortran_int work_count;
     size_t work_size;
     fortran_int lda = fortran_int_max(1, m);
 
-    mem_buff = malloc(q_size + tau_size + a_size);
+    mem_buff = (npy_uint8 *)malloc(q_size + tau_size + a_size);
 
     if (!mem_buff)
         goto error;
@@ -3209,35 +3337,35 @@ init_@lapack_func@_common(GQR_PARAMS_t *params,
     params->MC = mc;
     params->MN = min_m_n;
     params->A = a;
-    params->Q = q;
-    params->TAU = tau;
+    params->Q = (ftyp*)q;
+    params->TAU = (ftyp*)tau;
     params->LDA = lda;
 
     {
         /* compute optimal work size */
-        @ftyp@ work_size_query;
+        ftyp work_size_query;
 
         params->WORK = &work_size_query;
         params->LWORK = -1;
 
-        if (call_@lapack_func@(params) != 0)
+        if (call_gqr(params) != 0)
             goto error;
 
-        work_count = (fortran_int) *(@ftyp@*) params->WORK;
+        work_count = (fortran_int) *(ftyp*) params->WORK;
 
     }
 
     params->LWORK = fortran_int_max(fortran_int_max(1, n), work_count);
 
-    work_size = (size_t) params->LWORK * sizeof(@ftyp@);
+    work_size = (size_t) params->LWORK * sizeof(ftyp);
 
-    mem_buff2 = malloc(work_size);
+    mem_buff2 = (npy_uint8 *)malloc(work_size);
     if (!mem_buff2)
         goto error;
 
     work = mem_buff2;
 
-    params->WORK = work;
+    params->WORK = (ftyp*)work;
 
     return 1;
  error:
@@ -3249,18 +3377,14 @@ init_@lapack_func@_common(GQR_PARAMS_t *params,
     return 0;
 }
 
-/**end repeat**/
 
-/**begin repeat
-   #lapack_func=zungqr#
-   #ftyp=fortran_doublecomplex#
- */
 static inline int
-init_@lapack_func@_common(GQR_PARAMS_t *params,
+init_gqr_common(GQR_PARAMS_t *params,
                           fortran_int m,
                           fortran_int n,
                           fortran_int mc)
 {
+using ftyp=fortran_doublecomplex;
     npy_uint8 *mem_buff = NULL;
     npy_uint8 *mem_buff2 = NULL;
     npy_uint8 *a, *q, *tau, *work;
@@ -3270,15 +3394,15 @@ init_@lapack_func@_common(GQR_PARAMS_t *params,
     size_t safe_m = m;
     size_t safe_n = n;
 
-    size_t a_size = safe_m * safe_n * sizeof(@ftyp@);
-    size_t q_size = safe_m * safe_mc * sizeof(@ftyp@);
-    size_t tau_size = safe_min_m_n * sizeof(@ftyp@);
+    size_t a_size = safe_m * safe_n * sizeof(ftyp);
+    size_t q_size = safe_m * safe_mc * sizeof(ftyp);
+    size_t tau_size = safe_min_m_n * sizeof(ftyp);
 
     fortran_int work_count;
     size_t work_size;
     fortran_int lda = fortran_int_max(1, m);
 
-    mem_buff = malloc(q_size + tau_size + a_size);
+    mem_buff = (npy_uint8 *)malloc(q_size + tau_size + a_size);
 
     if (!mem_buff)
         goto error;
@@ -3292,36 +3416,36 @@ init_@lapack_func@_common(GQR_PARAMS_t *params,
     params->MC = mc;
     params->MN = min_m_n;
     params->A = a;
-    params->Q = q;
-    params->TAU = tau;
+    params->Q = (ftyp*)q;
+    params->TAU = (ftyp*)tau;
     params->LDA = lda;
 
     {
         /* compute optimal work size */
-        @ftyp@ work_size_query;
+        ftyp work_size_query;
 
         params->WORK = &work_size_query;
         params->LWORK = -1;
 
-        if (call_@lapack_func@(params) != 0)
+        if (call_gqr(params) != 0)
             goto error;
 
-        work_count = (fortran_int) ((@ftyp@*)params->WORK)->r;
+        work_count = (fortran_int) ((ftyp*)params->WORK)->r;
 
     }
 
     params->LWORK = fortran_int_max(fortran_int_max(1, n),
                                     work_count);
 
-    work_size = (size_t) params->LWORK * sizeof(@ftyp@);
+    work_size = (size_t) params->LWORK * sizeof(ftyp);
 
-    mem_buff2 = malloc(work_size);
+    mem_buff2 = (npy_uint8 *)malloc(work_size);
     if (!mem_buff2)
         goto error;
 
     work = mem_buff2;
 
-    params->WORK = work;
+    params->WORK = (ftyp*)work;
     params->LWORK = work_count;
 
     return 1;
@@ -3334,15 +3458,14 @@ init_@lapack_func@_common(GQR_PARAMS_t *params,
     return 0;
 }
 
-/**end repeat**/
-
 /* -------------------------------------------------------------------------- */
                  /* qr (modes - reduced) */
 
 
+template
 static inline void
 dump_gqr_params(const char *name,
-                GQR_PARAMS_t *params)
+                GQR_PARAMS_t *params)
 {
     TRACE_TXT("\n%s:\n"\
 
@@ -3368,27 +3491,21 @@ dump_gqr_params(const char *name,
               "LWORK", (int)params->LWORK);
 }
 
-/**begin repeat
-   #lapack_func=dorgqr,zungqr#
-   #ftyp=fortran_doublereal,fortran_doublecomplex#
- */
+template
 static inline int
-init_@lapack_func@(GQR_PARAMS_t *params,
+init_gqr(GQR_PARAMS_t *params,
                    fortran_int m,
                    fortran_int n)
 {
-    return init_@lapack_func@_common(
+    return init_gqr_common(
         params, m, n, 
         fortran_int_min(m, n));
 }
 
-/**end repeat**/
 
-/**begin repeat
-   #lapack_func=dorgqr,zungqr#
- */
+template
 static inline void
-release_@lapack_func@(GQR_PARAMS_t* params)
+release_gqr(GQR_PARAMS_t* params)
 {
     /* A and WORK contain allocated blocks */
     free(params->Q);
@@ -3396,22 +3513,13 @@ release_@lapack_func@(GQR_PARAMS_t* params)
     memset(params, 0, sizeof(*params));
 }
 
-/**end repeat**/
-
-/**begin repeat
-   #TYPE=DOUBLE,CDOUBLE#
-   #REALTYPE=DOUBLE,DOUBLE#
-   #lapack_func=dorgqr,zungqr#
-   #typ     = npy_double, npy_cdouble#
-   #basetyp = npy_double, npy_double#
-   #ftyp = fortran_doublereal,fortran_doublecomplex#
-   #cmplx = 0, 1#
- */
+template
 static void
-@TYPE@_qr_reduced(char **args, npy_intp const *dimensions, npy_intp const *steps,
+qr_reduced(char **args, npy_intp const *dimensions, npy_intp const *steps,
                   void *NPY_UNUSED(func))
 {
-    GQR_PARAMS_t params;
+using ftyp = fortran_type_t;
+    GQR_PARAMS_t params;
     int error_occurred = get_fp_invalid_and_clear();
     fortran_int n, m;
 
@@ -3420,7 +3528,7 @@ static void
     m = (fortran_int)dimensions[0];
     n = (fortran_int)dimensions[1];
 
-    if (init_@lapack_func@(¶ms, m, n)) {
+    if (init_gqr(¶ms, m, n)) {
         LINEARIZE_DATA_t a_in, tau_in, q_out;
 
         init_linearize_data(&a_in, n, m, steps[1], steps[0]);
@@ -3429,57 +3537,44 @@ static void
 
         BEGIN_OUTER_LOOP_3
             int not_ok;
-            linearize_@TYPE@_matrix(params.A, args[0], &a_in);
-            linearize_@TYPE@_matrix(params.Q, args[0], &a_in);
-            linearize_@TYPE@_matrix(params.TAU, args[1], &tau_in);
-            not_ok = call_@lapack_func@(¶ms);
+            linearize_matrix((typ*)params.A, (typ*)args[0], &a_in);
+            linearize_matrix((typ*)params.Q, (typ*)args[0], &a_in);
+            linearize_matrix((typ*)params.TAU, (typ*)args[1], &tau_in);
+            not_ok = call_gqr(¶ms);
             if (!not_ok) {
-                delinearize_@TYPE@_matrix(args[2], params.Q, &q_out);
+                delinearize_matrix((typ*)args[2], (typ*)params.Q, &q_out);
             } else {
                 error_occurred = 1;
-                nan_@TYPE@_matrix(args[2], &q_out);
+                nan_matrix((typ*)args[2], &q_out);
             }
         END_OUTER_LOOP
 
-        release_@lapack_func@(¶ms);
+        release_gqr(¶ms);
     }
 
     set_fp_invalid_or_clear(error_occurred);
 }
 
-/**end repeat**/
-
 /* -------------------------------------------------------------------------- */
                  /* qr (modes - complete) */
 
-/**begin repeat
-   #lapack_func=dorgqr,zungqr#
-   #ftyp=fortran_doublereal,fortran_doublecomplex#
- */
+template
 static inline int
-init_@lapack_func@_complete(GQR_PARAMS_t *params,
+init_gqr_complete(GQR_PARAMS_t *params,
                             fortran_int m,
                             fortran_int n)
 {
-    return init_@lapack_func@_common(params, m, n, m);
+    return init_gqr_common(params, m, n, m);
 }
 
-/**end repeat**/
 
-/**begin repeat
-   #TYPE=DOUBLE,CDOUBLE#
-   #REALTYPE=DOUBLE,DOUBLE#
-   #lapack_func=dorgqr,zungqr#
-   #typ     = npy_double,npy_cdouble#
-   #basetyp = npy_double,npy_double#
-   #ftyp = fortran_doublereal,fortran_doublecomplex#
-   #cmplx = 0, 1#
- */
+template
 static void
-@TYPE@_qr_complete(char **args, npy_intp const *dimensions, npy_intp const *steps,
+qr_complete(char **args, npy_intp const *dimensions, npy_intp const *steps,
                   void *NPY_UNUSED(func))
 {
-    GQR_PARAMS_t params;
+using ftyp = fortran_type_t;
+    GQR_PARAMS_t params;
     int error_occurred = get_fp_invalid_and_clear();
     fortran_int n, m;
 
@@ -3489,7 +3584,7 @@ static void
     n = (fortran_int)dimensions[1];
 
 
-    if (init_@lapack_func@_complete(¶ms, m, n)) {
+    if (init_gqr_complete(¶ms, m, n)) {
         LINEARIZE_DATA_t a_in, tau_in, q_out;
 
         init_linearize_data(&a_in, n, m, steps[1], steps[0]);
@@ -3498,51 +3593,50 @@ static void
 
         BEGIN_OUTER_LOOP_3
             int not_ok;
-            linearize_@TYPE@_matrix(params.A, args[0], &a_in);
-            linearize_@TYPE@_matrix(params.Q, args[0], &a_in);
-            linearize_@TYPE@_matrix(params.TAU, args[1], &tau_in);
-            not_ok = call_@lapack_func@(¶ms);
+            linearize_matrix((typ*)params.A, (typ*)args[0], &a_in);
+            linearize_matrix((typ*)params.Q, (typ*)args[0], &a_in);
+            linearize_matrix((typ*)params.TAU, (typ*)args[1], &tau_in);
+            not_ok = call_gqr(¶ms);
             if (!not_ok) {
-                delinearize_@TYPE@_matrix(args[2], params.Q, &q_out);
+                delinearize_matrix((typ*)args[2], (typ*)params.Q, &q_out);
             } else {
                 error_occurred = 1;
-                nan_@TYPE@_matrix(args[2], &q_out);
+                nan_matrix((typ*)args[2], &q_out);
             }
         END_OUTER_LOOP
 
-        release_@lapack_func@(¶ms);
+        release_gqr(¶ms);
     }
 
     set_fp_invalid_or_clear(error_occurred);
 }
 
-/**end repeat**/
-
 /* -------------------------------------------------------------------------- */
                  /* least squares */
 
-typedef struct gelsd_params_struct
+template
+struct GELSD_PARAMS_t
 {
     fortran_int M;
     fortran_int N;
     fortran_int NRHS;
-    void *A;
+    typ *A;
     fortran_int LDA;
-    void *B;
+    typ *B;
     fortran_int LDB;
-    void *S;
-    void *RCOND;
+    basetype_t *S;
+    basetype_t *RCOND;
     fortran_int RANK;
-    void *WORK;
+    typ *WORK;
     fortran_int LWORK;
-    void *RWORK;
-    void *IWORK;
-} GELSD_PARAMS_t;
-
+    basetype_t *RWORK;
+    fortran_int *IWORK;
+};
 
+template
 static inline void
 dump_gelsd_params(const char *name,
-                  GELSD_PARAMS_t *params)
+                  GELSD_PARAMS_t *params)
 {
     TRACE_TXT("\n%s:\n"\
 
@@ -3583,18 +3677,27 @@ dump_gelsd_params(const char *name,
               "RCOND", params->RCOND);
 }
 
+static inline fortran_int
+call_gelsd(GELSD_PARAMS_t *params)
+{
+    fortran_int rv;
+    LAPACK(sgelsd)(¶ms->M, ¶ms->N, ¶ms->NRHS,
+                          params->A, ¶ms->LDA,
+                          params->B, ¶ms->LDB,
+                          params->S,
+                          params->RCOND, ¶ms->RANK,
+                          params->WORK, ¶ms->LWORK,
+                          params->IWORK,
+                          &rv);
+    return rv;
+}
 
-/**begin repeat
-   #TYPE=FLOAT,DOUBLE#
-   #lapack_func=sgelsd,dgelsd#
-   #ftyp=fortran_real,fortran_doublereal#
- */
 
 static inline fortran_int
-call_@lapack_func@(GELSD_PARAMS_t *params)
+call_gelsd(GELSD_PARAMS_t *params)
 {
     fortran_int rv;
-    LAPACK(@lapack_func@)(¶ms->M, ¶ms->N, ¶ms->NRHS,
+    LAPACK(dgelsd)(¶ms->M, ¶ms->N, ¶ms->NRHS,
                           params->A, ¶ms->LDA,
                           params->B, ¶ms->LDB,
                           params->S,
@@ -3605,11 +3708,14 @@ call_@lapack_func@(GELSD_PARAMS_t *params)
     return rv;
 }
 
+
+template
 static inline int
-init_@lapack_func@(GELSD_PARAMS_t *params,
+init_gelsd(GELSD_PARAMS_t *params,
                    fortran_int m,
                    fortran_int n,
-                   fortran_int nrhs)
+                   fortran_int nrhs,
+scalar_trait)
 {
     npy_uint8 *mem_buff = NULL;
     npy_uint8 *mem_buff2 = NULL;
@@ -3622,9 +3728,9 @@ init_@lapack_func@(GELSD_PARAMS_t *params,
     size_t safe_n = n;
     size_t safe_nrhs = nrhs;
 
-    size_t a_size = safe_m * safe_n * sizeof(@ftyp@);
-    size_t b_size = safe_max_m_n * safe_nrhs * sizeof(@ftyp@);
-    size_t s_size = safe_min_m_n * sizeof(@ftyp@);
+    size_t a_size = safe_m * safe_n * sizeof(ftyp);
+    size_t b_size = safe_max_m_n * safe_nrhs * sizeof(ftyp);
+    size_t s_size = safe_min_m_n * sizeof(ftyp);
 
     fortran_int work_count;
     size_t work_size;
@@ -3632,7 +3738,7 @@ init_@lapack_func@(GELSD_PARAMS_t *params,
     fortran_int lda = fortran_int_max(1, m);
     fortran_int ldb = fortran_int_max(1, fortran_int_max(m,n));
 
-    mem_buff = malloc(a_size + b_size + s_size);
+    mem_buff = (npy_uint8 *)malloc(a_size + b_size + s_size);
 
     if (!mem_buff)
         goto error;
@@ -3645,15 +3751,15 @@ init_@lapack_func@(GELSD_PARAMS_t *params,
     params->M = m;
     params->N = n;
     params->NRHS = nrhs;
-    params->A = a;
-    params->B = b;
-    params->S = s;
+    params->A = (ftyp*)a;
+    params->B = (ftyp*)b;
+    params->S = (ftyp*)s;
     params->LDA = lda;
     params->LDB = ldb;
 
     {
         /* compute optimal work size */
-        @ftyp@ work_size_query;
+        ftyp work_size_query;
         fortran_int iwork_size_query;
 
         params->WORK = &work_size_query;
@@ -3661,25 +3767,25 @@ init_@lapack_func@(GELSD_PARAMS_t *params,
         params->RWORK = NULL;
         params->LWORK = -1;
 
-        if (call_@lapack_func@(params) != 0)
+        if (call_gelsd(params) != 0)
             goto error;
 
         work_count = (fortran_int)work_size_query;
 
-        work_size  = (size_t) work_size_query * sizeof(@ftyp@);
+        work_size  = (size_t) work_size_query * sizeof(ftyp);
         iwork_size = (size_t)iwork_size_query * sizeof(fortran_int);
     }
 
-    mem_buff2 = malloc(work_size + iwork_size);
+    mem_buff2 = (npy_uint8 *)malloc(work_size + iwork_size);
     if (!mem_buff2)
         goto error;
 
     work = mem_buff2;
     iwork = work + work_size;
 
-    params->WORK = work;
+    params->WORK = (ftyp*)work;
     params->RWORK = NULL;
-    params->IWORK = iwork;
+    params->IWORK = (fortran_int*)iwork;
     params->LWORK = work_count;
 
     return 1;
@@ -3692,37 +3798,46 @@ init_@lapack_func@(GELSD_PARAMS_t *params,
     return 0;
 }
 
-/**end repeat**/
-
-/**begin repeat
-   #TYPE=CFLOAT,CDOUBLE#
-   #ftyp=fortran_complex,fortran_doublecomplex#
-   #frealtyp=fortran_real,fortran_doublereal#
-   #typ=COMPLEX_t,DOUBLECOMPLEX_t#
-   #lapack_func=cgelsd,zgelsd#
- */
+static inline fortran_int
+call_gelsd(GELSD_PARAMS_t *params)
+{
+    fortran_int rv;
+    LAPACK(cgelsd)(¶ms->M, ¶ms->N, ¶ms->NRHS,
+                          params->A, ¶ms->LDA,
+                          params->B, ¶ms->LDB,
+                          params->S,
+                          params->RCOND, ¶ms->RANK,
+                          params->WORK, ¶ms->LWORK,
+                          params->RWORK, (fortran_int*)params->IWORK,
+                          &rv);
+    return rv;
+}
 
 static inline fortran_int
-call_@lapack_func@(GELSD_PARAMS_t *params)
+call_gelsd(GELSD_PARAMS_t *params)
 {
     fortran_int rv;
-    LAPACK(@lapack_func@)(¶ms->M, ¶ms->N, ¶ms->NRHS,
+    LAPACK(zgelsd)(¶ms->M, ¶ms->N, ¶ms->NRHS,
                           params->A, ¶ms->LDA,
                           params->B, ¶ms->LDB,
                           params->S,
                           params->RCOND, ¶ms->RANK,
                           params->WORK, ¶ms->LWORK,
-                          params->RWORK, params->IWORK,
+                          params->RWORK, (fortran_int*)params->IWORK,
                           &rv);
     return rv;
 }
 
+
+template
 static inline int
-init_@lapack_func@(GELSD_PARAMS_t *params,
+init_gelsd(GELSD_PARAMS_t *params,
                    fortran_int m,
                    fortran_int n,
-                   fortran_int nrhs)
+                   fortran_int nrhs,
+complex_trait)
 {
+using frealtyp = basetype_t;
     npy_uint8 *mem_buff = NULL;
     npy_uint8 *mem_buff2 = NULL;
     npy_uint8 *a, *b, *s, *work, *iwork, *rwork;
@@ -3734,16 +3849,16 @@ init_@lapack_func@(GELSD_PARAMS_t *params,
     size_t safe_n = n;
     size_t safe_nrhs = nrhs;
 
-    size_t a_size = safe_m * safe_n * sizeof(@ftyp@);
-    size_t b_size = safe_max_m_n * safe_nrhs * sizeof(@ftyp@);
-    size_t s_size = safe_min_m_n * sizeof(@frealtyp@);
+    size_t a_size = safe_m * safe_n * sizeof(ftyp);
+    size_t b_size = safe_max_m_n * safe_nrhs * sizeof(ftyp);
+    size_t s_size = safe_min_m_n * sizeof(frealtyp);
 
     fortran_int work_count;
     size_t work_size, rwork_size, iwork_size;
     fortran_int lda = fortran_int_max(1, m);
     fortran_int ldb = fortran_int_max(1, fortran_int_max(m,n));
 
-    mem_buff = malloc(a_size + b_size + s_size);
+    mem_buff = (npy_uint8 *)malloc(a_size + b_size + s_size);
 
     if (!mem_buff)
         goto error;
@@ -3756,16 +3871,16 @@ init_@lapack_func@(GELSD_PARAMS_t *params,
     params->M = m;
     params->N = n;
     params->NRHS = nrhs;
-    params->A = a;
-    params->B = b;
-    params->S = s;
+    params->A = (ftyp*)a;
+    params->B = (ftyp*)b;
+    params->S = (frealtyp*)s;
     params->LDA = lda;
     params->LDB = ldb;
 
     {
         /* compute optimal work size */
-        @ftyp@ work_size_query;
-        @frealtyp@ rwork_size_query;
+        ftyp work_size_query;
+        frealtyp rwork_size_query;
         fortran_int iwork_size_query;
 
         params->WORK = &work_size_query;
@@ -3773,17 +3888,17 @@ init_@lapack_func@(GELSD_PARAMS_t *params,
         params->RWORK = &rwork_size_query;
         params->LWORK = -1;
 
-        if (call_@lapack_func@(params) != 0)
+        if (call_gelsd(params) != 0)
             goto error;
 
         work_count = (fortran_int)work_size_query.r;
 
-        work_size  = (size_t )work_size_query.r * sizeof(@ftyp@);
-        rwork_size = (size_t)rwork_size_query * sizeof(@frealtyp@);
+        work_size  = (size_t )work_size_query.r * sizeof(ftyp);
+        rwork_size = (size_t)rwork_size_query * sizeof(frealtyp);
         iwork_size = (size_t)iwork_size_query * sizeof(fortran_int);
     }
 
-    mem_buff2 = malloc(work_size + rwork_size + iwork_size);
+    mem_buff2 = (npy_uint8 *)malloc(work_size + rwork_size + iwork_size);
     if (!mem_buff2)
         goto error;
 
@@ -3791,9 +3906,9 @@ init_@lapack_func@(GELSD_PARAMS_t *params,
     rwork = work + work_size;
     iwork = rwork + rwork_size;
 
-    params->WORK = work;
-    params->RWORK = rwork;
-    params->IWORK = iwork;
+    params->WORK = (ftyp*)work;
+    params->RWORK = (frealtyp*)rwork;
+    params->IWORK = (fortran_int*)iwork;
     params->LWORK = work_count;
 
     return 1;
@@ -3806,22 +3921,9 @@ init_@lapack_func@(GELSD_PARAMS_t *params,
     return 0;
 }
 
-/**end repeat**/
-
-
-/**begin repeat
-   #TYPE=FLOAT,DOUBLE,CFLOAT,CDOUBLE#
-   #REALTYPE=FLOAT,DOUBLE,FLOAT,DOUBLE#
-   #lapack_func=sgelsd,dgelsd,cgelsd,zgelsd#
-   #dot_func=sdot,ddot,cdotc,zdotc#
-   #typ     = npy_float, npy_double, npy_cfloat, npy_cdouble#
-   #basetyp = npy_float, npy_double, npy_float,  npy_double#
-   #ftyp = fortran_real, fortran_doublereal,
-           fortran_complex, fortran_doublecomplex#
-   #cmplx = 0, 0, 1, 1#
- */
+template
 static inline void
-release_@lapack_func@(GELSD_PARAMS_t* params)
+release_gelsd(GELSD_PARAMS_t* params)
 {
     /* A and WORK contain allocated blocks */
     free(params->A);
@@ -3830,26 +3932,38 @@ release_@lapack_func@(GELSD_PARAMS_t* params)
 }
 
 /** Compute the squared l2 norm of a contiguous vector */
-static @basetyp@
-@TYPE@_abs2(@typ@ *p, npy_intp n) {
+template
+static basetype_t
+abs2(typ *p, npy_intp n, scalar_trait) {
     npy_intp i;
-    @basetyp@ res = 0;
+    basetype_t res = 0;
     for (i = 0; i < n; i++) {
-        @typ@ el = p[i];
-#if @cmplx@
-        res += el.real*el.real + el.imag*el.imag;
-#else
+        typ el = p[i];
         res += el*el;
-#endif
+    }
+    return res;
+}
+template
+static basetype_t
+abs2(typ *p, npy_intp n, complex_trait) {
+    npy_intp i;
+    basetype_t res = 0;
+    for (i = 0; i < n; i++) {
+        typ el = p[i];
+        res += el.real*el.real + el.imag*el.imag;
     }
     return res;
 }
 
+
+template
 static void
-@TYPE@_lstsq(char **args, npy_intp const *dimensions, npy_intp const *steps,
+lstsq(char **args, npy_intp const *dimensions, npy_intp const *steps,
              void *NPY_UNUSED(func))
 {
-    GELSD_PARAMS_t params;
+using ftyp = fortran_type_t;
+using basetyp = basetype_t;
+    GELSD_PARAMS_t params;
     int error_occurred = get_fp_invalid_and_clear();
     fortran_int n, m, nrhs;
     fortran_int excess;
@@ -3861,7 +3975,7 @@ static void
     nrhs = (fortran_int)dimensions[2];
     excess = m - n;
 
-    if (init_@lapack_func@(¶ms, m, n, nrhs)) {
+    if (init_gelsd(¶ms, m, n, nrhs, dispatch_scalar{})) {
         LINEARIZE_DATA_t a_in, b_in, x_out, s_out, r_out;
 
         init_linearize_data(&a_in, n, m, steps[1], steps[0]);
@@ -3872,52 +3986,51 @@ static void
 
         BEGIN_OUTER_LOOP_7
             int not_ok;
-            linearize_@TYPE@_matrix(params.A, args[0], &a_in);
-            linearize_@TYPE@_matrix(params.B, args[1], &b_in);
-            params.RCOND = args[2];
-            not_ok = call_@lapack_func@(¶ms);
+            linearize_matrix((typ*)params.A, (typ*)args[0], &a_in);
+            linearize_matrix((typ*)params.B, (typ*)args[1], &b_in);
+            params.RCOND = (basetyp*)args[2];
+            not_ok = call_gelsd(¶ms);
             if (!not_ok) {
-                delinearize_@TYPE@_matrix(args[3], params.B, &x_out);
+                delinearize_matrix((typ*)args[3], (typ*)params.B, &x_out);
                 *(npy_int*) args[5] = params.RANK;
-                delinearize_@REALTYPE@_matrix(args[6], params.S, &s_out);
+                delinearize_matrix((basetyp*)args[6], (basetyp*)params.S, &s_out);
 
                 /* Note that linalg.lstsq discards this when excess == 0 */
                 if (excess >= 0 && params.RANK == n) {
                     /* Compute the residuals as the square sum of each column */
                     int i;
                     char *resid = args[4];
-                    @ftyp@ *components = (@ftyp@ *)params.B + n;
+                    ftyp *components = (ftyp *)params.B + n;
                     for (i = 0; i < nrhs; i++) {
-                        @ftyp@ *vector = components + i*m;
+                        ftyp *vector = components + i*m;
                         /* Numpy and fortran floating types are the same size,
                          * so this cast is safe */
-                        @basetyp@ abs2 = @TYPE@_abs2((@typ@ *)vector, excess);
+                        basetyp abs = abs2((typ *)vector, excess,
+dispatch_scalar{});
                         memcpy(
                             resid + i*r_out.column_strides,
-                            &abs2, sizeof(abs2));
+                            &abs, sizeof(abs));
                     }
                 }
                 else {
                     /* Note that this is always discarded by linalg.lstsq */
-                    nan_@REALTYPE@_matrix(args[4], &r_out);
+                    nan_matrix((basetyp*)args[4], &r_out);
                 }
             } else {
                 error_occurred = 1;
-                nan_@TYPE@_matrix(args[3], &x_out);
-                nan_@REALTYPE@_matrix(args[4], &r_out);
+                nan_matrix((typ*)args[3], &x_out);
+                nan_matrix((basetyp*)args[4], &r_out);
                 *(npy_int*) args[5] = -1;
-                nan_@REALTYPE@_matrix(args[6], &s_out);
+                nan_matrix((basetyp*)args[6], &s_out);
             }
         END_OUTER_LOOP
 
-        release_@lapack_func@(¶ms);
+        release_gelsd(¶ms);
     }
 
     set_fp_invalid_or_clear(error_occurred);
 }
 
-/**end repeat**/
-
 #pragma GCC diagnostic pop
 
 /* -------------------------------------------------------------------------- */
@@ -3962,6 +4075,22 @@ static void *array_of_nulls[] = {
         CFLOAT_ ## NAME,                                \
         CDOUBLE_ ## NAME                                \
     }
+#define GUFUNC_FUNC_ARRAY_REAL_COMPLEX_(NAME)            \
+    static PyUFuncGenericFunction                       \
+    FUNC_ARRAY_NAME(NAME)[] = {                         \
+        NAME,                                 \
+        NAME,                                \
+        NAME,                                \
+        NAME                                \
+    }
+#define GUFUNC_FUNC_ARRAY_REAL_COMPLEX__(NAME)            \
+    static PyUFuncGenericFunction                       \
+    FUNC_ARRAY_NAME(NAME)[] = {                         \
+        NAME,                                 \
+        NAME,                                \
+        NAME,                                \
+        NAME                                \
+    }
 
 /* There are problems with eig in complex single precision.
  * That kernel is disabled
@@ -3969,9 +4098,9 @@ static void *array_of_nulls[] = {
 #define GUFUNC_FUNC_ARRAY_EIG(NAME)                     \
     static PyUFuncGenericFunction                       \
     FUNC_ARRAY_NAME(NAME)[] = {                         \
-        FLOAT_ ## NAME,                                 \
-        DOUBLE_ ## NAME,                                \
-        CDOUBLE_ ## NAME                                \
+        NAME,                                 \
+        NAME,                                \
+        NAME                                \
     }
 
 /* The single precision functions are not used at all,
@@ -3984,25 +4113,31 @@ static void *array_of_nulls[] = {
         DOUBLE_ ## NAME,                                \
         CDOUBLE_ ## NAME                                \
     }
+#define GUFUNC_FUNC_ARRAY_QR__(NAME)                      \
+    static PyUFuncGenericFunction                       \
+    FUNC_ARRAY_NAME(NAME)[] = {                         \
+        NAME,                                \
+        NAME                                \
+    }
 
 
-GUFUNC_FUNC_ARRAY_REAL_COMPLEX(slogdet);
-GUFUNC_FUNC_ARRAY_REAL_COMPLEX(det);
-GUFUNC_FUNC_ARRAY_REAL_COMPLEX(eighlo);
-GUFUNC_FUNC_ARRAY_REAL_COMPLEX(eighup);
-GUFUNC_FUNC_ARRAY_REAL_COMPLEX(eigvalshlo);
-GUFUNC_FUNC_ARRAY_REAL_COMPLEX(eigvalshup);
-GUFUNC_FUNC_ARRAY_REAL_COMPLEX(solve);
-GUFUNC_FUNC_ARRAY_REAL_COMPLEX(solve1);
-GUFUNC_FUNC_ARRAY_REAL_COMPLEX(inv);
-GUFUNC_FUNC_ARRAY_REAL_COMPLEX(cholesky_lo);
-GUFUNC_FUNC_ARRAY_REAL_COMPLEX(svd_N);
-GUFUNC_FUNC_ARRAY_REAL_COMPLEX(svd_S);
-GUFUNC_FUNC_ARRAY_REAL_COMPLEX(svd_A);
-GUFUNC_FUNC_ARRAY_QR(qr_r_raw);
-GUFUNC_FUNC_ARRAY_QR(qr_reduced);
-GUFUNC_FUNC_ARRAY_QR(qr_complete);
-GUFUNC_FUNC_ARRAY_REAL_COMPLEX(lstsq);
+GUFUNC_FUNC_ARRAY_REAL_COMPLEX_(slogdet);
+GUFUNC_FUNC_ARRAY_REAL_COMPLEX_(det);
+GUFUNC_FUNC_ARRAY_REAL_COMPLEX__(eighlo);
+GUFUNC_FUNC_ARRAY_REAL_COMPLEX__(eighup);
+GUFUNC_FUNC_ARRAY_REAL_COMPLEX__(eigvalshlo);
+GUFUNC_FUNC_ARRAY_REAL_COMPLEX__(eigvalshup);
+GUFUNC_FUNC_ARRAY_REAL_COMPLEX__(solve);
+GUFUNC_FUNC_ARRAY_REAL_COMPLEX__(solve1);
+GUFUNC_FUNC_ARRAY_REAL_COMPLEX__(inv);
+GUFUNC_FUNC_ARRAY_REAL_COMPLEX__(cholesky_lo);
+GUFUNC_FUNC_ARRAY_REAL_COMPLEX__(svd_N);
+GUFUNC_FUNC_ARRAY_REAL_COMPLEX__(svd_S);
+GUFUNC_FUNC_ARRAY_REAL_COMPLEX__(svd_A);
+GUFUNC_FUNC_ARRAY_QR__(qr_r_raw);
+GUFUNC_FUNC_ARRAY_QR__(qr_reduced);
+GUFUNC_FUNC_ARRAY_QR__(qr_complete);
+GUFUNC_FUNC_ARRAY_REAL_COMPLEX__(lstsq);
 GUFUNC_FUNC_ARRAY_EIG(eig);
 GUFUNC_FUNC_ARRAY_EIG(eigvals);
 
@@ -4095,9 +4230,9 @@ static char lstsq_types[] = {
 };
 
 typedef struct gufunc_descriptor_struct {
-    char *name;
-    char *signature;
-    char *doc;
+    const char *name;
+    const char *signature;
+    const char *doc;
     int ntypes;
     int nin;
     int nout;
@@ -4396,13 +4531,12 @@ static struct PyModuleDef moduledef = {
         NULL
 };
 
-PyObject *PyInit__umath_linalg(void)
+PyMODINIT_FUNC PyInit__umath_linalg(void)
 {
     PyObject *m;
     PyObject *d;
     PyObject *version;
 
-    init_constants();
     m = PyModule_Create(&moduledef);
     if (m == NULL) {
         return NULL;
diff --git a/numpy/ma/__init__.pyi b/numpy/ma/__init__.pyi
index 26d44b508c47..7f5cb56a80d6 100644
--- a/numpy/ma/__init__.pyi
+++ b/numpy/ma/__init__.pyi
@@ -1,5 +1,3 @@
-from typing import Any, List
-
 from numpy._pytesttester import PytestTester
 
 from numpy.ma import extras as extras
@@ -218,6 +216,7 @@ from numpy.ma.extras import (
     masked_all_like as masked_all_like,
     median as median,
     mr_ as mr_,
+    ndenumerate as ndenumerate,
     notmasked_contiguous as notmasked_contiguous,
     notmasked_edges as notmasked_edges,
     polyfit as polyfit,
@@ -231,6 +230,6 @@ from numpy.ma.extras import (
     vstack as vstack,
 )
 
-__all__: List[str]
-__path__: List[str]
+__all__: list[str]
+__path__: list[str]
 test: PytestTester
diff --git a/numpy/ma/core.py b/numpy/ma/core.py
index 491c2c60550f..acf1a04441d6 100644
--- a/numpy/ma/core.py
+++ b/numpy/ma/core.py
@@ -31,6 +31,7 @@
 import numpy as np
 import numpy.core.umath as umath
 import numpy.core.numerictypes as ntypes
+from numpy.core import multiarray as mu
 from numpy import ndarray, amax, amin, iscomplexobj, bool_, _NoValue
 from numpy import array as narray
 from numpy.lib.function_base import angle
@@ -174,7 +175,7 @@ class MaskError(MAError):
                   'S': b'N/A',
                   'u': 999999,
                   'V': b'???',
-                  'U': u'N/A'
+                  'U': 'N/A'
                   }
 
 # Add datetime64 and timedelta64 types
@@ -200,7 +201,13 @@ def _recursive_fill_value(dtype, f):
     Recursively produce a fill value for `dtype`, calling f on scalar dtypes
     """
     if dtype.names is not None:
-        vals = tuple(_recursive_fill_value(dtype[name], f) for name in dtype.names)
+        # We wrap into `array` here, which ensures we use NumPy cast rules
+        # for integer casts, this allows the use of 99999 as a fill value
+        # for int8.
+        # TODO: This is probably a mess, but should best preserve behavior?
+        vals = tuple(
+                np.array(_recursive_fill_value(dtype[name], f))
+                for name in dtype.names)
         return np.array(vals, dtype=dtype)[()]  # decay to void scalar from 0d
     elif dtype.subdtype:
         subtype, shape = dtype.subdtype
@@ -405,7 +412,7 @@ def _recursive_set_fill_value(fillvalue, dt):
 
     Returns
     -------
-    val: tuple
+    val : tuple
         A tuple of values corresponding to the structured fill value.
 
     """
@@ -2074,9 +2081,11 @@ def masked_equal(x, value, copy=True):
     """
     Mask an array where equal to a given value.
 
-    This function is a shortcut to ``masked_where``, with
-    `condition` = (x == value).  For floating point arrays,
-    consider using ``masked_values(x, value)``.
+    Return a MaskedArray, masked where the data in array `x` are
+    equal to `value`. The fill_value of the returned MaskedArray
+    is set to `value`.
+
+    For floating point arrays, consider using ``masked_values(x, value)``.
 
     See Also
     --------
@@ -2296,25 +2305,17 @@ def masked_values(x, value, rtol=1e-5, atol=1e-8, copy=True, shrink=True):
 
     Note that `mask` is set to ``nomask`` if possible.
 
-    >>> ma.masked_values(x, 1.5)
+    >>> ma.masked_values(x, 2.1)
     masked_array(data=[1. , 1.1, 2. , 1.1, 3. ],
                  mask=False,
-           fill_value=1.5)
+           fill_value=2.1)
 
-    For integers, the fill value will be different in general to the
-    result of ``masked_equal``.
+    Unlike `masked_equal`, `masked_values` can perform approximate equalities. 
 
-    >>> x = np.arange(5)
-    >>> x
-    array([0, 1, 2, 3, 4])
-    >>> ma.masked_values(x, 2)
-    masked_array(data=[0, 1, --, 3, 4],
+    >>> ma.masked_values(x, 2.1, atol=1e-1)
+    masked_array(data=[1.0, 1.1, --, 1.1, 3.0],
                  mask=[False, False,  True, False, False],
-           fill_value=2)
-    >>> ma.masked_equal(x, 2)
-    masked_array(data=[0, 1, --, 3, 4],
-                 mask=[False, False,  True, False, False],
-           fill_value=2)
+           fill_value=2.1)
 
     """
     xnew = filled(x, value)
@@ -2355,20 +2356,13 @@ def masked_invalid(a, copy=True):
            fill_value=1e+20)
 
     """
-    a = np.array(a, copy=copy, subok=True)
-    mask = getattr(a, '_mask', None)
-    if mask is not None:
-        condition = ~(np.isfinite(getdata(a)))
-        if mask is not nomask:
-            condition |= mask
-        cls = type(a)
-    else:
-        condition = ~(np.isfinite(a))
-        cls = MaskedArray
-    result = a.view(cls)
-    result._mask = condition
-    return result
-
+    a = np.array(a, copy=False, subok=True)
+    res = masked_where(~(np.isfinite(a)), a, copy=copy)
+    # masked_invalid previously never returned nomask as a mask and doing so
+    # threw off matplotlib (gh-22842).  So use shrink=False:
+    if res._mask is nomask:
+        res._mask = make_mask_none(res.shape, res.dtype)
+    return res
 
 ###############################################################################
 #                            Printing options                                 #
@@ -2842,7 +2836,7 @@ def __new__(cls, data=None, mask=nomask, dtype=None, copy=False,
         # still has the _mask attribute like MaskedArrays
         if hasattr(data, '_mask') and not isinstance(data, ndarray):
             _data._mask = data._mask
-            # FIXME: should we set `_data._sharedmask = True`? 
+            # FIXME: should we set `_data._sharedmask = True`?
         # Process mask.
         # Type of the mask
         mdtype = make_mask_descr(_data.dtype)
@@ -3334,6 +3328,10 @@ def _scalar_heuristic(arr, elem):
                 # Note: Don't try to check for m.any(), that'll take too long
         return dout
 
+    # setitem may put NaNs into integer arrays or occasionally overflow a
+    # float.  But this may happen in masked values, so avoid otherwise
+    # correct warnings (as is typical also in masked calculations).
+    @np.errstate(over='ignore', invalid='ignore')
     def __setitem__(self, indx, value):
         """
         x.__setitem__(i, y) <==> x[i]=y
@@ -3542,15 +3540,17 @@ def recordmask(self, mask):
 
     def harden_mask(self):
         """
-        Force the mask to hard.
+        Force the mask to hard, preventing unmasking by assignment.
 
         Whether the mask of a masked array is hard or soft is determined by
         its `~ma.MaskedArray.hardmask` property. `harden_mask` sets
-        `~ma.MaskedArray.hardmask` to ``True``.
+        `~ma.MaskedArray.hardmask` to ``True`` (and returns the modified
+        self).
 
         See Also
         --------
         ma.MaskedArray.hardmask
+        ma.MaskedArray.soften_mask
 
         """
         self._hardmask = True
@@ -3558,15 +3558,17 @@ def harden_mask(self):
 
     def soften_mask(self):
         """
-        Force the mask to soft.
+        Force the mask to soft (default), allowing unmasking by assignment.
 
         Whether the mask of a masked array is hard or soft is determined by
         its `~ma.MaskedArray.hardmask` property. `soften_mask` sets
-        `~ma.MaskedArray.hardmask` to ``False``.
+        `~ma.MaskedArray.hardmask` to ``False`` (and returns the modified
+        self).
 
         See Also
         --------
         ma.MaskedArray.hardmask
+        ma.MaskedArray.harden_mask
 
         """
         self._hardmask = False
@@ -3574,16 +3576,55 @@ def soften_mask(self):
 
     @property
     def hardmask(self):
-        """ Hardness of the mask """
+        """
+        Specifies whether values can be unmasked through assignments.
+
+        By default, assigning definite values to masked array entries will
+        unmask them.  When `hardmask` is ``True``, the mask will not change
+        through assignments.
+
+        See Also
+        --------
+        ma.MaskedArray.harden_mask
+        ma.MaskedArray.soften_mask
+
+        Examples
+        --------
+        >>> x = np.arange(10)
+        >>> m = np.ma.masked_array(x, x>5)
+        >>> assert not m.hardmask
+
+        Since `m` has a soft mask, assigning an element value unmasks that
+        element:
+
+        >>> m[8] = 42
+        >>> m
+        masked_array(data=[0, 1, 2, 3, 4, 5, --, --, 42, --],
+                     mask=[False, False, False, False, False, False,
+                           True, True, False, True],
+               fill_value=999999)
+
+        After hardening, the mask is not affected by assignments:
+
+        >>> hardened = np.ma.harden_mask(m)
+        >>> assert m.hardmask and hardened is m
+        >>> m[:] = 23
+        >>> m
+        masked_array(data=[23, 23, 23, 23, 23, 23, --, --, 23, --],
+                     mask=[False, False, False, False, False, False,
+                           True, True, False, True],
+               fill_value=999999)
+
+        """
         return self._hardmask
 
     def unshare_mask(self):
         """
-        Copy the mask and set the sharedmask flag to False.
+        Copy the mask and set the `sharedmask` flag to ``False``.
 
         Whether the mask is shared between masked arrays can be seen from
-        the `sharedmask` property. `unshare_mask` ensures the mask is not shared.
-        A copy of the mask is only made if it was shared.
+        the `sharedmask` property. `unshare_mask` ensures the mask is not
+        shared. A copy of the mask is only made if it was shared.
 
         See Also
         --------
@@ -4058,6 +4099,10 @@ def _comparison(self, other, compare):
 
         odata = getdata(other)
         if mask.dtype.names is not None:
+            # only == and != are reasonably defined for structured dtypes,
+            # so give up early for all other comparisons:
+            if compare not in (operator.eq, operator.ne):
+                return NotImplemented
             # For possibly masked structured arrays we need to be careful,
             # since the standard structured array comparison will use all
             # fields, masked or not. To avoid masked fields influencing the
@@ -4080,10 +4125,11 @@ def _comparison(self, other, compare):
         if isinstance(check, (np.bool_, bool)):
             return masked if mask else check
 
-        if mask is not nomask:
+        if mask is not nomask and compare in (operator.eq, operator.ne):
             # Adjust elements that were masked, which should be treated
             # as equal if masked in both, unequal if masked in one.
             # Note that this works automatically for structured arrays too.
+            # Ignore this for operations other than `==` and `!=`
             check = np.where(mask, compare(smask, omask), check)
             if mask.shape != check.shape:
                 # Guarantee consistency of the shape, making a copy since the
@@ -4131,6 +4177,19 @@ def __ne__(self, other):
         """
         return self._comparison(other, operator.ne)
 
+    # All other comparisons:
+    def __le__(self, other):
+        return self._comparison(other, operator.le)
+
+    def __lt__(self, other):
+        return self._comparison(other, operator.lt)
+
+    def __ge__(self, other):
+        return self._comparison(other, operator.ge)
+
+    def __gt__(self, other):
+        return self._comparison(other, operator.gt)
+
     def __add__(self, other):
         """
         Add self to other, and return a new masked array.
@@ -4250,8 +4309,9 @@ def __iadd__(self, other):
         else:
             if m is not nomask:
                 self._mask += m
-        self._data.__iadd__(np.where(self._mask, self.dtype.type(0),
-                                     getdata(other)))
+        other_data = getdata(other)
+        other_data = np.where(self._mask, other_data.dtype.type(0), other_data)
+        self._data.__iadd__(other_data)
         return self
 
     def __isub__(self, other):
@@ -4266,8 +4326,9 @@ def __isub__(self, other):
                 self._mask += m
         elif m is not nomask:
             self._mask += m
-        self._data.__isub__(np.where(self._mask, self.dtype.type(0),
-                                     getdata(other)))
+        other_data = getdata(other)
+        other_data = np.where(self._mask, other_data.dtype.type(0), other_data)
+        self._data.__isub__(other_data)
         return self
 
     def __imul__(self, other):
@@ -4282,8 +4343,9 @@ def __imul__(self, other):
                 self._mask += m
         elif m is not nomask:
             self._mask += m
-        self._data.__imul__(np.where(self._mask, self.dtype.type(1),
-                                     getdata(other)))
+        other_data = getdata(other)
+        other_data = np.where(self._mask, other_data.dtype.type(1), other_data)
+        self._data.__imul__(other_data)
         return self
 
     def __idiv__(self, other):
@@ -4295,13 +4357,14 @@ def __idiv__(self, other):
         dom_mask = _DomainSafeDivide().__call__(self._data, other_data)
         other_mask = getmask(other)
         new_mask = mask_or(other_mask, dom_mask)
-        # The following 3 lines control the domain filling
+        # The following 4 lines control the domain filling
         if dom_mask.any():
             (_, fval) = ufunc_fills[np.divide]
-            other_data = np.where(dom_mask, fval, other_data)
+            other_data = np.where(
+                    dom_mask, other_data.dtype.type(fval), other_data)
         self._mask |= new_mask
-        self._data.__idiv__(np.where(self._mask, self.dtype.type(1),
-                                     other_data))
+        other_data = np.where(self._mask, other_data.dtype.type(1), other_data)
+        self._data.__idiv__(other_data)
         return self
 
     def __ifloordiv__(self, other):
@@ -4316,10 +4379,11 @@ def __ifloordiv__(self, other):
         # The following 3 lines control the domain filling
         if dom_mask.any():
             (_, fval) = ufunc_fills[np.floor_divide]
-            other_data = np.where(dom_mask, fval, other_data)
+            other_data = np.where(
+                    dom_mask, other_data.dtype.type(fval), other_data)
         self._mask |= new_mask
-        self._data.__ifloordiv__(np.where(self._mask, self.dtype.type(1),
-                                          other_data))
+        other_data = np.where(self._mask, other_data.dtype.type(1), other_data)
+        self._data.__ifloordiv__(other_data)
         return self
 
     def __itruediv__(self, other):
@@ -4334,10 +4398,11 @@ def __itruediv__(self, other):
         # The following 3 lines control the domain filling
         if dom_mask.any():
             (_, fval) = ufunc_fills[np.true_divide]
-            other_data = np.where(dom_mask, fval, other_data)
+            other_data = np.where(
+                    dom_mask, other_data.dtype.type(fval), other_data)
         self._mask |= new_mask
-        self._data.__itruediv__(np.where(self._mask, self.dtype.type(1),
-                                         other_data))
+        other_data = np.where(self._mask, other_data.dtype.type(1), other_data)
+        self._data.__itruediv__(other_data)
         return self
 
     def __ipow__(self, other):
@@ -4346,10 +4411,10 @@ def __ipow__(self, other):
 
         """
         other_data = getdata(other)
+        other_data = np.where(self._mask, other_data.dtype.type(1), other_data)
         other_mask = getmask(other)
         with np.errstate(divide='ignore', invalid='ignore'):
-            self._data.__ipow__(np.where(self._mask, self.dtype.type(1),
-                                         other_data))
+            self._data.__ipow__(other_data)
         invalid = np.logical_not(np.isfinite(self._data))
         if invalid.any():
             if self._mask is not nomask:
@@ -4558,6 +4623,7 @@ def ravel(self, order='C'):
             otherwise.  'K' means to read the elements in the order they occur
             in memory, except for reversing the data when strides are negative.
             By default, 'C' index order is used.
+            (Masked arrays currently use 'A' on the data when 'K' is passed.)
 
         Returns
         -------
@@ -4584,6 +4650,13 @@ def ravel(self, order='C'):
                fill_value=999999)
 
         """
+        # The order of _data and _mask could be different (it shouldn't be
+        # normally).  Passing order `K` or `A` would be incorrect.
+        # So we ignore the mask memory order.
+        # TODO: We don't actually support K, so use A instead.  We could
+        #       try to guess this correct by sorting strides or deprecate.
+        if order in "kKaA":
+            order = "C" if self._data.flags.fnc else "F"
         r = ndarray.ravel(self._data, order=order).view(type(self))
         r._update_from(self)
         if self._mask is not nomask:
@@ -4811,7 +4884,6 @@ def iscontiguous(self):
           WRITEABLE : True
           ALIGNED : True
           WRITEBACKIFCOPY : False
-          UPDATEIFCOPY : False
 
         """
         return self.flags['CONTIGUOUS']
@@ -5241,14 +5313,22 @@ def mean(self, axis=None, dtype=None, out=None, keepdims=np._NoValue):
 
         """
         kwargs = {} if keepdims is np._NoValue else {'keepdims': keepdims}
-
         if self._mask is nomask:
             result = super().mean(axis=axis, dtype=dtype, **kwargs)[()]
         else:
+            is_float16_result = False
+            if dtype is None:
+                if issubclass(self.dtype.type, (ntypes.integer, ntypes.bool_)):
+                    dtype = mu.dtype('f8')
+                elif issubclass(self.dtype.type, ntypes.float16):
+                    dtype = mu.dtype('f4')
+                    is_float16_result = True
             dsum = self.sum(axis=axis, dtype=dtype, **kwargs)
             cnt = self.count(axis=axis, **kwargs)
             if cnt.shape == () and (cnt == 0):
                 result = masked
+            elif is_float16_result:
+                result = self.dtype.type(dsum * 1. / cnt)
             else:
                 result = dsum * 1. / cnt
         if out is not None:
@@ -5666,9 +5746,12 @@ def min(self, axis=None, out=None, fill_value=None, keepdims=np._NoValue):
 
         Parameters
         ----------
-        axis : {None, int}, optional
+        axis : None or int or tuple of ints, optional
             Axis along which to operate.  By default, ``axis`` is None and the
             flattened input is used.
+            .. versionadded:: 1.7.0
+            If this is a tuple of ints, the minimum is selected over multiple
+            axes, instead of a single axis or all the axes as before.
         out : array_like, optional
             Alternative output array in which to place the result.  Must be of
             the same shape and buffer length as the expected output.
@@ -5691,6 +5774,36 @@ def min(self, axis=None, out=None, fill_value=None, keepdims=np._NoValue):
         ma.minimum_fill_value
             Returns the minimum filling value for a given datatype.
 
+        Examples
+        --------
+        >>> import numpy.ma as ma
+        >>> x = [[1., -2., 3.], [0.2, -0.7, 0.1]]
+        >>> mask = [[1, 1, 0], [0, 0, 1]]
+        >>> masked_x = ma.masked_array(x, mask)
+        >>> masked_x
+        masked_array(
+          data=[[--, --, 3.0],
+                [0.2, -0.7, --]],
+          mask=[[ True,  True, False],
+                [False, False,  True]],
+          fill_value=1e+20)
+        >>> ma.min(masked_x)
+        -0.7
+        >>> ma.min(masked_x, axis=-1)
+        masked_array(data=[3.0, -0.7],
+                     mask=[False, False],
+                fill_value=1e+20)
+        >>> ma.min(masked_x, axis=0, keepdims=True)
+        masked_array(data=[[0.2, -0.7, 3.0]],
+                     mask=[[False, False, False]],
+                fill_value=1e+20)
+        >>> mask = [[1, 1, 1,], [1, 1, 1]]
+        >>> masked_x = ma.masked_array(x, mask)
+        >>> ma.min(masked_x, axis=0)
+        masked_array(data=[--, --, --],
+                     mask=[ True,  True,  True],
+                fill_value=1e+20,
+                    dtype=float64)
         """
         kwargs = {} if keepdims is np._NoValue else {'keepdims': keepdims}
 
@@ -5726,83 +5839,18 @@ def min(self, axis=None, out=None, fill_value=None, keepdims=np._NoValue):
             np.copyto(out, np.nan, where=newmask)
         return out
 
-    # unique to masked arrays
-    def mini(self, axis=None):
-        """
-        Return the array minimum along the specified axis.
-
-        .. deprecated:: 1.13.0
-           This function is identical to both:
-
-            * ``self.min(keepdims=True, axis=axis).squeeze(axis=axis)``
-            * ``np.ma.minimum.reduce(self, axis=axis)``
-
-           Typically though, ``self.min(axis=axis)`` is sufficient.
-
-        Parameters
-        ----------
-        axis : int, optional
-            The axis along which to find the minima. Default is None, in which case
-            the minimum value in the whole array is returned.
-
-        Returns
-        -------
-        min : scalar or MaskedArray
-            If `axis` is None, the result is a scalar. Otherwise, if `axis` is
-            given and the array is at least 2-D, the result is a masked array with
-            dimension one smaller than the array on which `mini` is called.
-
-        Examples
-        --------
-        >>> x = np.ma.array(np.arange(6), mask=[0 ,1, 0, 0, 0 ,1]).reshape(3, 2)
-        >>> x
-        masked_array(
-          data=[[0, --],
-                [2, 3],
-                [4, --]],
-          mask=[[False,  True],
-                [False, False],
-                [False,  True]],
-          fill_value=999999)
-        >>> x.mini()
-        masked_array(data=0,
-                     mask=False,
-               fill_value=999999)
-        >>> x.mini(axis=0)
-        masked_array(data=[0, 3],
-                     mask=[False, False],
-               fill_value=999999)
-        >>> x.mini(axis=1)
-        masked_array(data=[0, 2, 4],
-                     mask=[False, False, False],
-               fill_value=999999)
-
-        There is a small difference between `mini` and `min`:
-
-        >>> x[:,1].mini(axis=0)
-        masked_array(data=3,
-                     mask=False,
-               fill_value=999999)
-        >>> x[:,1].min(axis=0)
-        3
-        """
-
-        # 2016-04-13, 1.13.0, gh-8764
-        warnings.warn(
-            "`mini` is deprecated; use the `min` method or "
-            "`np.ma.minimum.reduce instead.",
-            DeprecationWarning, stacklevel=2)
-        return minimum.reduce(self, axis)
-
     def max(self, axis=None, out=None, fill_value=None, keepdims=np._NoValue):
         """
         Return the maximum along a given axis.
 
         Parameters
         ----------
-        axis : {None, int}, optional
+        axis : None or int or tuple of ints, optional
             Axis along which to operate.  By default, ``axis`` is None and the
             flattened input is used.
+            .. versionadded:: 1.7.0
+            If this is a tuple of ints, the maximum is selected over multiple
+            axes, instead of a single axis or all the axes as before.
         out : array_like, optional
             Alternative output array in which to place the result.  Must
             be of the same shape and buffer length as the expected output.
@@ -5825,6 +5873,43 @@ def max(self, axis=None, out=None, fill_value=None, keepdims=np._NoValue):
         ma.maximum_fill_value
             Returns the maximum filling value for a given datatype.
 
+        Examples
+        --------
+        >>> import numpy.ma as ma
+        >>> x = [[-1., 2.5], [4., -2.], [3., 0.]]
+        >>> mask = [[0, 0], [1, 0], [1, 0]]
+        >>> masked_x = ma.masked_array(x, mask)
+        >>> masked_x
+        masked_array(
+          data=[[-1.0, 2.5],
+                [--, -2.0],
+                [--, 0.0]],
+          mask=[[False, False],
+                [ True, False],
+                [ True, False]],
+          fill_value=1e+20)
+        >>> ma.max(masked_x)
+        2.5
+        >>> ma.max(masked_x, axis=0)
+        masked_array(data=[-1.0, 2.5],
+                     mask=[False, False],
+               fill_value=1e+20)
+        >>> ma.max(masked_x, axis=1, keepdims=True)
+        masked_array(
+          data=[[2.5],
+                [-2.0],
+                [0.0]],
+          mask=[[False],
+                [False],
+                [False]],
+          fill_value=1e+20)
+        >>> mask = [[1, 1], [1, 1], [1, 1]]
+        >>> masked_x = ma.masked_array(x, mask)
+        >>> ma.max(masked_x, axis=1)
+        masked_array(data=[--, --, --],
+                     mask=[ True,  True,  True],
+               fill_value=1e+20,
+                    dtype=float64)
         """
         kwargs = {} if keepdims is np._NoValue else {'keepdims': keepdims}
 
@@ -6638,15 +6723,9 @@ def __init__(self, ufunc, compare, fill_value):
         self.compare = compare
         self.fill_value_func = fill_value
 
-    def __call__(self, a, b=None):
+    def __call__(self, a, b):
         "Executes the call behavior."
-        if b is None:
-            # 2016-04-13, 1.13.0
-            warnings.warn(
-                f"Single-argument form of np.ma.{self.__name__} is deprecated. Use "
-                f"np.ma.{self.__name__}.reduce instead.",
-                DeprecationWarning, stacklevel=2)
-            return self.reduce(a)
+
         return where(self.compare(a, b), a, b)
 
     def reduce(self, target, axis=np._NoValue):
@@ -6832,6 +6911,32 @@ def power(a, b, third=None):
     The *out* argument to `numpy.power` is not supported, `third` has to be
     None.
 
+    Examples
+    --------
+    >>> import numpy.ma as ma
+    >>> x = [11.2, -3.973, 0.801, -1.41]
+    >>> mask = [0, 0, 0, 1]
+    >>> masked_x = ma.masked_array(x, mask)
+    >>> masked_x
+    masked_array(data=[11.2, -3.973, 0.801, --],
+             mask=[False, False, False,  True],
+       fill_value=1e+20)
+    >>> ma.power(masked_x, 2)
+    masked_array(data=[125.43999999999998, 15.784728999999999,
+                   0.6416010000000001, --],
+             mask=[False, False, False,  True],
+       fill_value=1e+20)
+    >>> y = [-0.5, 2, 0, 17]
+    >>> masked_y = ma.masked_array(y, mask)
+    >>> masked_y
+    masked_array(data=[-0.5, 2.0, 0.0, --],
+             mask=[False, False, False,  True],
+       fill_value=1e+20)
+    >>> ma.power(masked_x, masked_y)
+    masked_array(data=[0.29880715233359845, 15.784728999999999, 1.0, --],
+             mask=[False, False, False,  True],
+       fill_value=1e+20)
+
     """
     if third is not None:
         raise MaskError("3-argument power not supported.")
@@ -7441,6 +7546,28 @@ def round_(a, decimals=0, out=None):
     If out is given and does not have a mask attribute, the mask of a
     is lost!
 
+    Examples
+    --------
+    >>> import numpy.ma as ma
+    >>> x = [11.2, -3.973, 0.801, -1.41]
+    >>> mask = [0, 0, 0, 1]
+    >>> masked_x = ma.masked_array(x, mask)
+    >>> masked_x
+    masked_array(data=[11.2, -3.973, 0.801, --],
+                 mask=[False, False, False, True],
+        fill_value=1e+20)
+    >>> ma.round_(masked_x)
+    masked_array(data=[11.0, -4.0, 1.0, --],
+                 mask=[False, False, False, True],
+        fill_value=1e+20)
+    >>> ma.round(masked_x, decimals=1)
+    masked_array(data=[11.2, -4.0, 0.8, --],
+                 mask=[False, False, False, True],
+        fill_value=1e+20)
+    >>> ma.round_(masked_x, decimals=-1)
+    masked_array(data=[10.0, -0.0, 0.0, --],
+                 mask=[False, False, False, True],
+        fill_value=1e+20)
     """
     if out is None:
         return np.round_(a, decimals, out)
@@ -8009,12 +8136,6 @@ def asanyarray(a, dtype=None):
 #                               Pickling                                     #
 ##############################################################################
 
-def _pickle_warn(method):
-    # NumPy 1.15.0, 2017-12-10
-    warnings.warn(
-        f"np.ma.{method} is deprecated, use pickle.{method} instead",
-        DeprecationWarning, stacklevel=3)
-
 
 def fromfile(file, dtype=float, count=-1, sep=''):
     raise NotImplementedError(
@@ -8160,7 +8281,7 @@ def __call__(self, *args, **params):
 
 
 arange = _convert2ma(
-    'arange', 
+    'arange',
     params=dict(fill_value=None, hardmask=False),
     np_ret='arange : ndarray',
     np_ma_ret='arange : MaskedArray',
@@ -8178,7 +8299,7 @@ def __call__(self, *args, **params):
     np_ma_ret='diff : MaskedArray',
 )
 empty = _convert2ma(
-    'empty', 
+    'empty',
     params=dict(fill_value=None, hardmask=False),
     np_ret='out : ndarray',
     np_ma_ret='out : MaskedArray',
@@ -8199,7 +8320,7 @@ def __call__(self, *args, **params):
    np_ma_ret='fromfunction: MaskedArray',
 )
 identity = _convert2ma(
-    'identity', 
+    'identity',
     params=dict(fill_value=None, hardmask=False),
     np_ret='out : ndarray',
     np_ma_ret='out : MaskedArray',
diff --git a/numpy/ma/core.pyi b/numpy/ma/core.pyi
index bc1f45a8d5ad..d5d4f7f36320 100644
--- a/numpy/ma/core.pyi
+++ b/numpy/ma/core.pyi
@@ -1,4 +1,5 @@
-from typing import Any, List, TypeVar, Callable
+from collections.abc import Callable
+from typing import Any, TypeVar
 from numpy import ndarray, dtype, float64
 
 from numpy import (
@@ -23,7 +24,7 @@ from numpy.lib.function_base import (
 _ShapeType = TypeVar("_ShapeType", bound=Any)
 _DType_co = TypeVar("_DType_co", bound=dtype[Any], covariant=True)
 
-__all__: List[str]
+__all__: list[str]
 
 MaskType = bool_
 nomask: bool_
@@ -219,6 +220,10 @@ class MaskedArray(ndarray[_ShapeType, _DType_co]):
     def compress(self, condition, axis=..., out=...): ...
     def __eq__(self, other): ...
     def __ne__(self, other): ...
+    def __ge__(self, other): ...
+    def __gt__(self, other): ...
+    def __le__(self, other): ...
+    def __lt__(self, other): ...
     def __add__(self, other): ...
     def __radd__(self, other): ...
     def __sub__(self, other): ...
@@ -275,7 +280,6 @@ class MaskedArray(ndarray[_ShapeType, _DType_co]):
     def sort(self, axis=..., kind=..., order=..., endwith=..., fill_value=...): ...
     def min(self, axis=..., out=..., fill_value=..., keepdims=...): ...
     # NOTE: deprecated
-    # def mini(self, axis=...): ...
     # def tostring(self, fill_value=..., order=...): ...
     def max(self, axis=..., out=..., fill_value=..., keepdims=...): ...
     def ptp(self, axis=..., out=..., fill_value=..., keepdims=...): ...
diff --git a/numpy/ma/extras.py b/numpy/ma/extras.py
index 38bf1f0e8395..41bce0f22328 100644
--- a/numpy/ma/extras.py
+++ b/numpy/ma/extras.py
@@ -10,12 +10,12 @@
 """
 __all__ = [
     'apply_along_axis', 'apply_over_axes', 'atleast_1d', 'atleast_2d',
-    'atleast_3d', 'average', 'clump_masked', 'clump_unmasked',
-    'column_stack', 'compress_cols', 'compress_nd', 'compress_rowcols',
-    'compress_rows', 'count_masked', 'corrcoef', 'cov', 'diagflat', 'dot',
-    'dstack', 'ediff1d', 'flatnotmasked_contiguous', 'flatnotmasked_edges',
-    'hsplit', 'hstack', 'isin', 'in1d', 'intersect1d', 'mask_cols', 'mask_rowcols',
-    'mask_rows', 'masked_all', 'masked_all_like', 'median', 'mr_',
+    'atleast_3d', 'average', 'clump_masked', 'clump_unmasked', 'column_stack',
+    'compress_cols', 'compress_nd', 'compress_rowcols', 'compress_rows',
+    'count_masked', 'corrcoef', 'cov', 'diagflat', 'dot', 'dstack', 'ediff1d',
+    'flatnotmasked_contiguous', 'flatnotmasked_edges', 'hsplit', 'hstack',
+    'isin', 'in1d', 'intersect1d', 'mask_cols', 'mask_rowcols', 'mask_rows',
+    'masked_all', 'masked_all_like', 'median', 'mr_', 'ndenumerate',
     'notmasked_contiguous', 'notmasked_edges', 'polyfit', 'row_stack',
     'setdiff1d', 'setxor1d', 'stack', 'unique', 'union1d', 'vander', 'vstack',
     ]
@@ -110,8 +110,8 @@ def masked_all(shape, dtype=float):
 
     Parameters
     ----------
-    shape : tuple
-        Shape of the required MaskedArray.
+    shape : int or tuple of ints
+        Shape of the required MaskedArray, e.g., ``(2, 3)`` or ``2``.
     dtype : dtype, optional
         Data type of the output.
 
@@ -475,6 +475,7 @@ def apply_over_axes(func, a, axes):
                         "an array of the correct shape")
     return val
 
+
 if apply_over_axes.__doc__ is not None:
     apply_over_axes.__doc__ = np.apply_over_axes.__doc__[
         :np.apply_over_axes.__doc__.find('Notes')].rstrip() + \
@@ -524,7 +525,8 @@ def apply_over_axes(func, a, axes):
     """
 
 
-def average(a, axis=None, weights=None, returned=False):
+def average(a, axis=None, weights=None, returned=False, *,
+            keepdims=np._NoValue):
     """
     Return the weighted average of array over the given axis.
 
@@ -550,6 +552,14 @@ def average(a, axis=None, weights=None, returned=False):
         Flag indicating whether a tuple ``(result, sum of weights)``
         should be returned as output (True), or just the result (False).
         Default is False.
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the original `a`.
+        *Note:* `keepdims` will not work with instances of `numpy.matrix`
+        or other classes whose methods do not support `keepdims`.
+
+        .. versionadded:: 1.23.0
 
     Returns
     -------
@@ -582,17 +592,32 @@ def average(a, axis=None, weights=None, returned=False):
                  mask=[False, False],
            fill_value=1e+20)
 
+    With ``keepdims=True``, the following result has shape (3, 1).
+
+    >>> np.ma.average(x, axis=1, keepdims=True)
+    masked_array(
+      data=[[0.5],
+            [2.5],
+            [4.5]],
+      mask=False,
+      fill_value=1e+20)
     """
     a = asarray(a)
     m = getmask(a)
 
     # inspired by 'average' in numpy/lib/function_base.py
 
+    if keepdims is np._NoValue:
+        # Don't pass on the keepdims argument if one wasn't given.
+        keepdims_kw = {}
+    else:
+        keepdims_kw = {'keepdims': keepdims}
+
     if weights is None:
-        avg = a.mean(axis)
+        avg = a.mean(axis, **keepdims_kw)
         scl = avg.dtype.type(a.count(axis))
     else:
-        wgt = np.asanyarray(weights)
+        wgt = asarray(weights)
 
         if issubclass(a.dtype.type, (np.integer, np.bool_)):
             result_dtype = np.result_type(a.dtype, wgt.dtype, 'f8')
@@ -618,9 +643,11 @@ def average(a, axis=None, weights=None, returned=False):
 
         if m is not nomask:
             wgt = wgt*(~a.mask)
+            wgt.mask |= a.mask
 
-        scl = wgt.sum(axis=axis, dtype=result_dtype)
-        avg = np.multiply(a, wgt, dtype=result_dtype).sum(axis)/scl
+        scl = wgt.sum(axis=axis, dtype=result_dtype, **keepdims_kw)
+        avg = np.multiply(a, wgt,
+                          dtype=result_dtype).sum(axis, **keepdims_kw) / scl
 
     if returned:
         if scl.shape != avg.shape:
@@ -705,12 +732,9 @@ def median(a, axis=None, out=None, overwrite_input=False, keepdims=False):
         else:
             return m
 
-    r, k = _ureduce(a, func=_median, axis=axis, out=out,
+    return _ureduce(a, func=_median, keepdims=keepdims, axis=axis, out=out,
                     overwrite_input=overwrite_input)
-    if keepdims:
-        return r.reshape(k)
-    else:
-        return r
+
 
 def _median(a, axis=None, out=None, overwrite_input=False):
     # when an unmasked NaN is present return it, so we need to sort the NaN
@@ -839,6 +863,7 @@ def compress_nd(x, axis=None):
         data = data[(slice(None),)*ax + (~m.any(axis=axes),)]
     return data
 
+
 def compress_rowcols(x, axis=None):
     """
     Suppress the rows and/or columns of a 2-D array that contain
@@ -911,6 +936,7 @@ def compress_rows(a):
         raise NotImplementedError("compress_rows works for 2D arrays only.")
     return compress_rowcols(a, 0)
 
+
 def compress_cols(a):
     """
     Suppress whole columns of a 2-D array that contain masked values.
@@ -928,6 +954,7 @@ def compress_cols(a):
         raise NotImplementedError("compress_cols works for 2D arrays only.")
     return compress_rowcols(a, 1)
 
+
 def mask_rows(a, axis=np._NoValue):
     """
     Mask rows of a 2D array that contain masked values.
@@ -978,6 +1005,7 @@ def mask_rows(a, axis=np._NoValue):
             "will raise TypeError", DeprecationWarning, stacklevel=2)
     return mask_rowcols(a, 0)
 
+
 def mask_cols(a, axis=np._NoValue):
     """
     Mask columns of a 2D array that contain masked values.
@@ -1072,6 +1100,32 @@ def unique(ar1, return_index=False, return_inverse=False):
     --------
     numpy.unique : Equivalent function for ndarrays.
 
+    Examples
+    --------
+    >>> import numpy.ma as ma
+    >>> a = [1, 2, 1000, 2, 3]
+    >>> mask = [0, 0, 1, 0, 0]
+    >>> masked_a = ma.masked_array(a, mask)
+    >>> masked_a
+    masked_array(data=[1, 2, --, 2, 3],
+                mask=[False, False,  True, False, False],
+        fill_value=999999)
+    >>> ma.unique(masked_a)
+    masked_array(data=[1, 2, 3, --],
+                mask=[False, False, False,  True],
+        fill_value=999999)
+    >>> ma.unique(masked_a, return_index=True)
+    (masked_array(data=[1, 2, 3, --],
+                mask=[False, False, False,  True],
+        fill_value=999999), array([0, 1, 4, 2]))
+    >>> ma.unique(masked_a, return_inverse=True)
+    (masked_array(data=[1, 2, 3, --],
+                mask=[False, False, False,  True],
+        fill_value=999999), array([0, 1, 3, 1, 2]))
+    >>> ma.unique(masked_a, return_index=True, return_inverse=True)
+    (masked_array(data=[1, 2, 3, --],
+                mask=[False, False, False,  True],
+        fill_value=999999), array([0, 1, 4, 2]), array([0, 1, 3, 1, 2]))
     """
     output = np.unique(ar1,
                        return_index=return_index,
@@ -1515,10 +1569,79 @@ def __init__(self):
 
 mr_ = mr_class()
 
+
 #####--------------------------------------------------------------------------
 #---- Find unmasked data ---
 #####--------------------------------------------------------------------------
 
+def ndenumerate(a, compressed=True):
+    """
+    Multidimensional index iterator.
+
+    Return an iterator yielding pairs of array coordinates and values,
+    skipping elements that are masked. With `compressed=False`,
+    `ma.masked` is yielded as the value of masked elements. This
+    behavior differs from that of `numpy.ndenumerate`, which yields the
+    value of the underlying data array.
+
+    Notes
+    -----
+    .. versionadded:: 1.23.0
+
+    Parameters
+    ----------
+    a : array_like
+        An array with (possibly) masked elements.
+    compressed : bool, optional
+        If True (default), masked elements are skipped.
+
+    See Also
+    --------
+    numpy.ndenumerate : Equivalent function ignoring any mask.
+
+    Examples
+    --------
+    >>> a = np.ma.arange(9).reshape((3, 3))
+    >>> a[1, 0] = np.ma.masked
+    >>> a[1, 2] = np.ma.masked
+    >>> a[2, 1] = np.ma.masked
+    >>> a
+    masked_array(
+      data=[[0, 1, 2],
+            [--, 4, --],
+            [6, --, 8]],
+      mask=[[False, False, False],
+            [ True, False,  True],
+            [False,  True, False]],
+      fill_value=999999)
+    >>> for index, x in np.ma.ndenumerate(a):
+    ...     print(index, x)
+    (0, 0) 0
+    (0, 1) 1
+    (0, 2) 2
+    (1, 1) 4
+    (2, 0) 6
+    (2, 2) 8
+
+    >>> for index, x in np.ma.ndenumerate(a, compressed=False):
+    ...     print(index, x)
+    (0, 0) 0
+    (0, 1) 1
+    (0, 2) 2
+    (1, 0) --
+    (1, 1) 4
+    (1, 2) --
+    (2, 0) 6
+    (2, 1) --
+    (2, 2) 8
+    """
+    for it, mask in zip(np.ndenumerate(a), getmaskarray(a).flat):
+        if not mask:
+            yield it
+        elif not compressed:
+            yield it[0], masked
+
+
 def flatnotmasked_edges(a):
     """
     Find the indices of the first and last unmasked values.
@@ -1627,11 +1750,11 @@ def notmasked_edges(a, axis=None):
 
 def flatnotmasked_contiguous(a):
     """
-    Find contiguous unmasked data in a masked array along the given axis.
+    Find contiguous unmasked data in a masked array.
 
     Parameters
     ----------
-    a : narray
+    a : array_like
         The input array.
 
     Returns
@@ -1681,6 +1804,7 @@ def flatnotmasked_contiguous(a):
         i += n
     return result
 
+
 def notmasked_contiguous(a, axis=None):
     """
     Find contiguous unmasked data in a masked array along the given axis.
@@ -1742,7 +1866,7 @@ def notmasked_contiguous(a, axis=None):
     a = asarray(a)
     nd = a.ndim
     if nd > 2:
-        raise NotImplementedError("Currently limited to atmost 2D array.")
+        raise NotImplementedError("Currently limited to at most 2D array.")
     if axis is None or nd == 1:
         return flatnotmasked_contiguous(a)
     #
diff --git a/numpy/ma/extras.pyi b/numpy/ma/extras.pyi
index e58e43badf23..56228b927080 100644
--- a/numpy/ma/extras.pyi
+++ b/numpy/ma/extras.pyi
@@ -1,4 +1,4 @@
-from typing import Any, List
+from typing import Any
 from numpy.lib.index_tricks import AxisConcatenator
 
 from numpy.ma.core import (
@@ -6,7 +6,7 @@ from numpy.ma.core import (
     mask_rowcols as mask_rowcols,
 )
 
-__all__: List[str]
+__all__: list[str]
 
 def count_masked(arr, axis=...): ...
 def masked_all(shape, dtype = ...): ...
@@ -44,7 +44,7 @@ diagflat: _fromnxfunction_single
 
 def apply_along_axis(func1d, axis, arr, *args, **kwargs): ...
 def apply_over_axes(func, a, axes): ...
-def average(a, axis=..., weights=..., returned=...): ...
+def average(a, axis=..., weights=..., returned=..., keepdims=...): ...
 def median(a, axis=..., out=..., overwrite_input=..., keepdims=...): ...
 def compress_nd(x, axis=...): ...
 def compress_rowcols(x, axis=...): ...
@@ -74,6 +74,7 @@ class mr_class(MAxisConcatenator):
 
 mr_: mr_class
 
+def ndenumerate(a, compressed=...): ...
 def flatnotmasked_edges(a): ...
 def notmasked_edges(a, axis=...): ...
 def flatnotmasked_contiguous(a): ...
diff --git a/numpy/ma/mrecords.pyi b/numpy/ma/mrecords.pyi
index 7bd8678cf12d..264807e05d57 100644
--- a/numpy/ma/mrecords.pyi
+++ b/numpy/ma/mrecords.pyi
@@ -1,9 +1,9 @@
-from typing import List, Any, TypeVar
+from typing import Any, TypeVar
 
 from numpy import dtype
 from numpy.ma import MaskedArray
 
-__all__: List[str]
+__all__: list[str]
 
 # TODO: Set the `bound` to something more suitable once we
 # have proper shape support
@@ -84,7 +84,7 @@ def fromtextfile(
     varnames=...,
     vartypes=...,
     # NOTE: deprecated: NumPy 1.22.0, 2021-09-23
-    # delimitor=..., 
+    # delimitor=...,
 ): ...
 
 def addfield(mrecord, newfield, newfieldname=...): ...
diff --git a/numpy/ma/tests/test_core.py b/numpy/ma/tests/test_core.py
index bf95c999a953..6c03e0ba23a1 100644
--- a/numpy/ma/tests/test_core.py
+++ b/numpy/ma/tests/test_core.py
@@ -21,8 +21,9 @@
 import numpy.core.fromnumeric as fromnumeric
 import numpy.core.umath as umath
 from numpy.testing import (
-    assert_raises, assert_warns, suppress_warnings
+    assert_raises, assert_warns, suppress_warnings, IS_WASM
     )
+from numpy.testing._private.utils import requires_memory
 from numpy import ndarray
 from numpy.compat import asbytes
 from numpy.ma.testutils import (
@@ -66,7 +67,7 @@
 class TestMaskedArray:
     # Base test class for MaskedArrays.
 
-    def setup(self):
+    def setup_method(self):
         # Base data definition.
         x = np.array([1., 1., 1., -2., pi/2.0, 4., 5., -10., 10., 1., 2., 3.])
         y = np.array([5., 0., 3., 2., -1., -4., 0., -10., 10., 1., 0., 3.])
@@ -373,6 +374,24 @@ def test_indexing(self):
         assert_equal(s1, s2)
         assert_(x1[1:1].shape == (0,))
 
+    def test_setitem_no_warning(self):
+        # Setitem shouldn't warn, because the assignment might be masked
+        # and warning for a masked assignment is weird (see gh-23000)
+        # (When the value is masked, otherwise a warning would be acceptable
+        # but is not given currently.)
+        x = np.ma.arange(60).reshape((6, 10))
+        index = (slice(1, 5, 2), [7, 5])
+        value = np.ma.masked_all((2, 2))
+        value._data[...] = np.inf  # not a valid integer...
+        x[index] = value
+        # The masked scalar is special cased, but test anyway (it's NaN):
+        x[...] = np.ma.masked
+        # Finally, a large value that cannot be cast to the float32 `x`
+        x = np.ma.arange(3., dtype=np.float32)
+        value = np.ma.array([2e234, 1, 1], mask=[True, False, False])
+        x[...] = value
+        x[[0, 1, 2]] = value
+
     @suppress_copy_mask_on_assignment
     def test_copy(self):
         # Tests of some subtle points of copying and sizing.
@@ -589,14 +608,14 @@ def test_str_repr_legacy(self):
             np.set_printoptions(**oldopts)
 
     def test_0d_unicode(self):
-        u = u'caf\xe9'
+        u = 'caf\xe9'
         utype = type(u)
 
         arr_nomask = np.ma.array(u)
         arr_masked = np.ma.array(u, mask=True)
 
         assert_equal(utype(arr_nomask), u)
-        assert_equal(utype(arr_masked), u'--')
+        assert_equal(utype(arr_masked), '--')
 
     def test_pickling(self):
         # Tests pickling
@@ -997,7 +1016,7 @@ def test_object_with_array(self):
 class TestMaskedArrayArithmetic:
     # Base test class for MaskedArrays.
 
-    def setup(self):
+    def setup_method(self):
         # Base data definition.
         x = np.array([1., 1., 1., -2., pi/2.0, 4., 5., -10., 10., 1., 2., 3.])
         y = np.array([5., 0., 3., 2., -1., -4., 0., -10., 10., 1., 0., 3.])
@@ -1014,7 +1033,7 @@ def setup(self):
         self.err_status = np.geterr()
         np.seterr(divide='ignore', invalid='ignore')
 
-    def teardown(self):
+    def teardown_method(self):
         np.seterr(**self.err_status)
 
     def test_basic_arithmetic(self):
@@ -1756,6 +1775,52 @@ def test_ne_for_numeric(self, dt1, dt2, fill):
         assert_equal(test.mask, [True, False])
         assert_(test.fill_value == True)
 
+    @pytest.mark.parametrize('dt1', num_dts, ids=num_ids)
+    @pytest.mark.parametrize('dt2', num_dts, ids=num_ids)
+    @pytest.mark.parametrize('fill', [None, 1])
+    @pytest.mark.parametrize('op',
+            [operator.le, operator.lt, operator.ge, operator.gt])
+    def test_comparisons_for_numeric(self, op, dt1, dt2, fill):
+        # Test the equality of structured arrays
+        a = array([0, 1], dtype=dt1, mask=[0, 1], fill_value=fill)
+
+        test = op(a, a)
+        assert_equal(test.data, op(a._data, a._data))
+        assert_equal(test.mask, [False, True])
+        assert_(test.fill_value == True)
+
+        test = op(a, a[0])
+        assert_equal(test.data, op(a._data, a._data[0]))
+        assert_equal(test.mask, [False, True])
+        assert_(test.fill_value == True)
+
+        b = array([0, 1], dtype=dt2, mask=[1, 0], fill_value=fill)
+        test = op(a, b)
+        assert_equal(test.data, op(a._data, b._data))
+        assert_equal(test.mask, [True, True])
+        assert_(test.fill_value == True)
+
+        test = op(a[0], b)
+        assert_equal(test.data, op(a._data[0], b._data))
+        assert_equal(test.mask, [True, False])
+        assert_(test.fill_value == True)
+
+        test = op(b, a[0])
+        assert_equal(test.data, op(b._data, a._data[0]))
+        assert_equal(test.mask, [True, False])
+        assert_(test.fill_value == True)
+
+    @pytest.mark.parametrize('op',
+            [operator.le, operator.lt, operator.ge, operator.gt])
+    @pytest.mark.parametrize('fill', [None, "N/A"])
+    def test_comparisons_strings(self, op, fill):
+        # See gh-21770, mask propagation is broken for strings (and some other
+        # cases) so we explicitly test strings here.
+        # In principle only == and != may need special handling...
+        ma1 = masked_array(["a", "b", "cde"], mask=[0, 1, 0], fill_value=fill)
+        ma2 = masked_array(["cde", "b", "a"], mask=[0, 1, 0], fill_value=fill)
+        assert_equal(op(ma1, ma2)._data, op(ma1._data, ma2._data))
+
     def test_eq_with_None(self):
         # Really, comparisons with None should not be done, but check them
         # anyway. Note that pep8 will flag these tests.
@@ -2338,14 +2403,14 @@ def test_fillvalue_bytes_or_str(self):
 class TestUfuncs:
     # Test class for the application of ufuncs on MaskedArrays.
 
-    def setup(self):
+    def setup_method(self):
         # Base data definition.
         self.d = (array([1.0, 0, -1, pi / 2] * 2, mask=[0, 1] + [0] * 6),
                   array([1.0, 0, -1, pi / 2] * 2, mask=[1, 0] + [0] * 6),)
         self.err_status = np.geterr()
         np.seterr(divide='ignore', invalid='ignore')
 
-    def teardown(self):
+    def teardown_method(self):
         np.seterr(**self.err_status)
 
     def test_testUfuncRegression(self):
@@ -2482,7 +2547,7 @@ def test_no_masked_nan_warnings(self):
 class TestMaskedArrayInPlaceArithmetic:
     # Test MaskedArray Arithmetic
 
-    def setup(self):
+    def setup_method(self):
         x = arange(10)
         y = arange(10)
         xm = arange(10)
@@ -2763,8 +2828,8 @@ def test_datafriendly_mul_arrays(self):
     def test_inplace_addition_scalar_type(self):
         # Test of inplace additions
         for t in self.othertypes:
-            with warnings.catch_warnings(record=True) as w:
-                warnings.filterwarnings("always")
+            with warnings.catch_warnings():
+                warnings.filterwarnings("error")
                 (x, y, xm) = (_.astype(t) for _ in self.uint8data)
                 xm[2] = masked
                 x += t(1)
@@ -2772,13 +2837,11 @@ def test_inplace_addition_scalar_type(self):
                 xm += t(1)
                 assert_equal(xm, y + t(1))
 
-                assert_equal(len(w), 0, f'Failed on type={t}.')
-
     def test_inplace_addition_array_type(self):
         # Test of inplace additions
         for t in self.othertypes:
-            with warnings.catch_warnings(record=True) as w:
-                warnings.filterwarnings("always")
+            with warnings.catch_warnings():
+                warnings.filterwarnings("error")
                 (x, y, xm) = (_.astype(t) for _ in self.uint8data)
                 m = xm.mask
                 a = arange(10, dtype=t)
@@ -2789,26 +2852,22 @@ def test_inplace_addition_array_type(self):
                 assert_equal(xm, y + a)
                 assert_equal(xm.mask, mask_or(m, a.mask))
 
-                assert_equal(len(w), 0, f'Failed on type={t}.')
-
     def test_inplace_subtraction_scalar_type(self):
         # Test of inplace subtractions
         for t in self.othertypes:
-            with warnings.catch_warnings(record=True) as w:
-                warnings.filterwarnings("always")
+            with warnings.catch_warnings():
+                warnings.filterwarnings("error")
                 (x, y, xm) = (_.astype(t) for _ in self.uint8data)
                 x -= t(1)
                 assert_equal(x, y - t(1))
                 xm -= t(1)
                 assert_equal(xm, y - t(1))
 
-                assert_equal(len(w), 0, f'Failed on type={t}.')
-
     def test_inplace_subtraction_array_type(self):
         # Test of inplace subtractions
         for t in self.othertypes:
-            with warnings.catch_warnings(record=True) as w:
-                warnings.filterwarnings("always")
+            with warnings.catch_warnings():
+                warnings.filterwarnings("error")
                 (x, y, xm) = (_.astype(t) for _ in self.uint8data)
                 m = xm.mask
                 a = arange(10, dtype=t)
@@ -2819,26 +2878,22 @@ def test_inplace_subtraction_array_type(self):
                 assert_equal(xm, y - a)
                 assert_equal(xm.mask, mask_or(m, a.mask))
 
-                assert_equal(len(w), 0, f'Failed on type={t}.')
-
     def test_inplace_multiplication_scalar_type(self):
         # Test of inplace multiplication
         for t in self.othertypes:
-            with warnings.catch_warnings(record=True) as w:
-                warnings.filterwarnings("always")
+            with warnings.catch_warnings():
+                warnings.filterwarnings("error")
                 (x, y, xm) = (_.astype(t) for _ in self.uint8data)
                 x *= t(2)
                 assert_equal(x, y * t(2))
                 xm *= t(2)
                 assert_equal(xm, y * t(2))
 
-                assert_equal(len(w), 0, f'Failed on type={t}.')
-
     def test_inplace_multiplication_array_type(self):
         # Test of inplace multiplication
         for t in self.othertypes:
-            with warnings.catch_warnings(record=True) as w:
-                warnings.filterwarnings("always")
+            with warnings.catch_warnings():
+                warnings.filterwarnings("error")
                 (x, y, xm) = (_.astype(t) for _ in self.uint8data)
                 m = xm.mask
                 a = arange(10, dtype=t)
@@ -2849,15 +2904,13 @@ def test_inplace_multiplication_array_type(self):
                 assert_equal(xm, y * a)
                 assert_equal(xm.mask, mask_or(m, a.mask))
 
-                assert_equal(len(w), 0, f'Failed on type={t}.')
-
     def test_inplace_floor_division_scalar_type(self):
         # Test of inplace division
         # Check for TypeError in case of unsupported types
         unsupported = {np.dtype(t).type for t in np.typecodes["Complex"]}
         for t in self.othertypes:
-            with warnings.catch_warnings(record=True) as w:
-                warnings.filterwarnings("always")
+            with warnings.catch_warnings():
+                warnings.filterwarnings("error")
                 (x, y, xm) = (_.astype(t) for _ in self.uint8data)
                 x = arange(10, dtype=t) * t(2)
                 xm = arange(10, dtype=t) * t(2)
@@ -2867,8 +2920,6 @@ def test_inplace_floor_division_scalar_type(self):
                     xm //= t(2)
                     assert_equal(x, y)
                     assert_equal(xm, y)
-
-                    assert_equal(len(w), 0, "Failed on type=%s." % t)
                 except TypeError:
                     msg = f"Supported type {t} throwing TypeError"
                     assert t in unsupported, msg
@@ -2878,8 +2929,8 @@ def test_inplace_floor_division_array_type(self):
         # Check for TypeError in case of unsupported types
         unsupported = {np.dtype(t).type for t in np.typecodes["Complex"]}
         for t in self.othertypes:
-            with warnings.catch_warnings(record=True) as w:
-                warnings.filterwarnings("always")
+            with warnings.catch_warnings():
+                warnings.filterwarnings("error")
                 (x, y, xm) = (_.astype(t) for _ in self.uint8data)
                 m = xm.mask
                 a = arange(10, dtype=t)
@@ -2893,8 +2944,6 @@ def test_inplace_floor_division_array_type(self):
                         xm.mask,
                         mask_or(mask_or(m, a.mask), (a == t(0)))
                     )
-
-                    assert_equal(len(w), 0, f'Failed on type={t}.')
                 except TypeError:
                     msg = f"Supported type {t} throwing TypeError"
                     assert t in unsupported, msg
@@ -2977,8 +3026,8 @@ def test_inplace_division_array_type(self):
     def test_inplace_pow_type(self):
         # Test keeping data w/ (inplace) power
         for t in self.othertypes:
-            with warnings.catch_warnings(record=True) as w:
-                warnings.filterwarnings("always")
+            with warnings.catch_warnings():
+                warnings.filterwarnings("error")
                 # Test pow on scalar
                 x = array([1, 2, 3], mask=[0, 0, 1], dtype=t)
                 xx = x ** t(2)
@@ -2990,12 +3039,10 @@ def test_inplace_pow_type(self):
                 assert_equal(x.data, xx_r.data)
                 assert_equal(x.mask, xx_r.mask)
 
-                assert_equal(len(w), 0, f'Failed on type={t}.')
-
 
 class TestMaskedArrayMethods:
     # Test class for miscellaneous MaskedArrays methods.
-    def setup(self):
+    def setup_method(self):
         # Base data definition.
         x = np.array([8.375, 7.545, 8.828, 8.5, 1.757, 5.928,
                       8.43, 7.78, 9.865, 5.878, 8.979, 4.732,
@@ -3379,6 +3426,22 @@ def test_ravel(self):
         assert_equal(a.ravel(order='C'), [1, 2, 3, 4])
         assert_equal(a.ravel(order='F'), [1, 3, 2, 4])
 
+    @pytest.mark.parametrize("order", "AKCF")
+    @pytest.mark.parametrize("data_order", "CF")
+    def test_ravel_order(self, order, data_order):
+        # Ravelling must ravel mask and data in the same order always to avoid
+        # misaligning the two in the ravel result.
+        arr = np.ones((5, 10), order=data_order)
+        arr[0, :] = 0
+        mask = np.ones((10, 5), dtype=bool, order=data_order).T
+        mask[0, :] = False
+        x = array(arr, mask=mask)
+        assert x._data.flags.fnc != x._mask.flags.fnc
+        assert (x.filled(0) == 0).all()
+        raveled = x.ravel(order)
+        assert (raveled.filled(0) == 0).all()
+
+
     def test_reshape(self):
         # Tests reshape
         x = arange(4)
@@ -3422,6 +3485,10 @@ def test_sort(self):
         assert_equal(sortedx._data, [1, 2, -2, -1, 0])
         assert_equal(sortedx._mask, [1, 1, 0, 0, 0])
 
+        x = array([0, -1], dtype=np.int8)
+        sortedx = sort(x, kind="stable")
+        assert_equal(sortedx, array([-1, 0], dtype=np.int8))
+
     def test_stable_sort(self):
         x = array([1, 2, 3, 1, 2, 3], dtype=np.uint8)
         expected = array([0, 3, 1, 4, 2, 5])
@@ -3753,7 +3820,7 @@ def test_diagonal_view(self):
 
 class TestMaskedArrayMathMethods:
 
-    def setup(self):
+    def setup_method(self):
         # Base data definition.
         x = np.array([8.375, 7.545, 8.828, 8.5, 1.757, 5.928,
                       8.43, 7.78, 9.865, 5.878, 8.979, 4.732,
@@ -4050,10 +4117,17 @@ def test_axis_methods_nomask(self):
         assert_equal(a.max(-1), [3, 6])
         assert_equal(a.max(1), [3, 6])
 
+    @requires_memory(free_bytes=2 * 10000 * 1000 * 2)
+    def test_mean_overflow(self):
+        # Test overflow in masked arrays
+        # gh-20272
+        a = masked_array(np.full((10000, 10000), 65535, dtype=np.uint16),
+                         mask=np.zeros((10000, 10000)))
+        assert_equal(a.mean(), 65535.0)
 
 class TestMaskedArrayMathMethodsComplex:
     # Test class for miscellaneous MaskedArrays methods.
-    def setup(self):
+    def setup_method(self):
         # Base data definition.
         x = np.array([8.375j, 7.545j, 8.828j, 8.5j, 1.757j, 5.928,
                       8.43, 7.78, 9.865, 5.878, 8.979, 4.732,
@@ -4107,7 +4181,7 @@ def test_varstd(self):
 class TestMaskedArrayFunctions:
     # Test class for miscellaneous functions.
 
-    def setup(self):
+    def setup_method(self):
         x = np.array([1., 1., 1., -2., pi/2.0, 4., 5., -10., 10., 1., 2., 3.])
         y = np.array([5., 0., 3., 2., -1., -4., 0., -10., 10., 1., 0., 3.])
         m1 = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]
@@ -4172,7 +4246,11 @@ def test_masked_where_structured(self):
         # test that masked_where on a structured array sets a structured
         # mask (see issue #2972)
         a = np.zeros(10, dtype=[("A", " 2, ixm, masked)
         assert_equal(d, [-9, -9, -9, -9, -9, 4, -9, -9, 10, -9, -9, 3])
         assert_equal(d.dtype, ixm.dtype)
@@ -4451,6 +4533,40 @@ def test_where_structured_masked(self):
         assert_equal(ma, expected)
         assert_equal(ma.mask, expected.mask)
 
+    def test_masked_invalid_error(self):
+        a = np.arange(5, dtype=object)
+        a[3] = np.PINF
+        a[2] = np.NaN
+        with pytest.raises(TypeError,
+                           match="not supported for the input types"):
+            np.ma.masked_invalid(a)
+
+    def test_masked_invalid_pandas(self):
+        # getdata() used to be bad for pandas series due to its _data
+        # attribute.  This test is a regression test mainly and may be
+        # removed if getdata() is adjusted.
+        class Series():
+            _data = "nonsense"
+
+            def __array__(self):
+                return np.array([5, np.nan, np.inf])
+
+        arr = np.ma.masked_invalid(Series())
+        assert_array_equal(arr._data, np.array(Series()))
+        assert_array_equal(arr._mask, [False, True, True])
+
+    @pytest.mark.parametrize("copy", [True, False])
+    def test_masked_invalid_full_mask(self, copy):
+        # Matplotlib relied on masked_invalid always returning a full mask
+        # (Also astropy projects, but were ok with it gh-22720 and gh-22842)
+        a = np.ma.array([1, 2, 3, 4])
+        assert a._mask is nomask
+        res = np.ma.masked_invalid(a, copy=copy)
+        assert res.mask is not nomask
+        # mask of a should not be mutated
+        assert a.mask is nomask
+        assert np.may_share_memory(a._data, res._data) != copy
+
     def test_choose(self):
         # Test choose
         choices = [[0, 1, 2, 3], [10, 11, 12, 13],
@@ -4745,7 +4861,7 @@ def test_convolve(self):
 
 class TestMaskedFields:
 
-    def setup(self):
+    def setup_method(self):
         ilist = [1, 2, 3, 4, 5]
         flist = [1.1, 2.2, 3.3, 4.4, 5.5]
         slist = ['one', 'two', 'three', 'four', 'five']
@@ -4955,7 +5071,7 @@ def test_nested_ma(self):
 
 class TestMaskedView:
 
-    def setup(self):
+    def setup_method(self):
         iterator = list(zip(np.arange(10), np.random.rand(10)))
         data = np.array(iterator)
         a = array(iterator, dtype=[('a', float), ('b', float)])
@@ -5208,7 +5324,7 @@ def test_coercion_float(self):
     def test_coercion_unicode(self):
         a_u = np.zeros((), 'U10')
         a_u[()] = np.ma.masked
-        assert_equal(a_u[()], u'--')
+        assert_equal(a_u[()], '--')
 
     @pytest.mark.xfail(reason="See gh-9750")
     def test_coercion_bytes(self):
@@ -5264,6 +5380,10 @@ def test_masked_array_no_copy():
     a = np.ma.array([1, 2, 3, 4], mask=[1, 0, 0, 0])
     _ = np.ma.masked_where(a == 3, a, copy=False)
     assert_array_equal(a.mask, [True, False, True, False])
+    # check masked array with masked_invalid is updated in place
+    a = np.ma.array([np.inf, 1, 2, 3, 4])
+    _ = np.ma.masked_invalid(a, copy=False)
+    assert_array_equal(a.mask, [True, False, False, False, False])
 
 def test_append_masked_array():
     a = np.ma.masked_equal([1,2,3], value=2)
@@ -5342,7 +5462,7 @@ def test_ufunc_with_out_varied():
 
 
 def test_astype_mask_ordering():
-    descr = [('v', int, 3), ('x', [('y', float)])]
+    descr = np.dtype([('v', int, 3), ('x', [('y', float)])])
     x = array([
         [([1, 2, 3], (1.0,)),  ([1, 2, 3], (2.0,))],
         [([1, 2, 3], (3.0,)),  ([1, 2, 3], (4.0,))]], dtype=descr)
diff --git a/numpy/ma/tests/test_deprecations.py b/numpy/ma/tests/test_deprecations.py
index 3e0e09fdd1c8..40c8418f5c18 100644
--- a/numpy/ma/tests/test_deprecations.py
+++ b/numpy/ma/tests/test_deprecations.py
@@ -39,11 +39,6 @@ def test_method(self):
 
 
 class TestMinimumMaximum:
-    def test_minimum(self):
-        assert_warns(DeprecationWarning, np.ma.minimum, np.ma.array([1, 2]))
-
-    def test_maximum(self):
-        assert_warns(DeprecationWarning, np.ma.maximum, np.ma.array([1, 2]))
 
     def test_axis_default(self):
         # NumPy 1.13, 2017-05-06
diff --git a/numpy/ma/tests/test_extras.py b/numpy/ma/tests/test_extras.py
index e735b9bc77fa..38603fb8433a 100644
--- a/numpy/ma/tests/test_extras.py
+++ b/numpy/ma/tests/test_extras.py
@@ -12,6 +12,7 @@
 import pytest
 
 import numpy as np
+from numpy.core.numeric import normalize_axis_tuple
 from numpy.testing import (
     assert_warns, suppress_warnings
     )
@@ -28,7 +29,7 @@
     ediff1d, apply_over_axes, apply_along_axis, compress_nd, compress_rowcols,
     mask_rowcols, clump_masked, clump_unmasked, flatnotmasked_contiguous,
     notmasked_contiguous, notmasked_edges, masked_all, masked_all_like, isin,
-    diagflat, stack, vstack
+    diagflat, ndenumerate, stack, vstack
     )
 
 
@@ -75,7 +76,7 @@ def test_masked_all_with_object_nested(self):
         assert_equal(len(masked_arr['b']['c']), 1)
         assert_equal(masked_arr['b']['c'].shape, (1, 1))
         assert_equal(masked_arr['b']['c']._fill_value.shape, ())
-    
+
     def test_masked_all_with_object(self):
         # same as above except that the array is not nested
         my_dtype = np.dtype([('b', (object, (1,)))])
@@ -241,6 +242,15 @@ def test_testAverage3(self):
         a2dma = average(a2dm, axis=1)
         assert_equal(a2dma, [1.5, 4.0])
 
+    def test_testAverage4(self):
+        # Test that `keepdims` works with average
+        x = np.array([2, 3, 4]).reshape(3, 1)
+        b = np.ma.array(x, mask=[[False], [False], [True]])
+        w = np.array([4, 5, 6]).reshape(3, 1)
+        actual = average(b, weights=w, axis=1, keepdims=True)
+        desired = masked_array([[2.], [3.], [4.]], [[False], [False], [True]])
+        assert_equal(actual, desired)
+
     def test_onintegers_with_mask(self):
         # Test average on integers with mask
         a = average(array([1, 2]))
@@ -292,6 +302,29 @@ def test_complex(self):
         assert_almost_equal(wav1.real, expected1.real)
         assert_almost_equal(wav1.imag, expected1.imag)
 
+    @pytest.mark.parametrize(
+        'x, axis, expected_avg, weights, expected_wavg, expected_wsum',
+        [([1, 2, 3], None, [2.0], [3, 4, 1], [1.75], [8.0]),
+         ([[1, 2, 5], [1, 6, 11]], 0, [[1.0, 4.0, 8.0]],
+          [1, 3], [[1.0, 5.0, 9.5]], [[4, 4, 4]])],
+    )
+    def test_basic_keepdims(self, x, axis, expected_avg,
+                            weights, expected_wavg, expected_wsum):
+        avg = np.ma.average(x, axis=axis, keepdims=True)
+        assert avg.shape == np.shape(expected_avg)
+        assert_array_equal(avg, expected_avg)
+
+        wavg = np.ma.average(x, axis=axis, weights=weights, keepdims=True)
+        assert wavg.shape == np.shape(expected_wavg)
+        assert_array_equal(wavg, expected_wavg)
+
+        wavg, wsum = np.ma.average(x, axis=axis, weights=weights,
+                                   returned=True, keepdims=True)
+        assert wavg.shape == np.shape(expected_wavg)
+        assert_array_equal(wavg, expected_wavg)
+        assert wsum.shape == np.shape(expected_wsum)
+        assert_array_equal(wsum, expected_wsum)
+
     def test_masked_weights(self):
         # Test with masked weights.
         # (Regression test for https://github.com/numpy/numpy/issues/10438)
@@ -309,6 +342,32 @@ def test_masked_weights(self):
         expected_masked = np.array([6.0, 5.576271186440678, 6.576271186440678])
         assert_almost_equal(avg_masked, expected_masked)
 
+        # weights should be masked if needed
+        # depending on the array mask. This is to avoid summing
+        # masked nan or other values that are not cancelled by a zero
+        a = np.ma.array([1.0,   2.0,   3.0,  4.0],
+                   mask=[False, False, True, True])
+        avg_unmasked = average(a, weights=[1, 1, 1, np.nan])
+
+        assert_almost_equal(avg_unmasked, 1.5)
+
+        a = np.ma.array([
+            [1.0, 2.0, 3.0, 4.0],
+            [5.0, 6.0, 7.0, 8.0],
+            [9.0, 1.0, 2.0, 3.0],
+        ], mask=[
+            [False, True, True, False],
+            [True, False, True, True],
+            [True, False, True, False],
+        ])
+
+        avg_masked = np.ma.average(a, weights=[1, np.nan, 1], axis=0)
+        avg_expected = np.ma.array([1.0, np.nan, np.nan, 3.5],
+                              mask=[False, True, True, False])
+
+        assert_almost_equal(avg_masked, avg_expected)
+        assert_equal(avg_masked.mask, avg_expected.mask)
+
 
 class TestConcatenator:
     # Tests for mr_, the equivalent of r_ for masked arrays.
@@ -931,6 +990,34 @@ def test_out(self):
             assert_(r is out)
             assert_(type(r) is MaskedArray)
 
+    @pytest.mark.parametrize(
+        argnames='axis',
+        argvalues=[
+            None,
+            1,
+            (1, ),
+            (0, 1),
+            (-3, -1),
+        ]
+    )
+    def test_keepdims_out(self, axis):
+        mask = np.zeros((3, 5, 7, 11), dtype=bool)
+        # Randomly set some elements to True:
+        w = np.random.random((4, 200)) * np.array(mask.shape)[:, None]
+        w = w.astype(np.intp)
+        mask[tuple(w)] = np.nan
+        d = masked_array(np.ones(mask.shape), mask=mask)
+        if axis is None:
+            shape_out = (1,) * d.ndim
+        else:
+            axis_norm = normalize_axis_tuple(axis, d.ndim)
+            shape_out = tuple(
+                1 if i in axis_norm else d.shape[i] for i in range(d.ndim))
+        out = masked_array(np.empty(shape_out))
+        result = median(d, axis=axis, keepdims=True, out=out)
+        assert result is out
+        assert_equal(result.shape, shape_out)
+
     def test_single_non_masked_value_on_axis(self):
         data = [[1., 0.],
                 [0., 3.],
@@ -1105,7 +1192,7 @@ def test_object(self):
 
 class TestCov:
 
-    def setup(self):
+    def setup_method(self):
         self.data = array(np.random.rand(12))
 
     def test_1d_without_missing(self):
@@ -1172,7 +1259,7 @@ def test_2d_with_missing(self):
 
 class TestCorrcoef:
 
-    def setup(self):
+    def setup_method(self):
         self.data = array(np.random.rand(12))
         self.data2 = array(np.random.rand(12))
 
@@ -1617,12 +1704,49 @@ def test_shape_scalar(self):
             assert_equal(a.mask.shape, a.shape)
             assert_equal(a.data.shape, a.shape)
 
-
         b = diagflat(1.0)
         assert_equal(b.shape, (1, 1))
         assert_equal(b.mask.shape, b.data.shape)
 
 
+class TestNDEnumerate:
+
+    def test_ndenumerate_nomasked(self):
+        ordinary = np.arange(6.).reshape((1, 3, 2))
+        empty_mask = np.zeros_like(ordinary, dtype=bool)
+        with_mask = masked_array(ordinary, mask=empty_mask)
+        assert_equal(list(np.ndenumerate(ordinary)),
+                     list(ndenumerate(ordinary)))
+        assert_equal(list(ndenumerate(ordinary)),
+                     list(ndenumerate(with_mask)))
+        assert_equal(list(ndenumerate(with_mask)),
+                     list(ndenumerate(with_mask, compressed=False)))
+
+    def test_ndenumerate_allmasked(self):
+        a = masked_all(())
+        b = masked_all((100,))
+        c = masked_all((2, 3, 4))
+        assert_equal(list(ndenumerate(a)), [])
+        assert_equal(list(ndenumerate(b)), [])
+        assert_equal(list(ndenumerate(b, compressed=False)),
+                     list(zip(np.ndindex((100,)), 100 * [masked])))
+        assert_equal(list(ndenumerate(c)), [])
+        assert_equal(list(ndenumerate(c, compressed=False)),
+                     list(zip(np.ndindex((2, 3, 4)), 2 * 3 * 4 * [masked])))
+
+    def test_ndenumerate_mixedmasked(self):
+        a = masked_array(np.arange(12).reshape((3, 4)),
+                         mask=[[1, 1, 1, 1],
+                               [1, 1, 0, 1],
+                               [0, 0, 0, 0]])
+        items = [((1, 2), 6),
+                 ((2, 0), 8), ((2, 1), 9), ((2, 2), 10), ((2, 3), 11)]
+        assert_equal(list(ndenumerate(a)), items)
+        assert_equal(len(list(ndenumerate(a, compressed=False))), a.size)
+        for coordinate, value in ndenumerate(a, compressed=False):
+            assert_equal(a[coordinate], value)
+
+
 class TestStack:
 
     def test_stack_1d(self):
diff --git a/numpy/ma/tests/test_mrecords.py b/numpy/ma/tests/test_mrecords.py
index 4b2c01df9947..77123c3cda94 100644
--- a/numpy/ma/tests/test_mrecords.py
+++ b/numpy/ma/tests/test_mrecords.py
@@ -348,7 +348,7 @@ def test_exotic_formats(self):
 
 class TestView:
 
-    def setup(self):
+    def setup_method(self):
         (a, b) = (np.arange(10), np.random.rand(10))
         ndtype = [('a', float), ('b', float)]
         arr = np.array(list(zip(a, b)), dtype=ndtype)
diff --git a/numpy/ma/tests/test_old_ma.py b/numpy/ma/tests/test_old_ma.py
index 2b3034f9cb2b..8465b11531d8 100644
--- a/numpy/ma/tests/test_old_ma.py
+++ b/numpy/ma/tests/test_old_ma.py
@@ -1,5 +1,7 @@
 from functools import reduce
 
+import pytest
+
 import numpy as np
 import numpy.core.umath as umath
 import numpy.core.fromnumeric as fromnumeric
@@ -33,7 +35,7 @@ def eq(v, w, msg=''):
 
 class TestMa:
 
-    def setup(self):
+    def setup_method(self):
         x = np.array([1., 1., 1., -2., pi/2.0, 4., 5., -10., 10., 1., 2., 3.])
         y = np.array([5., 0., 3., 2., -1., -4., 0., -10., 10., 1., 0., 3.])
         a10 = 10.
@@ -62,27 +64,25 @@ def test_testBasic1d(self):
         assert_(eq(filled(xm, 1.e20), xf))
         assert_(eq(x, xm))
 
-    def test_testBasic2d(self):
+    @pytest.mark.parametrize("s", [(4, 3), (6, 2)])
+    def test_testBasic2d(self, s):
         # Test of basic array creation and properties in 2 dimensions.
-        for s in [(4, 3), (6, 2)]:
-            (x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
-            x.shape = s
-            y.shape = s
-            xm.shape = s
-            ym.shape = s
-            xf.shape = s
-
-            assert_(not isMaskedArray(x))
-            assert_(isMaskedArray(xm))
-            assert_equal(shape(xm), s)
-            assert_equal(xm.shape, s)
-            assert_equal(xm.size, reduce(lambda x, y:x * y, s))
-            assert_equal(count(xm),
-                             len(m1) - reduce(lambda x, y:x + y, m1))
-            assert_(eq(xm, xf))
-            assert_(eq(filled(xm, 1.e20), xf))
-            assert_(eq(x, xm))
-            self.setup()
+        (x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
+        x.shape = s
+        y.shape = s
+        xm.shape = s
+        ym.shape = s
+        xf.shape = s
+
+        assert_(not isMaskedArray(x))
+        assert_(isMaskedArray(xm))
+        assert_equal(shape(xm), s)
+        assert_equal(xm.shape, s)
+        assert_equal(xm.size, reduce(lambda x, y: x * y, s))
+        assert_equal(count(xm), len(m1) - reduce(lambda x, y: x + y, m1))
+        assert_(eq(xm, xf))
+        assert_(eq(filled(xm, 1.e20), xf))
+        assert_(eq(x, xm))
 
     def test_testArithmetic(self):
         # Test of basic arithmetic.
@@ -715,7 +715,7 @@ def test_assignment_by_condition_2(self):
 
 
 class TestUfuncs:
-    def setup(self):
+    def setup_method(self):
         self.d = (array([1.0, 0, -1, pi / 2] * 2, mask=[0, 1] + [0] * 6),
                   array([1.0, 0, -1, pi / 2] * 2, mask=[1, 0] + [0] * 6),)
 
@@ -781,7 +781,7 @@ def test_nonzero(self):
 
 class TestArrayMethods:
 
-    def setup(self):
+    def setup_method(self):
         x = np.array([8.375, 7.545, 8.828, 8.5, 1.757, 5.928,
                       8.43, 7.78, 9.865, 5.878, 8.979, 4.732,
                       3.012, 6.022, 5.095, 3.116, 5.238, 3.957,
diff --git a/numpy/ma/tests/test_regression.py b/numpy/ma/tests/test_regression.py
index 7e76eb05491b..cb3d0349f96b 100644
--- a/numpy/ma/tests/test_regression.py
+++ b/numpy/ma/tests/test_regression.py
@@ -37,7 +37,7 @@ def test_masked_array_repeat(self):
 
     def test_masked_array_repr_unicode(self):
         # Ticket #1256
-        repr(np.ma.array(u"Unicode"))
+        repr(np.ma.array("Unicode"))
 
     def test_atleast_2d(self):
         # Ticket #1559
diff --git a/numpy/ma/tests/test_subclassing.py b/numpy/ma/tests/test_subclassing.py
index 83a9b2f5187c..64c66eeb9d6b 100644
--- a/numpy/ma/tests/test_subclassing.py
+++ b/numpy/ma/tests/test_subclassing.py
@@ -7,6 +7,7 @@
 
 """
 import numpy as np
+from numpy.lib.mixins import NDArrayOperatorsMixin
 from numpy.testing import assert_, assert_raises
 from numpy.ma.testutils import assert_equal
 from numpy.ma.core import (
@@ -28,8 +29,7 @@ def __new__(cls,arr,info={}):
         return x
 
     def __array_finalize__(self, obj):
-        if callable(getattr(super(), '__array_finalize__', None)):
-            super().__array_finalize__(obj)
+        super().__array_finalize__(obj)
         self.info = getattr(obj, 'info', {}).copy()
         return
 
@@ -148,10 +148,37 @@ def __array_wrap__(self, obj, context=None):
         return obj
 
 
+class WrappedArray(NDArrayOperatorsMixin):
+    """
+    Wrapping a MaskedArray rather than subclassing to test that
+    ufunc deferrals are commutative.
+    See: https://github.com/numpy/numpy/issues/15200)
+    """
+    __array_priority__ = 20
+
+    def __init__(self, array, **attrs):
+        self._array = array
+        self.attrs = attrs
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}(\n{self._array}\n{self.attrs}\n)"
+
+    def __array__(self):
+        return np.asarray(self._array)
+
+    def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
+        if method == '__call__':
+            inputs = [arg._array if isinstance(arg, self.__class__) else arg
+                      for arg in inputs]
+            return self.__class__(ufunc(*inputs, **kwargs), **self.attrs)
+        else:
+            return NotImplemented
+
+
 class TestSubclassing:
     # Test suite for masked subclasses of ndarray.
 
-    def setup(self):
+    def setup_method(self):
         x = np.arange(5, dtype='float')
         mx = msubarray(x, mask=[0, 1, 0, 0, 0])
         self.data = (x, mx)
@@ -315,7 +342,7 @@ def test_subclass_repr(self):
         assert_startswith(repr(mx), 'masked_array')
         xsub = SubArray(x)
         mxsub = masked_array(xsub, mask=[True, False, True, False, False])
-        assert_startswith(repr(mxsub), 
+        assert_startswith(repr(mxsub),
             f'masked_{SubArray.__name__}(data=[--, 1, --, 3, 4]')
 
     def test_subclass_str(self):
@@ -385,3 +412,39 @@ def test_array_no_inheritance():
     # Test that the mask is False and not shared when keep_mask=False
     assert_(not new_array.mask)
     assert_(not new_array.sharedmask)
+
+
+class TestClassWrapping:
+    # Test suite for classes that wrap MaskedArrays
+
+    def setup_method(self):
+        m = np.ma.masked_array([1, 3, 5], mask=[False, True, False])
+        wm = WrappedArray(m)
+        self.data = (m, wm)
+
+    def test_masked_unary_operations(self):
+        # Tests masked_unary_operation
+        (m, wm) = self.data
+        with np.errstate(divide='ignore'):
+            assert_(isinstance(np.log(wm), WrappedArray))
+
+    def test_masked_binary_operations(self):
+        # Tests masked_binary_operation
+        (m, wm) = self.data
+        # Result should be a WrappedArray
+        assert_(isinstance(np.add(wm, wm), WrappedArray))
+        assert_(isinstance(np.add(m, wm), WrappedArray))
+        assert_(isinstance(np.add(wm, m), WrappedArray))
+        # add and '+' should call the same ufunc
+        assert_equal(np.add(m, wm), m + wm)
+        assert_(isinstance(np.hypot(m, wm), WrappedArray))
+        assert_(isinstance(np.hypot(wm, m), WrappedArray))
+        # Test domained binary operations
+        assert_(isinstance(np.divide(wm, m), WrappedArray))
+        assert_(isinstance(np.divide(m, wm), WrappedArray))
+        assert_equal(np.divide(wm, m) * m, np.divide(m, m) * wm)
+        # Test broadcasting
+        m2 = np.stack([m, m])
+        assert_(isinstance(np.divide(wm, m2), WrappedArray))
+        assert_(isinstance(np.divide(m2, wm), WrappedArray))
+        assert_equal(np.divide(m2, wm), np.divide(wm, m2))
diff --git a/numpy/matlib.py b/numpy/matlib.py
index bd6b632891fc..e929fd9b1885 100644
--- a/numpy/matlib.py
+++ b/numpy/matlib.py
@@ -300,9 +300,10 @@ def randn(*args):
 
     Notes
     -----
-    For random samples from :math:`N(\\mu, \\sigma^2)`, use:
+    For random samples from the normal distribution with mean ``mu`` and
+    standard deviation ``sigma``, use::
 
-    ``sigma * np.matlib.randn(...) + mu``
+        sigma * np.matlib.randn(...) + mu
 
     Examples
     --------
@@ -314,7 +315,8 @@ def randn(*args):
     matrix([[ 0.99734545,  0.2829785 , -1.50629471],
             [-0.57860025,  1.65143654, -2.42667924]])
 
-    Two-by-four matrix of samples from :math:`N(3, 6.25)`:
+    Two-by-four matrix of samples from the normal distribution with
+    mean 3 and standard deviation 2.5:
 
     >>> 2.5 * np.matlib.randn((2, 4)) + 3
     matrix([[1.92771843, 6.16484065, 0.83314899, 1.30278462],
diff --git a/numpy/matrixlib/__init__.py b/numpy/matrixlib/__init__.py
index 54154d11f750..8a7597d30387 100644
--- a/numpy/matrixlib/__init__.py
+++ b/numpy/matrixlib/__init__.py
@@ -1,6 +1,7 @@
 """Sub-package containing the matrix class and related functions.
 
 """
+from . import defmatrix
 from .defmatrix import *
 
 __all__ = defmatrix.__all__
diff --git a/numpy/matrixlib/__init__.pyi b/numpy/matrixlib/__init__.pyi
index c1b82d2ecdb7..b0ca8c9ca03d 100644
--- a/numpy/matrixlib/__init__.pyi
+++ b/numpy/matrixlib/__init__.pyi
@@ -1,5 +1,3 @@
-from typing import List
-
 from numpy._pytesttester import PytestTester
 
 from numpy import (
@@ -12,6 +10,6 @@ from numpy.matrixlib.defmatrix import (
     asmatrix as asmatrix,
 )
 
-__all__: List[str]
-__path__: List[str]
+__all__: list[str]
+__path__: list[str]
 test: PytestTester
diff --git a/numpy/matrixlib/defmatrix.pyi b/numpy/matrixlib/defmatrix.pyi
index 6c86ea1ef769..9d0d1ee50b66 100644
--- a/numpy/matrixlib/defmatrix.pyi
+++ b/numpy/matrixlib/defmatrix.pyi
@@ -1,8 +1,9 @@
-from typing import List, Any, Sequence, Mapping
+from collections.abc import Sequence, Mapping
+from typing import Any
 from numpy import matrix as matrix
-from numpy.typing import ArrayLike, DTypeLike, NDArray
+from numpy._typing import ArrayLike, DTypeLike, NDArray
 
-__all__: List[str]
+__all__: list[str]
 
 def bmat(
     obj: str | Sequence[ArrayLike] | NDArray[Any],
diff --git a/numpy/matrixlib/tests/test_masked_matrix.py b/numpy/matrixlib/tests/test_masked_matrix.py
index 95d3f44b6196..d0ce357aef27 100644
--- a/numpy/matrixlib/tests/test_masked_matrix.py
+++ b/numpy/matrixlib/tests/test_masked_matrix.py
@@ -173,7 +173,7 @@ def test_view(self):
 class TestSubclassing:
     # Test suite for masked subclasses of ndarray.
 
-    def setup(self):
+    def setup_method(self):
         x = np.arange(5, dtype='float')
         mx = MMatrix(x, mask=[0, 1, 0, 0, 0])
         self.data = (x, mx)
diff --git a/numpy/polynomial/__init__.py b/numpy/polynomial/__init__.py
index 5a3addf4cd3d..c4e7baf2c683 100644
--- a/numpy/polynomial/__init__.py
+++ b/numpy/polynomial/__init__.py
@@ -156,17 +156,17 @@ def set_default_printstyle(style):
     >>> c = np.polynomial.Chebyshev([1, 2, 3])
     >>> np.polynomial.set_default_printstyle('unicode')
     >>> print(p)
-    1.0 + 2.0·x¹ + 3.0·x²
+    1.0 + 2.0·x + 3.0·x²
     >>> print(c)
     1.0 + 2.0·T₁(x) + 3.0·T₂(x)
     >>> np.polynomial.set_default_printstyle('ascii')
     >>> print(p)
-    1.0 + 2.0 x**1 + 3.0 x**2
+    1.0 + 2.0 x + 3.0 x**2
     >>> print(c)
     1.0 + 2.0 T_1(x) + 3.0 T_2(x)
     >>> # Formatting supersedes all class/package-level defaults
     >>> print(f"{p:unicode}")
-    1.0 + 2.0·x¹ + 3.0·x²
+    1.0 + 2.0·x + 3.0·x²
     """
     if style not in ('unicode', 'ascii'):
         raise ValueError(
diff --git a/numpy/polynomial/__init__.pyi b/numpy/polynomial/__init__.pyi
index e0cfedd7aae7..c9d1c27a96c2 100644
--- a/numpy/polynomial/__init__.pyi
+++ b/numpy/polynomial/__init__.pyi
@@ -1,5 +1,3 @@
-from typing import List
-
 from numpy._pytesttester import PytestTester
 
 from numpy.polynomial import (
@@ -17,8 +15,8 @@ from numpy.polynomial.laguerre import Laguerre as Laguerre
 from numpy.polynomial.legendre import Legendre as Legendre
 from numpy.polynomial.polynomial import Polynomial as Polynomial
 
-__all__: List[str]
-__path__: List[str]
+__all__: list[str]
+__path__: list[str]
 test: PytestTester
 
 def set_default_printstyle(style): ...
diff --git a/numpy/polynomial/_polybase.py b/numpy/polynomial/_polybase.py
index 155d7280591b..3bea91dd239c 100644
--- a/numpy/polynomial/_polybase.py
+++ b/numpy/polynomial/_polybase.py
@@ -37,6 +37,12 @@ class ABCPolyBase(abc.ABC):
     window : (2,) array_like, optional
         Window, see domain for its use. The default value is the
         derived class window.
+    symbol : str, optional
+        Symbol used to represent the independent variable in string 
+        representations of the polynomial expression, e.g. for printing.
+        The symbol must be a valid Python identifier. Default value is 'x'.
+
+        .. versionadded:: 1.24
 
     Attributes
     ----------
@@ -46,6 +52,8 @@ class ABCPolyBase(abc.ABC):
         Domain that is mapped to window.
     window : (2,) ndarray
         Window that domain is mapped to.
+    symbol : str
+        Symbol representing the independent variable.
 
     Class Attributes
     ----------------
@@ -99,6 +107,10 @@ class ABCPolyBase(abc.ABC):
     # printing on windows.
     _use_unicode = not os.name == 'nt'
 
+    @property
+    def symbol(self):
+        return self._symbol
+
     @property
     @abc.abstractmethod
     def domain(self):
@@ -284,10 +296,12 @@ class as self with identical domain and window. If so,
                 raise TypeError("Domains differ")
             elif not np.all(self.window == other.window):
                 raise TypeError("Windows differ")
+            elif self.symbol != other.symbol:
+                raise ValueError("Polynomial symbols differ")
             return other.coef
         return other
 
-    def __init__(self, coef, domain=None, window=None):
+    def __init__(self, coef, domain=None, window=None, symbol='x'):
         [coef] = pu.as_series([coef], trim=False)
         self.coef = coef
 
@@ -303,12 +317,27 @@ def __init__(self, coef, domain=None, window=None):
                 raise ValueError("Window has wrong number of elements.")
             self.window = window
 
+        # Validation for symbol
+        try:
+            if not symbol.isidentifier():
+                raise ValueError(
+                    "Symbol string must be a valid Python identifier"
+                )
+        # If a user passes in something other than a string, the above
+        # results in an AttributeError. Catch this and raise a more
+        # informative exception
+        except AttributeError:
+            raise TypeError("Symbol must be a non-empty string")
+
+        self._symbol = symbol
+
     def __repr__(self):
         coef = repr(self.coef)[6:-1]
         domain = repr(self.domain)[6:-1]
         window = repr(self.window)[6:-1]
         name = self.__class__.__name__
-        return f"{name}({coef}, domain={domain}, window={window})"
+        return (f"{name}({coef}, domain={domain}, window={window}, "
+                f"symbol='{self.symbol}')")
 
     def __format__(self, fmt_str):
         if fmt_str == '':
@@ -337,7 +366,7 @@ def _generate_string(self, term_method):
         linewidth = np.get_printoptions().get('linewidth', 75)
         if linewidth < 1:
             linewidth = 1
-        out = f"{self.coef[0]}"
+        out = pu.format_float(self.coef[0])
         for i, coef in enumerate(self.coef[1:]):
             out += " "
             power = str(i + 1)
@@ -347,13 +376,13 @@ def _generate_string(self, term_method):
             # complex). In this case, represent the coefficient as-is.
             try:
                 if coef >= 0:
-                    next_term = f"+ {coef}"
+                    next_term = f"+ " + pu.format_float(coef, parens=True)
                 else:
-                    next_term = f"- {-coef}"
+                    next_term = f"- " + pu.format_float(-coef, parens=True)
             except TypeError:
                 next_term = f"+ {coef}"
             # Polynomial term
-            next_term += term_method(power, "x")
+            next_term += term_method(power, self.symbol)
             # Length of the current line with next term added
             line_len = len(out.split('\n')[-1]) + len(next_term)
             # If not the last term in the polynomial, it will be two
@@ -403,27 +432,27 @@ def _repr_latex_term(cls, i, arg_str, needs_parens):
         return f"{{{cls.basis_name}}}_{{{i}}}({arg_str})"
 
     @staticmethod
-    def _repr_latex_scalar(x):
+    def _repr_latex_scalar(x, parens=False):
         # TODO: we're stuck with disabling math formatting until we handle
         # exponents in this function
-        return r'\text{{{}}}'.format(x)
+        return r'\text{{{}}}'.format(pu.format_float(x, parens=parens))
 
     def _repr_latex_(self):
         # get the scaled argument string to the basis functions
         off, scale = self.mapparms()
         if off == 0 and scale == 1:
-            term = 'x'
+            term = self.symbol
             needs_parens = False
         elif scale == 1:
-            term = f"{self._repr_latex_scalar(off)} + x"
+            term = f"{self._repr_latex_scalar(off)} + {self.symbol}"
             needs_parens = True
         elif off == 0:
-            term = f"{self._repr_latex_scalar(scale)}x"
+            term = f"{self._repr_latex_scalar(scale)}{self.symbol}"
             needs_parens = True
         else:
             term = (
                 f"{self._repr_latex_scalar(off)} + "
-                f"{self._repr_latex_scalar(scale)}x"
+                f"{self._repr_latex_scalar(scale)}{self.symbol}"
             )
             needs_parens = True
 
@@ -437,9 +466,9 @@ def _repr_latex_(self):
             elif not isinstance(c, numbers.Real):
                 coef_str = f" + ({self._repr_latex_scalar(c)})"
             elif not np.signbit(c):
-                coef_str = f" + {self._repr_latex_scalar(c)}"
+                coef_str = f" + {self._repr_latex_scalar(c, parens=True)}"
             else:
-                coef_str = f" - {self._repr_latex_scalar(-c)}"
+                coef_str = f" - {self._repr_latex_scalar(-c, parens=True)}"
 
             # produce the string for the term
             term_str = self._repr_latex_term(i, term, needs_parens)
@@ -459,7 +488,7 @@ def _repr_latex_(self):
             # in case somehow there are no coefficients at all
             body = '0'
 
-        return rf"$x \mapsto {body}$"
+        return rf"${self.symbol} \mapsto {body}$"
 
 
 
@@ -470,6 +499,7 @@ def __getstate__(self):
         ret['coef'] = self.coef.copy()
         ret['domain'] = self.domain.copy()
         ret['window'] = self.window.copy()
+        ret['symbol'] = self.symbol
         return ret
 
     def __setstate__(self, dict):
@@ -491,7 +521,9 @@ def __len__(self):
     # Numeric properties.
 
     def __neg__(self):
-        return self.__class__(-self.coef, self.domain, self.window)
+        return self.__class__(
+            -self.coef, self.domain, self.window, self.symbol
+        )
 
     def __pos__(self):
         return self
@@ -502,7 +534,7 @@ def __add__(self, other):
             coef = self._add(self.coef, othercoef)
         except Exception:
             return NotImplemented
-        return self.__class__(coef, self.domain, self.window)
+        return self.__class__(coef, self.domain, self.window, self.symbol)
 
     def __sub__(self, other):
         othercoef = self._get_coefficients(other)
@@ -510,7 +542,7 @@ def __sub__(self, other):
             coef = self._sub(self.coef, othercoef)
         except Exception:
             return NotImplemented
-        return self.__class__(coef, self.domain, self.window)
+        return self.__class__(coef, self.domain, self.window, self.symbol)
 
     def __mul__(self, other):
         othercoef = self._get_coefficients(other)
@@ -518,7 +550,7 @@ def __mul__(self, other):
             coef = self._mul(self.coef, othercoef)
         except Exception:
             return NotImplemented
-        return self.__class__(coef, self.domain, self.window)
+        return self.__class__(coef, self.domain, self.window, self.symbol)
 
     def __truediv__(self, other):
         # there is no true divide if the rhs is not a Number, although it
@@ -551,13 +583,13 @@ def __divmod__(self, other):
             raise
         except Exception:
             return NotImplemented
-        quo = self.__class__(quo, self.domain, self.window)
-        rem = self.__class__(rem, self.domain, self.window)
+        quo = self.__class__(quo, self.domain, self.window, self.symbol)
+        rem = self.__class__(rem, self.domain, self.window, self.symbol)
         return quo, rem
 
     def __pow__(self, other):
         coef = self._pow(self.coef, other, maxpower=self.maxpower)
-        res = self.__class__(coef, self.domain, self.window)
+        res = self.__class__(coef, self.domain, self.window, self.symbol)
         return res
 
     def __radd__(self, other):
@@ -565,21 +597,21 @@ def __radd__(self, other):
             coef = self._add(other, self.coef)
         except Exception:
             return NotImplemented
-        return self.__class__(coef, self.domain, self.window)
+        return self.__class__(coef, self.domain, self.window, self.symbol)
 
     def __rsub__(self, other):
         try:
             coef = self._sub(other, self.coef)
         except Exception:
             return NotImplemented
-        return self.__class__(coef, self.domain, self.window)
+        return self.__class__(coef, self.domain, self.window, self.symbol)
 
     def __rmul__(self, other):
         try:
             coef = self._mul(other, self.coef)
         except Exception:
             return NotImplemented
-        return self.__class__(coef, self.domain, self.window)
+        return self.__class__(coef, self.domain, self.window, self.symbol)
 
     def __rdiv__(self, other):
         # set to __floordiv__ /.
@@ -609,8 +641,8 @@ def __rdivmod__(self, other):
             raise
         except Exception:
             return NotImplemented
-        quo = self.__class__(quo, self.domain, self.window)
-        rem = self.__class__(rem, self.domain, self.window)
+        quo = self.__class__(quo, self.domain, self.window, self.symbol)
+        rem = self.__class__(rem, self.domain, self.window, self.symbol)
         return quo, rem
 
     def __eq__(self, other):
@@ -618,7 +650,8 @@ def __eq__(self, other):
                np.all(self.domain == other.domain) and
                np.all(self.window == other.window) and
                (self.coef.shape == other.coef.shape) and
-               np.all(self.coef == other.coef))
+               np.all(self.coef == other.coef) and
+               (self.symbol == other.symbol))
         return res
 
     def __ne__(self, other):
@@ -637,7 +670,7 @@ def copy(self):
             Copy of self.
 
         """
-        return self.__class__(self.coef, self.domain, self.window)
+        return self.__class__(self.coef, self.domain, self.window, self.symbol)
 
     def degree(self):
         """The degree of the series.
@@ -698,7 +731,7 @@ def trim(self, tol=0):
 
         """
         coef = pu.trimcoef(self.coef, tol)
-        return self.__class__(coef, self.domain, self.window)
+        return self.__class__(coef, self.domain, self.window, self.symbol)
 
     def truncate(self, size):
         """Truncate series to length `size`.
@@ -727,7 +760,7 @@ def truncate(self, size):
             coef = self.coef
         else:
             coef = self.coef[:isize]
-        return self.__class__(coef, self.domain, self.window)
+        return self.__class__(coef, self.domain, self.window, self.symbol)
 
     def convert(self, domain=None, kind=None, window=None):
         """Convert series to a different kind and/or domain and/or window.
@@ -764,7 +797,7 @@ def convert(self, domain=None, kind=None, window=None):
             domain = kind.domain
         if window is None:
             window = kind.window
-        return self(kind.identity(domain, window=window))
+        return self(kind.identity(domain, window=window, symbol=self.symbol))
 
     def mapparms(self):
         """Return the mapping parameters.
@@ -826,7 +859,7 @@ def integ(self, m=1, k=[], lbnd=None):
         else:
             lbnd = off + scl*lbnd
         coef = self._int(self.coef, m, k, lbnd, 1./scl)
-        return self.__class__(coef, self.domain, self.window)
+        return self.__class__(coef, self.domain, self.window, self.symbol)
 
     def deriv(self, m=1):
         """Differentiate.
@@ -848,7 +881,7 @@ def deriv(self, m=1):
         """
         off, scl = self.mapparms()
         coef = self._der(self.coef, m, scl)
-        return self.__class__(coef, self.domain, self.window)
+        return self.__class__(coef, self.domain, self.window, self.symbol)
 
     def roots(self):
         """Return the roots of the series polynomial.
@@ -899,7 +932,7 @@ def linspace(self, n=100, domain=None):
 
     @classmethod
     def fit(cls, x, y, deg, domain=None, rcond=None, full=False, w=None,
-        window=None):
+        window=None, symbol='x'):
         """Least squares fit to data.
 
         Return a series instance that is the least squares fit to the data
@@ -948,6 +981,8 @@ class domain in NumPy 1.4 and ``None`` in later versions.
             value is the default class domain
 
             .. versionadded:: 1.6.0
+        symbol : str, optional
+            Symbol representing the independent variable. Default is 'x'.
 
         Returns
         -------
@@ -980,13 +1015,15 @@ class domain in NumPy 1.4 and ``None`` in later versions.
         res = cls._fit(xnew, y, deg, w=w, rcond=rcond, full=full)
         if full:
             [coef, status] = res
-            return cls(coef, domain=domain, window=window), status
+            return (
+                cls(coef, domain=domain, window=window, symbol=symbol), status
+            )
         else:
             coef = res
-            return cls(coef, domain=domain, window=window)
+            return cls(coef, domain=domain, window=window, symbol=symbol)
 
     @classmethod
-    def fromroots(cls, roots, domain=[], window=None):
+    def fromroots(cls, roots, domain=[], window=None, symbol='x'):
         """Return series instance that has the specified roots.
 
         Returns a series representing the product
@@ -1004,6 +1041,8 @@ def fromroots(cls, roots, domain=[], window=None):
         window : {None, array_like}, optional
             Window for the returned series. If None the class window is
             used. The default is None.
+        symbol : str, optional
+            Symbol representing the independent variable. Default is 'x'.
 
         Returns
         -------
@@ -1024,10 +1063,10 @@ def fromroots(cls, roots, domain=[], window=None):
         off, scl = pu.mapparms(domain, window)
         rnew = off + scl*roots
         coef = cls._fromroots(rnew) / scl**deg
-        return cls(coef, domain=domain, window=window)
+        return cls(coef, domain=domain, window=window, symbol=symbol)
 
     @classmethod
-    def identity(cls, domain=None, window=None):
+    def identity(cls, domain=None, window=None, symbol='x'):
         """Identity function.
 
         If ``p`` is the returned series, then ``p(x) == x`` for all
@@ -1044,6 +1083,8 @@ def identity(cls, domain=None, window=None):
             ``[beg, end]``, where ``beg`` and ``end`` are the endpoints of
             the window. If None is given then the class window is used. The
             default is None.
+        symbol : str, optional
+            Symbol representing the independent variable. Default is 'x'.
 
         Returns
         -------
@@ -1057,10 +1098,10 @@ def identity(cls, domain=None, window=None):
             window = cls.window
         off, scl = pu.mapparms(window, domain)
         coef = cls._line(off, scl)
-        return cls(coef, domain, window)
+        return cls(coef, domain, window, symbol)
 
     @classmethod
-    def basis(cls, deg, domain=None, window=None):
+    def basis(cls, deg, domain=None, window=None, symbol='x'):
         """Series basis polynomial of degree `deg`.
 
         Returns the series representing the basis polynomial of degree `deg`.
@@ -1080,6 +1121,8 @@ def basis(cls, deg, domain=None, window=None):
             ``[beg, end]``, where ``beg`` and ``end`` are the endpoints of
             the window. If None is given then the class window is used. The
             default is None.
+        symbol : str, optional
+            Symbol representing the independent variable. Default is 'x'.
 
         Returns
         -------
@@ -1096,7 +1139,7 @@ def basis(cls, deg, domain=None, window=None):
 
         if ideg != deg or ideg < 0:
             raise ValueError("deg must be non-negative integer")
-        return cls([0]*ideg + [1], domain, window)
+        return cls([0]*ideg + [1], domain, window, symbol)
 
     @classmethod
     def cast(cls, series, domain=None, window=None):
diff --git a/numpy/polynomial/_polybase.pyi b/numpy/polynomial/_polybase.pyi
index c4160146947f..25c740dbedd0 100644
--- a/numpy/polynomial/_polybase.pyi
+++ b/numpy/polynomial/_polybase.pyi
@@ -1,7 +1,7 @@
 import abc
-from typing import Any, List, ClassVar
+from typing import Any, ClassVar
 
-__all__: List[str]
+__all__: list[str]
 
 class ABCPolyBase(abc.ABC):
     __hash__: ClassVar[None]  # type: ignore[assignment]
@@ -9,6 +9,8 @@ class ABCPolyBase(abc.ABC):
     maxpower: ClassVar[int]
     coef: Any
     @property
+    def symbol(self) -> str: ...
+    @property
     @abc.abstractmethod
     def domain(self): ...
     @property
@@ -21,7 +23,7 @@ class ABCPolyBase(abc.ABC):
     def has_samedomain(self, other): ...
     def has_samewindow(self, other): ...
     def has_sametype(self, other): ...
-    def __init__(self, coef, domain=..., window=...): ...
+    def __init__(self, coef, domain=..., window=..., symbol: str = ...) -> None: ...
     def __format__(self, fmt_str): ...
     def __call__(self, arg): ...
     def __iter__(self): ...
diff --git a/numpy/polynomial/chebyshev.py b/numpy/polynomial/chebyshev.py
index 89ce815d571e..c663ffab06fd 100644
--- a/numpy/polynomial/chebyshev.py
+++ b/numpy/polynomial/chebyshev.py
@@ -1119,7 +1119,7 @@ def chebval(x, c, tensor=True):
         If `x` is a list or tuple, it is converted to an ndarray, otherwise
         it is left unchanged and treated as a scalar. In either case, `x`
         or its elements must support addition and multiplication with
-        with themselves and with the elements of `c`.
+        themselves and with the elements of `c`.
     c : array_like
         Array of coefficients ordered so that the coefficients for terms of
         degree n are contained in c[n]. If `c` is multidimensional the
@@ -1959,7 +1959,8 @@ def chebpts2(npts):
     Chebyshev points of the second kind.
 
     The Chebyshev points of the second kind are the points ``cos(x)``,
-    where ``x = [pi*k/(npts - 1) for k in range(npts)]``.
+    where ``x = [pi*k/(npts - 1) for k in range(npts)]`` sorted in ascending
+    order.
 
     Parameters
     ----------
diff --git a/numpy/polynomial/chebyshev.pyi b/numpy/polynomial/chebyshev.pyi
index 841c0859b1b0..e8113dbae780 100644
--- a/numpy/polynomial/chebyshev.pyi
+++ b/numpy/polynomial/chebyshev.pyi
@@ -1,10 +1,10 @@
-from typing import Any, List
+from typing import Any
 
 from numpy import ndarray, dtype, int_
 from numpy.polynomial._polybase import ABCPolyBase
 from numpy.polynomial.polyutils import trimcoef
 
-__all__: List[str]
+__all__: list[str]
 
 chebtrim = trimcoef
 
diff --git a/numpy/polynomial/hermite.py b/numpy/polynomial/hermite.py
index 9b0735a9aad3..e20339121884 100644
--- a/numpy/polynomial/hermite.py
+++ b/numpy/polynomial/hermite.py
@@ -827,7 +827,7 @@ def hermval(x, c, tensor=True):
         If `x` is a list or tuple, it is converted to an ndarray, otherwise
         it is left unchanged and treated as a scalar. In either case, `x`
         or its elements must support addition and multiplication with
-        with themselves and with the elements of `c`.
+        themselves and with the elements of `c`.
     c : array_like
         Array of coefficients ordered so that the coefficients for terms of
         degree n are contained in c[n]. If `c` is multidimensional the
diff --git a/numpy/polynomial/hermite.pyi b/numpy/polynomial/hermite.pyi
index 8364a5b0fcbc..0d3556d69641 100644
--- a/numpy/polynomial/hermite.pyi
+++ b/numpy/polynomial/hermite.pyi
@@ -1,4 +1,4 @@
-from typing import Any, List
+from typing import Any
 
 from numpy import ndarray, dtype, int_, float_
 from numpy.polynomial._polybase import ABCPolyBase
diff --git a/numpy/polynomial/hermite_e.pyi b/numpy/polynomial/hermite_e.pyi
index c029bfda7788..0b7152a253b6 100644
--- a/numpy/polynomial/hermite_e.pyi
+++ b/numpy/polynomial/hermite_e.pyi
@@ -1,4 +1,4 @@
-from typing import Any, List
+from typing import Any
 
 from numpy import ndarray, dtype, int_
 from numpy.polynomial._polybase import ABCPolyBase
diff --git a/numpy/polynomial/laguerre.py b/numpy/polynomial/laguerre.py
index d9ca373ddd5c..2eacceceda11 100644
--- a/numpy/polynomial/laguerre.py
+++ b/numpy/polynomial/laguerre.py
@@ -826,7 +826,7 @@ def lagval(x, c, tensor=True):
         If `x` is a list or tuple, it is converted to an ndarray, otherwise
         it is left unchanged and treated as a scalar. In either case, `x`
         or its elements must support addition and multiplication with
-        with themselves and with the elements of `c`.
+        themselves and with the elements of `c`.
     c : array_like
         Array of coefficients ordered so that the coefficients for terms of
         degree n are contained in c[n]. If `c` is multidimensional the
@@ -1282,7 +1282,7 @@ def lagfit(x, y, deg, rcond=None, full=False, w=None):
 
     .. math::  p(x) = c_0 + c_1 * L_1(x) + ... + c_n * L_n(x),
 
-    where `n` is `deg`.
+    where ``n`` is `deg`.
 
     Parameters
     ----------
@@ -1317,8 +1317,8 @@ def lagfit(x, y, deg, rcond=None, full=False, w=None):
     -------
     coef : ndarray, shape (M,) or (M, K)
         Laguerre coefficients ordered from low to high. If `y` was 2-D,
-        the coefficients for the data in column k  of `y` are in column
-        `k`.
+        the coefficients for the data in column *k*  of `y` are in column
+        *k*.
 
     [residuals, rank, singular_values, rcond] : list
         These values are only returned if ``full == True``
@@ -1355,7 +1355,7 @@ def lagfit(x, y, deg, rcond=None, full=False, w=None):
 
     Notes
     -----
-    The solution is the coefficients of the Laguerre series `p` that
+    The solution is the coefficients of the Laguerre series ``p`` that
     minimizes the sum of the weighted squared errors
 
     .. math:: E = \\sum_j w_j^2 * |y_j - p(x_j)|^2,
@@ -1365,10 +1365,10 @@ def lagfit(x, y, deg, rcond=None, full=False, w=None):
 
     .. math:: V(x) * c = w * y,
 
-    where `V` is the weighted pseudo Vandermonde matrix of `x`, `c` are the
+    where ``V`` is the weighted pseudo Vandermonde matrix of `x`, ``c`` are the
     coefficients to be solved for, `w` are the weights, and `y` are the
     observed values.  This equation is then solved using the singular value
-    decomposition of `V`.
+    decomposition of ``V``.
 
     If some of the singular values of `V` are so small that they are
     neglected, then a `RankWarning` will be issued. This means that the
@@ -1378,7 +1378,7 @@ def lagfit(x, y, deg, rcond=None, full=False, w=None):
     spurious and have large contributions from roundoff error.
 
     Fits using Laguerre series are probably most useful when the data can
-    be approximated by ``sqrt(w(x)) * p(x)``, where `w(x)` is the Laguerre
+    be approximated by ``sqrt(w(x)) * p(x)``, where ``w(x)`` is the Laguerre
     weight. In that case the weight ``sqrt(w(x[i]))`` should be used
     together with data values ``y[i]/sqrt(w(x[i]))``. The weight function is
     available as `lagweight`.
diff --git a/numpy/polynomial/laguerre.pyi b/numpy/polynomial/laguerre.pyi
index 2b9ab34e0afa..e546bc20a54c 100644
--- a/numpy/polynomial/laguerre.pyi
+++ b/numpy/polynomial/laguerre.pyi
@@ -1,4 +1,4 @@
-from typing import Any, List
+from typing import Any
 
 from numpy import ndarray, dtype, int_
 from numpy.polynomial._polybase import ABCPolyBase
diff --git a/numpy/polynomial/legendre.py b/numpy/polynomial/legendre.py
index 2e8052e7c007..028e2fe7b366 100644
--- a/numpy/polynomial/legendre.py
+++ b/numpy/polynomial/legendre.py
@@ -185,7 +185,7 @@ def leg2poly(c):
     >>> p = c.convert(kind=P.Polynomial)
     >>> p
     Polynomial([-1. , -3.5,  3. ,  7.5], domain=[-1.,  1.], window=[-1.,  1.])
-    >>> P.leg2poly(range(4))
+    >>> P.legendre.leg2poly(range(4))
     array([-1. , -3.5,  3. ,  7.5])
 
 
@@ -857,7 +857,7 @@ def legval(x, c, tensor=True):
         If `x` is a list or tuple, it is converted to an ndarray, otherwise
         it is left unchanged and treated as a scalar. In either case, `x`
         or its elements must support addition and multiplication with
-        with themselves and with the elements of `c`.
+        themselves and with the elements of `c`.
     c : array_like
         Array of coefficients ordered so that the coefficients for terms of
         degree n are contained in c[n]. If `c` is multidimensional the
diff --git a/numpy/polynomial/legendre.pyi b/numpy/polynomial/legendre.pyi
index 86aef179304e..63a1c3f3a1f8 100644
--- a/numpy/polynomial/legendre.pyi
+++ b/numpy/polynomial/legendre.pyi
@@ -1,4 +1,4 @@
-from typing import Any, List
+from typing import Any
 
 from numpy import ndarray, dtype, int_
 from numpy.polynomial._polybase import ABCPolyBase
diff --git a/numpy/polynomial/polynomial.py b/numpy/polynomial/polynomial.py
index 3c2663b6cc95..d102f5a30e71 100644
--- a/numpy/polynomial/polynomial.py
+++ b/numpy/polynomial/polynomial.py
@@ -772,7 +772,7 @@ def polyvalfromroots(x, r, tensor=True):
 
     If `r` is a 1-D array, then `p(x)` will have the same shape as `x`.  If `r`
     is multidimensional, then the shape of the result depends on the value of
-    `tensor`. If `tensor is ``True`` the shape will be r.shape[1:] + x.shape;
+    `tensor`. If `tensor` is ``True`` the shape will be r.shape[1:] + x.shape;
     that is, each polynomial is evaluated at every value of `x`. If `tensor` is
     ``False``, the shape will be r.shape[1:]; that is, each polynomial is
     evaluated only for the corresponding broadcast value of `x`. Note that
@@ -1339,7 +1339,7 @@ def polyfit(x, y, deg, rcond=None, full=False, w=None):
     >>> np.random.seed(123)
     >>> from numpy.polynomial import polynomial as P
     >>> x = np.linspace(-1,1,51) # x "data": [-1, -0.96, ..., 0.96, 1]
-    >>> y = x**3 - x + np.random.randn(len(x)) # x^3 - x + N(0,1) "noise"
+    >>> y = x**3 - x + np.random.randn(len(x))  # x^3 - x + Gaussian noise
     >>> c, stats = P.polyfit(x,y,3,full=True)
     >>> np.random.seed(123)
     >>> c # c[0], c[2] should be approx. 0, c[1] approx. -1, c[3] approx. 1
@@ -1512,11 +1512,17 @@ class Polynomial(ABCPolyBase):
 
     @classmethod
     def _str_term_unicode(cls, i, arg_str):
-        return f"·{arg_str}{i.translate(cls._superscript_mapping)}"
+        if i == '1':
+            return f"·{arg_str}"
+        else:
+            return f"·{arg_str}{i.translate(cls._superscript_mapping)}"
 
     @staticmethod
     def _str_term_ascii(i, arg_str):
-        return f" {arg_str}**{i}"
+        if i == '1':
+            return f" {arg_str}"
+        else:
+            return f" {arg_str}**{i}"
 
     @staticmethod
     def _repr_latex_term(i, arg_str, needs_parens):
diff --git a/numpy/polynomial/polynomial.pyi b/numpy/polynomial/polynomial.pyi
index f779300a9c5a..3c87f9d29266 100644
--- a/numpy/polynomial/polynomial.pyi
+++ b/numpy/polynomial/polynomial.pyi
@@ -1,4 +1,4 @@
-from typing import Any, List
+from typing import Any
 
 from numpy import ndarray, dtype, int_
 from numpy.polynomial._polybase import ABCPolyBase
diff --git a/numpy/polynomial/polyutils.py b/numpy/polynomial/polyutils.py
index a2bc75a4d331..482913892016 100644
--- a/numpy/polynomial/polyutils.py
+++ b/numpy/polynomial/polyutils.py
@@ -32,9 +32,13 @@
 
 import numpy as np
 
+from numpy.core.multiarray import dragon4_positional, dragon4_scientific
+from numpy.core.umath import absolute
+
 __all__ = [
     'RankWarning', 'as_series', 'trimseq',
-    'trimcoef', 'getdomain', 'mapdomain', 'mapparms']
+    'trimcoef', 'getdomain', 'mapdomain', 'mapparms',
+    'format_float']
 
 #
 # Warnings and Exceptions
@@ -748,3 +752,38 @@ def _deprecate_as_int(x, desc):
                 return ix
 
         raise TypeError(f"{desc} must be an integer") from e
+
+
+def format_float(x, parens=False):
+    if not np.issubdtype(type(x), np.floating):
+        return str(x)
+
+    opts = np.get_printoptions()
+
+    if np.isnan(x):
+        return opts['nanstr']
+    elif np.isinf(x):
+        return opts['infstr']
+
+    exp_format = False
+    if x != 0:
+        a = absolute(x)
+        if a >= 1.e8 or a < 10**min(0, -(opts['precision']-1)//2):
+            exp_format = True
+
+    trim, unique = '0', True
+    if opts['floatmode'] == 'fixed':
+        trim, unique = 'k', False
+
+    if exp_format:
+        s = dragon4_scientific(x, precision=opts['precision'],
+                               unique=unique, trim=trim, 
+                               sign=opts['sign'] == '+')
+        if parens:
+            s = '(' + s + ')'
+    else:
+        s = dragon4_positional(x, precision=opts['precision'],
+                               fractional=True,
+                               unique=unique, trim=trim,
+                               sign=opts['sign'] == '+')
+    return s
diff --git a/numpy/polynomial/polyutils.pyi b/numpy/polynomial/polyutils.pyi
index 52c9cfc4a607..c0bcc67847f6 100644
--- a/numpy/polynomial/polyutils.pyi
+++ b/numpy/polynomial/polyutils.pyi
@@ -1,6 +1,4 @@
-from typing import List
-
-__all__: List[str]
+__all__: list[str]
 
 class RankWarning(UserWarning): ...
 
@@ -10,3 +8,4 @@ def trimcoef(c, tol=...): ...
 def getdomain(x): ...
 def mapparms(old, new): ...
 def mapdomain(x, old, new): ...
+def format_float(x, parens=...): ...
diff --git a/numpy/polynomial/tests/test_polynomial.py b/numpy/polynomial/tests/test_polynomial.py
index a0a09fcf4a93..6b3ef2388f63 100644
--- a/numpy/polynomial/tests/test_polynomial.py
+++ b/numpy/polynomial/tests/test_polynomial.py
@@ -5,6 +5,8 @@
 
 import numpy as np
 import numpy.polynomial.polynomial as poly
+import pickle
+from copy import deepcopy
 from numpy.testing import (
     assert_almost_equal, assert_raises, assert_equal, assert_,
     assert_warns, assert_array_equal, assert_raises_regex)
@@ -41,6 +43,15 @@ def test_polyone(self):
     def test_polyx(self):
         assert_equal(poly.polyx, [0, 1])
 
+    def test_copy(self):
+        x = poly.Polynomial([1, 2, 3])
+        y = deepcopy(x)
+        assert_equal(x, y)
+
+    def test_pickle(self):
+        x = poly.Polynomial([1, 2, 3])
+        y = pickle.loads(pickle.dumps(x))
+        assert_equal(x, y)
 
 class TestArithmetic:
 
diff --git a/numpy/polynomial/tests/test_printing.py b/numpy/polynomial/tests/test_printing.py
index 4e9902a69588..6f2a5092d722 100644
--- a/numpy/polynomial/tests/test_printing.py
+++ b/numpy/polynomial/tests/test_printing.py
@@ -1,3 +1,4 @@
+from math import nan, inf
 import pytest
 from numpy.core import array, arange, printoptions
 import numpy.polynomial as poly
@@ -15,9 +16,9 @@ def use_unicode(self):
         poly.set_default_printstyle('unicode')
 
     @pytest.mark.parametrize(('inp', 'tgt'), (
-        ([1, 2, 3], "1.0 + 2.0·x¹ + 3.0·x²"),
-        ([-1, 0, 3, -1], "-1.0 + 0.0·x¹ + 3.0·x² - 1.0·x³"),
-        (arange(12), ("0.0 + 1.0·x¹ + 2.0·x² + 3.0·x³ + 4.0·x⁴ + 5.0·x⁵ + "
+        ([1, 2, 3], "1.0 + 2.0·x + 3.0·x²"),
+        ([-1, 0, 3, -1], "-1.0 + 0.0·x + 3.0·x² - 1.0·x³"),
+        (arange(12), ("0.0 + 1.0·x + 2.0·x² + 3.0·x³ + 4.0·x⁴ + 5.0·x⁵ + "
                       "6.0·x⁶ + 7.0·x⁷ +\n8.0·x⁸ + 9.0·x⁹ + 10.0·x¹⁰ + "
                       "11.0·x¹¹")),
     ))
@@ -89,9 +90,9 @@ def use_ascii(self):
         poly.set_default_printstyle('ascii')
 
     @pytest.mark.parametrize(('inp', 'tgt'), (
-        ([1, 2, 3], "1.0 + 2.0 x**1 + 3.0 x**2"),
-        ([-1, 0, 3, -1], "-1.0 + 0.0 x**1 + 3.0 x**2 - 1.0 x**3"),
-        (arange(12), ("0.0 + 1.0 x**1 + 2.0 x**2 + 3.0 x**3 + 4.0 x**4 + "
+        ([1, 2, 3], "1.0 + 2.0 x + 3.0 x**2"),
+        ([-1, 0, 3, -1], "-1.0 + 0.0 x + 3.0 x**2 - 1.0 x**3"),
+        (arange(12), ("0.0 + 1.0 x + 2.0 x**2 + 3.0 x**3 + 4.0 x**4 + "
                       "5.0 x**5 + 6.0 x**6 +\n7.0 x**7 + 8.0 x**8 + "
                       "9.0 x**9 + 10.0 x**10 + 11.0 x**11")),
     ))
@@ -168,51 +169,51 @@ def use_ascii(self):
 
     def test_single_line_one_less(self):
         # With 'ascii' style, len(str(p)) is default linewidth - 1 (i.e. 74)
-        p = poly.Polynomial([123456789, 123456789, 123456789, 1234, 1])
+        p = poly.Polynomial([12345678, 12345678, 12345678, 12345678, 123])
         assert_equal(len(str(p)), 74)
         assert_equal(str(p), (
-            '123456789.0 + 123456789.0 x**1 + 123456789.0 x**2 + '
-            '1234.0 x**3 + 1.0 x**4'
+            '12345678.0 + 12345678.0 x + 12345678.0 x**2 + '
+            '12345678.0 x**3 + 123.0 x**4'
         ))
 
     def test_num_chars_is_linewidth(self):
         # len(str(p)) == default linewidth == 75
-        p = poly.Polynomial([123456789, 123456789, 123456789, 1234, 10])
+        p = poly.Polynomial([12345678, 12345678, 12345678, 12345678, 1234])
         assert_equal(len(str(p)), 75)
         assert_equal(str(p), (
-            '123456789.0 + 123456789.0 x**1 + 123456789.0 x**2 + '
-            '1234.0 x**3 +\n10.0 x**4'
+            '12345678.0 + 12345678.0 x + 12345678.0 x**2 + '
+            '12345678.0 x**3 +\n1234.0 x**4'
         ))
 
     def test_first_linebreak_multiline_one_less_than_linewidth(self):
         # Multiline str where len(first_line) + len(next_term) == lw - 1 == 74
         p = poly.Polynomial(
-                [123456789, 123456789, 123456789, 12, 1, 123456789]
+                [12345678, 12345678, 12345678, 12345678, 1, 12345678]
             )
         assert_equal(len(str(p).split('\n')[0]), 74)
         assert_equal(str(p), (
-            '123456789.0 + 123456789.0 x**1 + 123456789.0 x**2 + '
-            '12.0 x**3 + 1.0 x**4 +\n123456789.0 x**5'
+            '12345678.0 + 12345678.0 x + 12345678.0 x**2 + '
+            '12345678.0 x**3 + 1.0 x**4 +\n12345678.0 x**5'
         ))
 
     def test_first_linebreak_multiline_on_linewidth(self):
         # First line is one character longer than previous test
         p = poly.Polynomial(
-                [123456789, 123456789, 123456789, 123, 1, 123456789]
+                [12345678, 12345678, 12345678, 12345678.12, 1, 12345678]
             )
         assert_equal(str(p), (
-            '123456789.0 + 123456789.0 x**1 + 123456789.0 x**2 + '
-            '123.0 x**3 +\n1.0 x**4 + 123456789.0 x**5'
+            '12345678.0 + 12345678.0 x + 12345678.0 x**2 + '
+            '12345678.12 x**3 +\n1.0 x**4 + 12345678.0 x**5'
         ))
 
     @pytest.mark.parametrize(('lw', 'tgt'), (
-        (75, ('0.0 + 10.0 x**1 + 200.0 x**2 + 3000.0 x**3 + 40000.0 x**4 +\n'
-              '500000.0 x**5 + 600000.0 x**6 + 70000.0 x**7 + 8000.0 x**8 + '
+        (75, ('0.0 + 10.0 x + 200.0 x**2 + 3000.0 x**3 + 40000.0 x**4 + '
+              '500000.0 x**5 +\n600000.0 x**6 + 70000.0 x**7 + 8000.0 x**8 + '
               '900.0 x**9')),
-        (45, ('0.0 + 10.0 x**1 + 200.0 x**2 + 3000.0 x**3 +\n40000.0 x**4 + '
+        (45, ('0.0 + 10.0 x + 200.0 x**2 + 3000.0 x**3 +\n40000.0 x**4 + '
               '500000.0 x**5 +\n600000.0 x**6 + 70000.0 x**7 + 8000.0 x**8 +\n'
               '900.0 x**9')),
-        (132, ('0.0 + 10.0 x**1 + 200.0 x**2 + 3000.0 x**3 + 40000.0 x**4 + '
+        (132, ('0.0 + 10.0 x + 200.0 x**2 + 3000.0 x**3 + 40000.0 x**4 + '
                '500000.0 x**5 + 600000.0 x**6 + 70000.0 x**7 + 8000.0 x**8 + '
                '900.0 x**9')),
     ))
@@ -230,10 +231,10 @@ def test_set_default_printoptions():
     p = poly.Polynomial([1, 2, 3])
     c = poly.Chebyshev([1, 2, 3])
     poly.set_default_printstyle('ascii')
-    assert_equal(str(p), "1.0 + 2.0 x**1 + 3.0 x**2")
+    assert_equal(str(p), "1.0 + 2.0 x + 3.0 x**2")
     assert_equal(str(c), "1.0 + 2.0 T_1(x) + 3.0 T_2(x)")
     poly.set_default_printstyle('unicode')
-    assert_equal(str(p), "1.0 + 2.0·x¹ + 3.0·x²")
+    assert_equal(str(p), "1.0 + 2.0·x + 3.0·x²")
     assert_equal(str(c), "1.0 + 2.0·T₁(x) + 3.0·T₂(x)")
     with pytest.raises(ValueError):
         poly.set_default_printstyle('invalid_input')
@@ -247,22 +248,22 @@ def test_complex_coefficients():
     # Python complex
     p2 = poly.Polynomial(array(coefs, dtype=object))
     poly.set_default_printstyle('unicode')
-    assert_equal(str(p1), "1j + (1+1j)·x¹ - (2-2j)·x² + (3+0j)·x³")
-    assert_equal(str(p2), "1j + (1+1j)·x¹ + (-2+2j)·x² + (3+0j)·x³")
+    assert_equal(str(p1), "1j + (1+1j)·x - (2-2j)·x² + (3+0j)·x³")
+    assert_equal(str(p2), "1j + (1+1j)·x + (-2+2j)·x² + (3+0j)·x³")
     poly.set_default_printstyle('ascii')
-    assert_equal(str(p1), "1j + (1+1j) x**1 - (2-2j) x**2 + (3+0j) x**3")
-    assert_equal(str(p2), "1j + (1+1j) x**1 + (-2+2j) x**2 + (3+0j) x**3")
+    assert_equal(str(p1), "1j + (1+1j) x - (2-2j) x**2 + (3+0j) x**3")
+    assert_equal(str(p2), "1j + (1+1j) x + (-2+2j) x**2 + (3+0j) x**3")
 
 
 @pytest.mark.parametrize(('coefs', 'tgt'), (
     (array([Fraction(1, 2), Fraction(3, 4)], dtype=object), (
-        "1/2 + 3/4·x¹"
+        "1/2 + 3/4·x"
     )),
     (array([1, 2, Fraction(5, 7)], dtype=object), (
-        "1 + 2·x¹ + 5/7·x²"
+        "1 + 2·x + 5/7·x²"
     )),
     (array([Decimal('1.00'), Decimal('2.2'), 3], dtype=object), (
-        "1.00 + 2.2·x¹ + 3·x²"
+        "1.00 + 2.2·x + 3·x²"
     )),
 ))
 def test_numeric_object_coefficients(coefs, tgt):
@@ -272,8 +273,8 @@ def test_numeric_object_coefficients(coefs, tgt):
 
 
 @pytest.mark.parametrize(('coefs', 'tgt'), (
-    (array([1, 2, 'f'], dtype=object), '1 + 2·x¹ + f·x²'),
-    (array([1, 2, [3, 4]], dtype=object), '1 + 2·x¹ + [3, 4]·x²'),
+    (array([1, 2, 'f'], dtype=object), '1 + 2·x + f·x²'),
+    (array([1, 2, [3, 4]], dtype=object), '1 + 2·x + [3, 4]·x²'),
 ))
 def test_nonnumeric_object_coefficients(coefs, tgt):
     """
@@ -288,20 +289,20 @@ class TestFormat:
     def test_format_unicode(self):
         poly.set_default_printstyle('ascii')
         p = poly.Polynomial([1, 2, 0, -1])
-        assert_equal(format(p, 'unicode'), "1.0 + 2.0·x¹ + 0.0·x² - 1.0·x³")
+        assert_equal(format(p, 'unicode'), "1.0 + 2.0·x + 0.0·x² - 1.0·x³")
 
     def test_format_ascii(self):
         poly.set_default_printstyle('unicode')
         p = poly.Polynomial([1, 2, 0, -1])
         assert_equal(
-            format(p, 'ascii'), "1.0 + 2.0 x**1 + 0.0 x**2 - 1.0 x**3"
+            format(p, 'ascii'), "1.0 + 2.0 x + 0.0 x**2 - 1.0 x**3"
         )
 
     def test_empty_formatstr(self):
         poly.set_default_printstyle('ascii')
         p = poly.Polynomial([1, 2, 3])
-        assert_equal(format(p), "1.0 + 2.0 x**1 + 3.0 x**2")
-        assert_equal(f"{p}", "1.0 + 2.0 x**1 + 3.0 x**2")
+        assert_equal(format(p), "1.0 + 2.0 x + 3.0 x**2")
+        assert_equal(f"{p}", "1.0 + 2.0 x + 3.0 x**2")
 
     def test_bad_formatstr(self):
         p = poly.Polynomial([1, 2, 0, -1])
@@ -309,35 +310,66 @@ def test_bad_formatstr(self):
             format(p, '.2f')
 
 
+@pytest.mark.parametrize(('poly', 'tgt'), (
+    (poly.Polynomial, '1.0 + 2.0·z + 3.0·z²'),
+    (poly.Chebyshev, '1.0 + 2.0·T₁(z) + 3.0·T₂(z)'),
+    (poly.Hermite, '1.0 + 2.0·H₁(z) + 3.0·H₂(z)'),
+    (poly.HermiteE, '1.0 + 2.0·He₁(z) + 3.0·He₂(z)'),
+    (poly.Laguerre, '1.0 + 2.0·L₁(z) + 3.0·L₂(z)'),
+    (poly.Legendre, '1.0 + 2.0·P₁(z) + 3.0·P₂(z)'),
+))
+def test_symbol(poly, tgt):
+    p = poly([1, 2, 3], symbol='z')
+    assert_equal(f"{p:unicode}", tgt)
+
+
 class TestRepr:
     def test_polynomial_str(self):
         res = repr(poly.Polynomial([0, 1]))
-        tgt = 'Polynomial([0., 1.], domain=[-1,  1], window=[-1,  1])'
+        tgt = (
+            "Polynomial([0., 1.], domain=[-1,  1], window=[-1,  1], "
+            "symbol='x')"
+        )
         assert_equal(res, tgt)
 
     def test_chebyshev_str(self):
         res = repr(poly.Chebyshev([0, 1]))
-        tgt = 'Chebyshev([0., 1.], domain=[-1,  1], window=[-1,  1])'
+        tgt = (
+            "Chebyshev([0., 1.], domain=[-1,  1], window=[-1,  1], "
+            "symbol='x')"
+        )
         assert_equal(res, tgt)
 
     def test_legendre_repr(self):
         res = repr(poly.Legendre([0, 1]))
-        tgt = 'Legendre([0., 1.], domain=[-1,  1], window=[-1,  1])'
+        tgt = (
+            "Legendre([0., 1.], domain=[-1,  1], window=[-1,  1], "
+            "symbol='x')"
+        )
         assert_equal(res, tgt)
 
     def test_hermite_repr(self):
         res = repr(poly.Hermite([0, 1]))
-        tgt = 'Hermite([0., 1.], domain=[-1,  1], window=[-1,  1])'
+        tgt = (
+            "Hermite([0., 1.], domain=[-1,  1], window=[-1,  1], "
+            "symbol='x')"
+        )
         assert_equal(res, tgt)
 
     def test_hermiteE_repr(self):
         res = repr(poly.HermiteE([0, 1]))
-        tgt = 'HermiteE([0., 1.], domain=[-1,  1], window=[-1,  1])'
+        tgt = (
+            "HermiteE([0., 1.], domain=[-1,  1], window=[-1,  1], "
+            "symbol='x')"
+        )
         assert_equal(res, tgt)
 
     def test_laguerre_repr(self):
         res = repr(poly.Laguerre([0, 1]))
-        tgt = 'Laguerre([0., 1.], domain=[0, 1], window=[0, 1])'
+        tgt = (
+            "Laguerre([0., 1.], domain=[0, 1], window=[0, 1], "
+            "symbol='x')"
+        )
         assert_equal(res, tgt)
 
 
@@ -348,7 +380,7 @@ def as_latex(self, obj):
         # right now we ignore the formatting of scalars in our tests, since
         # it makes them too verbose. Ideally, the formatting of scalars will
         # be fixed such that tests below continue to pass
-        obj._repr_latex_scalar = lambda x: str(x)
+        obj._repr_latex_scalar = lambda x, parens=False: str(x)
         try:
             return obj._repr_latex_()
         finally:
@@ -388,3 +420,111 @@ def test_multichar_basis_func(self):
         p = poly.HermiteE([1, 2, 3])
         assert_equal(self.as_latex(p),
             r'$x \mapsto 1.0\,{He}_{0}(x) + 2.0\,{He}_{1}(x) + 3.0\,{He}_{2}(x)$')
+
+    def test_symbol_basic(self):
+        # default input
+        p = poly.Polynomial([1, 2, 3], symbol='z')
+        assert_equal(self.as_latex(p),
+            r'$z \mapsto 1.0 + 2.0\,z + 3.0\,z^{2}$')
+
+        # translated input
+        p = poly.Polynomial([1, 2, 3], domain=[-2, 0], symbol='z')
+        assert_equal(
+            self.as_latex(p),
+            (
+                r'$z \mapsto 1.0 + 2.0\,\left(1.0 + z\right) + 3.0\,'
+                r'\left(1.0 + z\right)^{2}$'
+            ),
+        )
+
+        # scaled input
+        p = poly.Polynomial([1, 2, 3], domain=[-0.5, 0.5], symbol='z')
+        assert_equal(
+            self.as_latex(p),
+            (
+                r'$z \mapsto 1.0 + 2.0\,\left(2.0z\right) + 3.0\,'
+                r'\left(2.0z\right)^{2}$'
+            ),
+        )
+
+        # affine input
+        p = poly.Polynomial([1, 2, 3], domain=[-1, 0], symbol='z')
+        assert_equal(
+            self.as_latex(p),
+            (
+                r'$z \mapsto 1.0 + 2.0\,\left(1.0 + 2.0z\right) + 3.0\,'
+                r'\left(1.0 + 2.0z\right)^{2}$'
+            ),
+        )
+
+
+SWITCH_TO_EXP = (
+    '1.0 + (1.0e-01) x + (1.0e-02) x**2',
+    '1.2 + (1.2e-01) x + (1.2e-02) x**2',
+    '1.23 + 0.12 x + (1.23e-02) x**2 + (1.23e-03) x**3',
+    '1.235 + 0.123 x + (1.235e-02) x**2 + (1.235e-03) x**3',
+    '1.2346 + 0.1235 x + 0.0123 x**2 + (1.2346e-03) x**3 + (1.2346e-04) x**4',
+    '1.23457 + 0.12346 x + 0.01235 x**2 + (1.23457e-03) x**3 + '
+    '(1.23457e-04) x**4',
+    '1.234568 + 0.123457 x + 0.012346 x**2 + 0.001235 x**3 + '
+    '(1.234568e-04) x**4 + (1.234568e-05) x**5',
+    '1.2345679 + 0.1234568 x + 0.0123457 x**2 + 0.0012346 x**3 + '
+    '(1.2345679e-04) x**4 + (1.2345679e-05) x**5')
+
+class TestPrintOptions:
+    """
+    Test the output is properly configured via printoptions.
+    The exponential notation is enabled automatically when the values 
+    are too small or too large.
+    """
+
+    @pytest.fixture(scope='class', autouse=True)
+    def use_ascii(self):
+        poly.set_default_printstyle('ascii')
+
+    def test_str(self):
+        p = poly.Polynomial([1/2, 1/7, 1/7*10**8, 1/7*10**9])
+        assert_equal(str(p), '0.5 + 0.14285714 x + 14285714.28571429 x**2 '
+                             '+ (1.42857143e+08) x**3')
+
+        with printoptions(precision=3):
+            assert_equal(str(p), '0.5 + 0.143 x + 14285714.286 x**2 '
+                                 '+ (1.429e+08) x**3')
+
+    def test_latex(self):
+        p = poly.Polynomial([1/2, 1/7, 1/7*10**8, 1/7*10**9])
+        assert_equal(p._repr_latex_(),
+            r'$x \mapsto \text{0.5} + \text{0.14285714}\,x + '
+            r'\text{14285714.28571429}\,x^{2} + '
+            r'\text{(1.42857143e+08)}\,x^{3}$')
+        
+        with printoptions(precision=3):
+            assert_equal(p._repr_latex_(),
+                r'$x \mapsto \text{0.5} + \text{0.143}\,x + '
+                r'\text{14285714.286}\,x^{2} + \text{(1.429e+08)}\,x^{3}$')
+
+    def test_fixed(self):
+        p = poly.Polynomial([1/2])
+        assert_equal(str(p), '0.5')
+        
+        with printoptions(floatmode='fixed'):
+            assert_equal(str(p), '0.50000000')
+        
+        with printoptions(floatmode='fixed', precision=4):
+            assert_equal(str(p), '0.5000')
+
+    def test_switch_to_exp(self):
+        for i, s in enumerate(SWITCH_TO_EXP):
+            with printoptions(precision=i):
+                p = poly.Polynomial([1.23456789*10**-i 
+                                     for i in range(i//2+3)])
+                assert str(p).replace('\n', ' ') == s 
+    
+    def test_non_finite(self):
+        p = poly.Polynomial([nan, inf])
+        assert str(p) == 'nan + inf x'
+        assert p._repr_latex_() == r'$x \mapsto \text{nan} + \text{inf}\,x$'
+        with printoptions(nanstr='NAN', infstr='INF'):
+            assert str(p) == 'NAN + INF x'
+            assert p._repr_latex_() == \
+                r'$x \mapsto \text{NAN} + \text{INF}\,x$'
diff --git a/numpy/polynomial/tests/test_symbol.py b/numpy/polynomial/tests/test_symbol.py
new file mode 100644
index 000000000000..4ea6035ef7a7
--- /dev/null
+++ b/numpy/polynomial/tests/test_symbol.py
@@ -0,0 +1,216 @@
+"""
+Tests related to the ``symbol`` attribute of the ABCPolyBase class.
+"""
+
+import pytest
+import numpy.polynomial as poly
+from numpy.core import array
+from numpy.testing import assert_equal, assert_raises, assert_
+
+
+class TestInit:
+    """
+    Test polynomial creation with symbol kwarg.
+    """
+    c = [1, 2, 3]
+
+    def test_default_symbol(self):
+        p = poly.Polynomial(self.c)
+        assert_equal(p.symbol, 'x')
+
+    @pytest.mark.parametrize(('bad_input', 'exception'), (
+        ('', ValueError),
+        ('3', ValueError),
+        (None, TypeError),
+        (1, TypeError),
+    ))
+    def test_symbol_bad_input(self, bad_input, exception):
+        with pytest.raises(exception):
+            p = poly.Polynomial(self.c, symbol=bad_input)
+
+    @pytest.mark.parametrize('symbol', (
+        'x',
+        'x_1',
+        'A',
+        'xyz',
+        'β',
+    ))
+    def test_valid_symbols(self, symbol):
+        """
+        Values for symbol that should pass input validation.
+        """
+        p = poly.Polynomial(self.c, symbol=symbol)
+        assert_equal(p.symbol, symbol)
+
+    def test_property(self):
+        """
+        'symbol' attribute is read only.
+        """
+        p = poly.Polynomial(self.c, symbol='x')
+        with pytest.raises(AttributeError):
+            p.symbol = 'z'
+
+    def test_change_symbol(self):
+        p = poly.Polynomial(self.c, symbol='y')
+        # Create new polynomial from p with different symbol
+        pt = poly.Polynomial(p.coef, symbol='t')
+        assert_equal(pt.symbol, 't')
+
+
+class TestUnaryOperators:
+    p = poly.Polynomial([1, 2, 3], symbol='z')
+
+    def test_neg(self):
+        n = -self.p
+        assert_equal(n.symbol, 'z')
+
+    def test_scalarmul(self):
+        out = self.p * 10
+        assert_equal(out.symbol, 'z')
+
+    def test_rscalarmul(self):
+        out = 10 * self.p
+        assert_equal(out.symbol, 'z')
+
+    def test_pow(self):
+        out = self.p ** 3
+        assert_equal(out.symbol, 'z')
+
+
+@pytest.mark.parametrize(
+    'rhs',
+    (
+        poly.Polynomial([4, 5, 6], symbol='z'),
+        array([4, 5, 6]),
+    ),
+)
+class TestBinaryOperatorsSameSymbol:
+    """
+    Ensure symbol is preserved for numeric operations on polynomials with
+    the same symbol
+    """
+    p = poly.Polynomial([1, 2, 3], symbol='z')
+
+    def test_add(self, rhs):
+        out = self.p + rhs
+        assert_equal(out.symbol, 'z')
+
+    def test_sub(self, rhs):
+        out = self.p - rhs
+        assert_equal(out.symbol, 'z')
+
+    def test_polymul(self, rhs):
+        out = self.p * rhs
+        assert_equal(out.symbol, 'z')
+
+    def test_divmod(self, rhs):
+        for out in divmod(self.p, rhs):
+            assert_equal(out.symbol, 'z')
+
+    def test_radd(self, rhs):
+        out = rhs + self.p
+        assert_equal(out.symbol, 'z')
+
+    def test_rsub(self, rhs):
+        out = rhs - self.p
+        assert_equal(out.symbol, 'z')
+
+    def test_rmul(self, rhs):
+        out = rhs * self.p
+        assert_equal(out.symbol, 'z')
+
+    def test_rdivmod(self, rhs):
+        for out in divmod(rhs, self.p):
+            assert_equal(out.symbol, 'z')
+
+
+class TestBinaryOperatorsDifferentSymbol:
+    p = poly.Polynomial([1, 2, 3], symbol='x')
+    other = poly.Polynomial([4, 5, 6], symbol='y')
+    ops = (p.__add__, p.__sub__, p.__mul__, p.__floordiv__, p.__mod__)
+
+    @pytest.mark.parametrize('f', ops)
+    def test_binops_fails(self, f):
+        assert_raises(ValueError, f, self.other)
+
+
+class TestEquality:
+    p = poly.Polynomial([1, 2, 3], symbol='x')
+
+    def test_eq(self):
+        other = poly.Polynomial([1, 2, 3], symbol='x')
+        assert_(self.p == other)
+
+    def test_neq(self):
+        other = poly.Polynomial([1, 2, 3], symbol='y')
+        assert_(not self.p == other)
+
+
+class TestExtraMethods:
+    """
+    Test other methods for manipulating/creating polynomial objects.
+    """
+    p = poly.Polynomial([1, 2, 3, 0], symbol='z')
+
+    def test_copy(self):
+        other = self.p.copy()
+        assert_equal(other.symbol, 'z')
+
+    def test_trim(self):
+        other = self.p.trim()
+        assert_equal(other.symbol, 'z')
+
+    def test_truncate(self):
+        other = self.p.truncate(2)
+        assert_equal(other.symbol, 'z')
+
+    @pytest.mark.parametrize('kwarg', (
+        {'domain': [-10, 10]},
+        {'window': [-10, 10]},
+        {'kind': poly.Chebyshev},
+    ))
+    def test_convert(self, kwarg):
+        other = self.p.convert(**kwarg)
+        assert_equal(other.symbol, 'z')
+
+    def test_integ(self):
+        other = self.p.integ()
+        assert_equal(other.symbol, 'z')
+
+    def test_deriv(self):
+        other = self.p.deriv()
+        assert_equal(other.symbol, 'z')
+
+
+def test_composition():
+    p = poly.Polynomial([3, 2, 1], symbol="t")
+    q = poly.Polynomial([5, 1, 0, -1], symbol="λ_1")
+    r = p(q)
+    assert r.symbol == "λ_1"
+
+
+#
+# Class methods that result in new polynomial class instances
+#
+
+
+def test_fit():
+    x, y = (range(10),)*2
+    p = poly.Polynomial.fit(x, y, deg=1, symbol='z')
+    assert_equal(p.symbol, 'z')
+
+
+def test_froomroots():
+    roots = [-2, 2]
+    p = poly.Polynomial.fromroots(roots, symbol='z')
+    assert_equal(p.symbol, 'z')
+
+
+def test_identity():
+    p = poly.Polynomial.identity(domain=[-1, 1], window=[5, 20], symbol='z')
+    assert_equal(p.symbol, 'z')
+
+
+def test_basis():
+    p = poly.Polynomial.basis(3, symbol='z')
+    assert_equal(p.symbol, 'z')
diff --git a/numpy/random/__init__.pyi b/numpy/random/__init__.pyi
index bf6147697b2d..99ef6f3e2f2a 100644
--- a/numpy/random/__init__.pyi
+++ b/numpy/random/__init__.pyi
@@ -1,5 +1,3 @@
-from typing import List
-
 from numpy._pytesttester import PytestTester
 
 from numpy.random._generator import Generator as Generator
@@ -25,6 +23,7 @@ from numpy.random.mtrand import (
     f as f,
     gamma as gamma,
     geometric as geometric,
+    get_bit_generator as get_bit_generator,
     get_state as get_state,
     gumbel as gumbel,
     hypergeometric as hypergeometric,
@@ -52,6 +51,7 @@ from numpy.random.mtrand import (
     rayleigh as rayleigh,
     sample as sample,
     seed as seed,
+    set_bit_generator as set_bit_generator,
     set_state as set_state,
     shuffle as shuffle,
     standard_cauchy as standard_cauchy,
@@ -67,6 +67,6 @@ from numpy.random.mtrand import (
     zipf as zipf,
 )
 
-__all__: List[str]
-__path__: List[str]
+__all__: list[str]
+__path__: list[str]
 test: PytestTester
diff --git a/numpy/random/_common.pxd b/numpy/random/_common.pxd
index 9f2e8c3ca117..3eaf39ddf831 100644
--- a/numpy/random/_common.pxd
+++ b/numpy/random/_common.pxd
@@ -17,8 +17,8 @@ cdef enum ConstraintType:
     CONS_POSITIVE
     CONS_POSITIVE_NOT_NAN
     CONS_BOUNDED_0_1
-    CONS_BOUNDED_0_1_NOTNAN
     CONS_BOUNDED_GT_0_1
+    CONS_BOUNDED_LT_0_1
     CONS_GT_1
     CONS_GTE_1
     CONS_POISSON
@@ -45,7 +45,7 @@ ctypedef double (*random_double_1)(void *state, double a) nogil
 ctypedef double (*random_double_2)(void *state, double a, double b) nogil
 ctypedef double (*random_double_3)(void *state, double a, double b, double c) nogil
 
-ctypedef double (*random_float_fill)(bitgen_t *state, np.npy_intp count, float* out) nogil
+ctypedef void (*random_float_fill)(bitgen_t *state, np.npy_intp count, float* out) nogil
 ctypedef float (*random_float_0)(bitgen_t *state) nogil
 ctypedef float (*random_float_1)(bitgen_t *state, float a) nogil
 
diff --git a/numpy/random/_common.pyx b/numpy/random/_common.pyx
index ad43f281226a..7b6f693037fb 100644
--- a/numpy/random/_common.pyx
+++ b/numpy/random/_common.pyx
@@ -5,6 +5,7 @@ from cpython cimport PyFloat_AsDouble
 import sys
 import numpy as np
 cimport numpy as np
+cimport numpy.math as npmath
 
 from libc.stdint cimport uintptr_t
 
@@ -64,7 +65,7 @@ cdef object random_raw(bitgen_t *bitgen, object lock, object size, object output
 
     Notes
     -----
-    This method directly exposes the the raw underlying pseudo-random
+    This method directly exposes the raw underlying pseudo-random
     number generator. All values are returned as unsigned 64-bit
     values irrespective of the number of bits produced by the PRNG.
 
@@ -171,8 +172,23 @@ cdef object prepare_ctypes(bitgen_t *bitgen):
     return _ctypes
 
 cdef double kahan_sum(double *darr, np.npy_intp n):
+    """
+    Parameters
+    ----------
+    darr : reference to double array
+        Address of values to sum
+    n : intp
+        Length of d
+    
+    Returns
+    -------
+    float
+        The sum. 0.0 if n <= 0.
+    """
     cdef double c, y, t, sum
     cdef np.npy_intp i
+    if n <= 0:
+        return 0.0
     sum = darr[0]
     c = 0.0
     for i in range(1, n):
@@ -343,6 +359,24 @@ cdef object float_fill_from_double(void *func, bitgen_t *state, object size, obj
             out_array_data[i] = random_func(state)
     return out_array
 
+cdef int _check_array_cons_bounded_0_1(np.ndarray val, object name) except -1:
+    cdef double *val_data
+    cdef np.npy_intp i
+    cdef bint err = 0
+
+    if not np.PyArray_ISONESEGMENT(val) or np.PyArray_TYPE(val) != np.NPY_DOUBLE:
+        # slow path for non-contiguous arrays or any non-double dtypes
+        err = not np.all(np.greater_equal(val, 0)) or not np.all(np.less_equal(val, 1))
+    else:
+        val_data = np.PyArray_DATA(val)
+        for i in range(np.PyArray_SIZE(val)):
+            err = (not (val_data[i] >= 0)) or (not val_data[i] <= 1)
+            if err:
+                break
+    if err:
+        raise ValueError(f"{name} < 0, {name} > 1 or {name} contains NaNs")
+
+    return 0
 
 cdef int check_array_constraint(np.ndarray val, object name, constraint_type cons) except -1:
     if cons == CONS_NON_NEGATIVE:
@@ -354,12 +388,13 @@ cdef int check_array_constraint(np.ndarray val, object name, constraint_type con
         elif np.any(np.less_equal(val, 0)):
             raise ValueError(name + " <= 0")
     elif cons == CONS_BOUNDED_0_1:
-        if not np.all(np.greater_equal(val, 0)) or \
-                not np.all(np.less_equal(val, 1)):
-            raise ValueError("{0} < 0, {0} > 1 or {0} contains NaNs".format(name))
+        return _check_array_cons_bounded_0_1(val, name)
     elif cons == CONS_BOUNDED_GT_0_1:
         if not np.all(np.greater(val, 0)) or not np.all(np.less_equal(val, 1)):
             raise ValueError("{0} <= 0, {0} > 1 or {0} contains NaNs".format(name))
+    elif cons == CONS_BOUNDED_LT_0_1:
+        if not np.all(np.greater_equal(val, 0)) or not np.all(np.less(val, 1)):
+            raise ValueError("{0} < 0, {0} >= 1 or {0} contains NaNs".format(name))
     elif cons == CONS_GT_1:
         if not np.all(np.greater(val, 1)):
             raise ValueError("{0} <= 1 or {0} contains NaNs".format(name))
@@ -383,10 +418,10 @@ cdef int check_array_constraint(np.ndarray val, object name, constraint_type con
 cdef int check_constraint(double val, object name, constraint_type cons) except -1:
     cdef bint is_nan
     if cons == CONS_NON_NEGATIVE:
-        if not np.isnan(val) and np.signbit(val):
+        if not npmath.isnan(val) and npmath.signbit(val):
             raise ValueError(name + " < 0")
     elif cons == CONS_POSITIVE or cons == CONS_POSITIVE_NOT_NAN:
-        if cons == CONS_POSITIVE_NOT_NAN and np.isnan(val):
+        if cons == CONS_POSITIVE_NOT_NAN and npmath.isnan(val):
             raise ValueError(name + " must not be NaN")
         elif val <= 0:
             raise ValueError(name + " <= 0")
@@ -396,6 +431,9 @@ cdef int check_constraint(double val, object name, constraint_type cons) except
     elif cons == CONS_BOUNDED_GT_0_1:
         if not val >0 or not val <= 1:
             raise ValueError("{0} <= 0, {0} > 1 or {0} contains NaNs".format(name))
+    elif cons == CONS_BOUNDED_LT_0_1:
+        if not (val >= 0) or not (val < 1):
+            raise ValueError("{0} < 0, {0} >= 1 or {0} is NaN".format(name))
     elif cons == CONS_GT_1:
         if not (val > 1):
             raise ValueError("{0} <= 1 or {0} is NaN".format(name))
diff --git a/numpy/random/_examples/cython/extending.pyx b/numpy/random/_examples/cython/extending.pyx
index 3a7f81aa0466..30efd7447748 100644
--- a/numpy/random/_examples/cython/extending.pyx
+++ b/numpy/random/_examples/cython/extending.pyx
@@ -31,7 +31,7 @@ def uniform_mean(Py_ssize_t n):
     random_values = np.empty(n)
     # Best practice is to acquire the lock whenever generating random values.
     # This prevents other threads from modifying the state. Acquiring the lock
-    # is only necessary if if the GIL is also released, as in this example.
+    # is only necessary if the GIL is also released, as in this example.
     with x.lock, nogil:
         for i in range(n):
             random_values[i] = rng.next_double(rng.state)
diff --git a/numpy/random/_examples/cython/setup.py b/numpy/random/_examples/cython/setup.py
index 7e0dd3e057a6..e70a1fddca74 100644
--- a/numpy/random/_examples/cython/setup.py
+++ b/numpy/random/_examples/cython/setup.py
@@ -4,20 +4,24 @@
 
 Usage: python setup.py build_ext -i
 """
-from distutils.core import setup
 from os.path import dirname, join, abspath
 
+from setuptools import setup
+from setuptools.extension import Extension
+
 import numpy as np
 from Cython.Build import cythonize
-from numpy.distutils.misc_util import get_info
-from setuptools.extension import Extension
+
 
 path = dirname(__file__)
 src_dir = join(dirname(path), '..', 'src')
 defs = [('NPY_NO_DEPRECATED_API', 0)]
 inc_path = np.get_include()
-lib_path = [abspath(join(np.get_include(), '..', '..', 'random', 'lib'))]
-lib_path += get_info('npymath')['library_dirs']
+# Add paths for npyrandom and npymath libraries:
+lib_path = [
+    abspath(join(np.get_include(), '..', '..', 'random', 'lib')),
+    abspath(join(np.get_include(), '..', 'lib'))
+]
 
 extending = Extension("extending",
                       sources=[join('.', 'extending.pyx')],
diff --git a/numpy/random/_generator.pyi b/numpy/random/_generator.pyi
index c574bef9a5cb..f0d814fef798 100644
--- a/numpy/random/_generator.pyi
+++ b/numpy/random/_generator.pyi
@@ -1,4 +1,5 @@
-from typing import Any, Callable, Dict, Optional, Tuple, Type, Union, overload, TypeVar, Literal
+from collections.abc import Callable
+from typing import Any, Union, overload, TypeVar, Literal
 
 from numpy import (
     bool_,
@@ -18,7 +19,7 @@ from numpy import (
     uint64,
 )
 from numpy.random import BitGenerator, SeedSequence
-from numpy.typing import (
+from numpy._typing import (
     ArrayLike,
     _ArrayLikeFloat_co,
     _ArrayLikeInt_co,
@@ -48,7 +49,7 @@ _ArrayType = TypeVar("_ArrayType", bound=ndarray[Any, Any])
 _DTypeLikeFloat32 = Union[
     dtype[float32],
     _SupportsDType[dtype[float32]],
-    Type[float32],
+    type[float32],
     _Float32Codes,
     _SingleCodes,
 ]
@@ -56,8 +57,8 @@ _DTypeLikeFloat32 = Union[
 _DTypeLikeFloat64 = Union[
     dtype[float64],
     _SupportsDType[dtype[float64]],
-    Type[float],
-    Type[float64],
+    type[float],
+    type[float64],
     _Float64Codes,
     _DoubleCodes,
 ]
@@ -66,9 +67,9 @@ class Generator:
     def __init__(self, bit_generator: BitGenerator) -> None: ...
     def __repr__(self) -> str: ...
     def __str__(self) -> str: ...
-    def __getstate__(self) -> Dict[str, Any]: ...
-    def __setstate__(self, state: Dict[str, Any]) -> None: ...
-    def __reduce__(self) -> Tuple[Callable[[str], Generator], Tuple[str], Dict[str, Any]]: ...
+    def __getstate__(self) -> dict[str, Any]: ...
+    def __setstate__(self, state: dict[str, Any]) -> None: ...
+    def __reduce__(self) -> tuple[Callable[[str], Generator], tuple[str], dict[str, Any]]: ...
     @property
     def bit_generator(self) -> BitGenerator: ...
     def bytes(self, length: int) -> bytes: ...
@@ -76,7 +77,7 @@ class Generator:
     def standard_normal(  # type: ignore[misc]
         self,
         size: None = ...,
-        dtype: Union[_DTypeLikeFloat32, _DTypeLikeFloat64] = ...,
+        dtype: _DTypeLikeFloat32 | _DTypeLikeFloat64 = ...,
         out: None = ...,
     ) -> float: ...
     @overload
@@ -95,14 +96,14 @@ class Generator:
         self,
         size: _ShapeLike = ...,
         dtype: _DTypeLikeFloat32 = ...,
-        out: Optional[ndarray[Any, dtype[float32]]] = ...,
+        out: None | ndarray[Any, dtype[float32]] = ...,
     ) -> ndarray[Any, dtype[float32]]: ...
     @overload
     def standard_normal(  # type: ignore[misc]
         self,
         size: _ShapeLike = ...,
         dtype: _DTypeLikeFloat64 = ...,
-        out: Optional[ndarray[Any, dtype[float64]]] = ...,
+        out: None | ndarray[Any, dtype[float64]] = ...,
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def permutation(self, x: int, axis: int = ...) -> ndarray[Any, dtype[int64]]: ...
@@ -112,7 +113,7 @@ class Generator:
     def standard_exponential(  # type: ignore[misc]
         self,
         size: None = ...,
-        dtype: Union[_DTypeLikeFloat32, _DTypeLikeFloat64] = ...,
+        dtype: _DTypeLikeFloat32 | _DTypeLikeFloat64 = ...,
         method: Literal["zig", "inv"] = ...,
         out: None = ...,
     ) -> float: ...
@@ -133,7 +134,7 @@ class Generator:
         size: _ShapeLike = ...,
         *,
         method: Literal["zig", "inv"] = ...,
-        out: Optional[ndarray[Any, dtype[float64]]] = ...,
+        out: None | ndarray[Any, dtype[float64]] = ...,
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def standard_exponential(
@@ -141,7 +142,7 @@ class Generator:
         size: _ShapeLike = ...,
         dtype: _DTypeLikeFloat32 = ...,
         method: Literal["zig", "inv"] = ...,
-        out: Optional[ndarray[Any, dtype[float32]]] = ...,
+        out: None | ndarray[Any, dtype[float32]] = ...,
     ) -> ndarray[Any, dtype[float32]]: ...
     @overload
     def standard_exponential(
@@ -149,13 +150,13 @@ class Generator:
         size: _ShapeLike = ...,
         dtype: _DTypeLikeFloat64 = ...,
         method: Literal["zig", "inv"] = ...,
-        out: Optional[ndarray[Any, dtype[float64]]] = ...,
+        out: None | ndarray[Any, dtype[float64]] = ...,
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def random(  # type: ignore[misc]
         self,
         size: None = ...,
-        dtype: Union[_DTypeLikeFloat32, _DTypeLikeFloat64] = ...,
+        dtype: _DTypeLikeFloat32 | _DTypeLikeFloat64 = ...,
         out: None = ...,
     ) -> float: ...
     @overload
@@ -169,45 +170,45 @@ class Generator:
         self,
         size: _ShapeLike = ...,
         *,
-        out: Optional[ndarray[Any, dtype[float64]]] = ...,
+        out: None | ndarray[Any, dtype[float64]] = ...,
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def random(
         self,
         size: _ShapeLike = ...,
         dtype: _DTypeLikeFloat32 = ...,
-        out: Optional[ndarray[Any, dtype[float32]]] = ...,
+        out: None | ndarray[Any, dtype[float32]] = ...,
     ) -> ndarray[Any, dtype[float32]]: ...
     @overload
     def random(
         self,
         size: _ShapeLike = ...,
         dtype: _DTypeLikeFloat64 = ...,
-        out: Optional[ndarray[Any, dtype[float64]]] = ...,
+        out: None | ndarray[Any, dtype[float64]] = ...,
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def beta(self, a: float, b: float, size: None = ...) -> float: ...  # type: ignore[misc]
     @overload
     def beta(
-        self, a: _ArrayLikeFloat_co, b: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+        self, a: _ArrayLikeFloat_co, b: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def exponential(self, scale: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
     @overload
     def exponential(
-        self, scale: _ArrayLikeFloat_co = ..., size: Optional[_ShapeLike] = ...
+        self, scale: _ArrayLikeFloat_co = ..., size: None | _ShapeLike = ...
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def integers(  # type: ignore[misc]
         self,
         low: int,
-        high: Optional[int] = ...,
+        high: None | int = ...,
     ) -> int: ...
     @overload
     def integers(  # type: ignore[misc]
         self,
         low: int,
-        high: Optional[int] = ...,
+        high: None | int = ...,
         size: None = ...,
         dtype: _DTypeLikeBool = ...,
         endpoint: bool = ...,
@@ -216,24 +217,24 @@ class Generator:
     def integers(  # type: ignore[misc]
         self,
         low: int,
-        high: Optional[int] = ...,
+        high: None | int = ...,
         size: None = ...,
-        dtype: Union[_DTypeLikeInt, _DTypeLikeUInt] = ...,
+        dtype: _DTypeLikeInt | _DTypeLikeUInt = ...,
         endpoint: bool = ...,
     ) -> int: ...
     @overload
     def integers(  # type: ignore[misc]
         self,
         low: _ArrayLikeInt_co,
-        high: Optional[_ArrayLikeInt_co] = ...,
-        size: Optional[_ShapeLike] = ...,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
     ) -> ndarray[Any, dtype[int64]]: ...
     @overload
     def integers(  # type: ignore[misc]
         self,
         low: _ArrayLikeInt_co,
-        high: Optional[_ArrayLikeInt_co] = ...,
-        size: Optional[_ShapeLike] = ...,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
         dtype: _DTypeLikeBool = ...,
         endpoint: bool = ...,
     ) -> ndarray[Any, dtype[bool_]]: ...
@@ -241,110 +242,100 @@ class Generator:
     def integers(  # type: ignore[misc]
         self,
         low: _ArrayLikeInt_co,
-        high: Optional[_ArrayLikeInt_co] = ...,
-        size: Optional[_ShapeLike] = ...,
-        dtype: Union[dtype[int8], Type[int8], _Int8Codes, _SupportsDType[dtype[int8]]] = ...,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+        dtype: dtype[int8] | type[int8] | _Int8Codes | _SupportsDType[dtype[int8]] = ...,
         endpoint: bool = ...,
     ) -> ndarray[Any, dtype[int8]]: ...
     @overload
     def integers(  # type: ignore[misc]
         self,
         low: _ArrayLikeInt_co,
-        high: Optional[_ArrayLikeInt_co] = ...,
-        size: Optional[_ShapeLike] = ...,
-        dtype: Union[dtype[int16], Type[int16], _Int16Codes, _SupportsDType[dtype[int16]]] = ...,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+        dtype: dtype[int16] | type[int16] | _Int16Codes | _SupportsDType[dtype[int16]] = ...,
         endpoint: bool = ...,
     ) -> ndarray[Any, dtype[int16]]: ...
     @overload
     def integers(  # type: ignore[misc]
         self,
         low: _ArrayLikeInt_co,
-        high: Optional[_ArrayLikeInt_co] = ...,
-        size: Optional[_ShapeLike] = ...,
-        dtype: Union[dtype[int32], Type[int32], _Int32Codes, _SupportsDType[dtype[int32]]] = ...,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+        dtype: dtype[int32] | type[int32] | _Int32Codes | _SupportsDType[dtype[int32]] = ...,
         endpoint: bool = ...,
-    ) -> ndarray[Any, dtype[Union[int32]]]: ...
+    ) -> ndarray[Any, dtype[int32]]: ...
     @overload
     def integers(  # type: ignore[misc]
         self,
         low: _ArrayLikeInt_co,
-        high: Optional[_ArrayLikeInt_co] = ...,
-        size: Optional[_ShapeLike] = ...,
-        dtype: Optional[
-            Union[dtype[int64], Type[int64], _Int64Codes, _SupportsDType[dtype[int64]]]
-        ] = ...,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+        dtype: None | dtype[int64] | type[int64] | _Int64Codes | _SupportsDType[dtype[int64]] = ...,
         endpoint: bool = ...,
     ) -> ndarray[Any, dtype[int64]]: ...
     @overload
     def integers(  # type: ignore[misc]
         self,
         low: _ArrayLikeInt_co,
-        high: Optional[_ArrayLikeInt_co] = ...,
-        size: Optional[_ShapeLike] = ...,
-        dtype: Union[dtype[uint8], Type[uint8], _UInt8Codes, _SupportsDType[dtype[uint8]]] = ...,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+        dtype: dtype[uint8] | type[uint8] | _UInt8Codes | _SupportsDType[dtype[uint8]] = ...,
         endpoint: bool = ...,
     ) -> ndarray[Any, dtype[uint8]]: ...
     @overload
     def integers(  # type: ignore[misc]
         self,
         low: _ArrayLikeInt_co,
-        high: Optional[_ArrayLikeInt_co] = ...,
-        size: Optional[_ShapeLike] = ...,
-        dtype: Union[
-            dtype[uint16], Type[uint16], _UInt16Codes, _SupportsDType[dtype[uint16]]
-        ] = ...,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+        dtype: dtype[uint16] | type[uint16] | _UInt16Codes | _SupportsDType[dtype[uint16]] = ...,
         endpoint: bool = ...,
-    ) -> ndarray[Any, dtype[Union[uint16]]]: ...
+    ) -> ndarray[Any, dtype[uint16]]: ...
     @overload
     def integers(  # type: ignore[misc]
         self,
         low: _ArrayLikeInt_co,
-        high: Optional[_ArrayLikeInt_co] = ...,
-        size: Optional[_ShapeLike] = ...,
-        dtype: Union[
-            dtype[uint32], Type[uint32], _UInt32Codes, _SupportsDType[dtype[uint32]]
-        ] = ...,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+        dtype: dtype[uint32] | type[uint32] | _UInt32Codes | _SupportsDType[dtype[uint32]] = ...,
         endpoint: bool = ...,
     ) -> ndarray[Any, dtype[uint32]]: ...
     @overload
     def integers(  # type: ignore[misc]
         self,
         low: _ArrayLikeInt_co,
-        high: Optional[_ArrayLikeInt_co] = ...,
-        size: Optional[_ShapeLike] = ...,
-        dtype: Union[
-            dtype[uint64], Type[uint64], _UInt64Codes, _SupportsDType[dtype[uint64]]
-        ] = ...,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+        dtype: dtype[uint64] | type[uint64] | _UInt64Codes | _SupportsDType[dtype[uint64]] = ...,
         endpoint: bool = ...,
     ) -> ndarray[Any, dtype[uint64]]: ...
     @overload
     def integers(  # type: ignore[misc]
         self,
         low: _ArrayLikeInt_co,
-        high: Optional[_ArrayLikeInt_co] = ...,
-        size: Optional[_ShapeLike] = ...,
-        dtype: Union[
-            dtype[int_], Type[int], Type[int_], _IntCodes, _SupportsDType[dtype[int_]]
-        ] = ...,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+        dtype: dtype[int_] | type[int] | type[int_] | _IntCodes | _SupportsDType[dtype[int_]] = ...,
         endpoint: bool = ...,
     ) -> ndarray[Any, dtype[int_]]: ...
     @overload
     def integers(  # type: ignore[misc]
         self,
         low: _ArrayLikeInt_co,
-        high: Optional[_ArrayLikeInt_co] = ...,
-        size: Optional[_ShapeLike] = ...,
-        dtype: Union[dtype[uint], Type[uint], _UIntCodes, _SupportsDType[dtype[uint]]] = ...,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+        dtype: dtype[uint] | type[uint] | _UIntCodes | _SupportsDType[dtype[uint]] = ...,
         endpoint: bool = ...,
     ) -> ndarray[Any, dtype[uint]]: ...
-    # TODO: Use a TypeVar _T here to get away from Any output?  Should be int->ndarray[Any,dtype[int64]], ArrayLike[_T] -> Union[_T, ndarray[Any,Any]]
+    # TODO: Use a TypeVar _T here to get away from Any output?  Should be int->ndarray[Any,dtype[int64]], ArrayLike[_T] -> _T | ndarray[Any,Any]
     @overload
     def choice(
         self,
         a: int,
         size: None = ...,
         replace: bool = ...,
-        p: Optional[_ArrayLikeFloat_co] = ...,
+        p: None | _ArrayLikeFloat_co = ...,
         axis: int = ...,
         shuffle: bool = ...,
     ) -> int: ...
@@ -354,7 +345,7 @@ class Generator:
         a: int,
         size: _ShapeLike = ...,
         replace: bool = ...,
-        p: Optional[_ArrayLikeFloat_co] = ...,
+        p: None | _ArrayLikeFloat_co = ...,
         axis: int = ...,
         shuffle: bool = ...,
     ) -> ndarray[Any, dtype[int64]]: ...
@@ -364,7 +355,7 @@ class Generator:
         a: ArrayLike,
         size: None = ...,
         replace: bool = ...,
-        p: Optional[_ArrayLikeFloat_co] = ...,
+        p: None | _ArrayLikeFloat_co = ...,
         axis: int = ...,
         shuffle: bool = ...,
     ) -> Any: ...
@@ -374,7 +365,7 @@ class Generator:
         a: ArrayLike,
         size: _ShapeLike = ...,
         replace: bool = ...,
-        p: Optional[_ArrayLikeFloat_co] = ...,
+        p: None | _ArrayLikeFloat_co = ...,
         axis: int = ...,
         shuffle: bool = ...,
     ) -> ndarray[Any, Any]: ...
@@ -385,7 +376,7 @@ class Generator:
         self,
         low: _ArrayLikeFloat_co = ...,
         high: _ArrayLikeFloat_co = ...,
-        size: Optional[_ShapeLike] = ...,
+        size: None | _ShapeLike = ...,
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def normal(self, loc: float = ..., scale: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
@@ -394,21 +385,21 @@ class Generator:
         self,
         loc: _ArrayLikeFloat_co = ...,
         scale: _ArrayLikeFloat_co = ...,
-        size: Optional[_ShapeLike] = ...,
+        size: None | _ShapeLike = ...,
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def standard_gamma(  # type: ignore[misc]
         self,
         shape: float,
         size: None = ...,
-        dtype: Union[_DTypeLikeFloat32, _DTypeLikeFloat64] = ...,
+        dtype: _DTypeLikeFloat32 | _DTypeLikeFloat64 = ...,
         out: None = ...,
     ) -> float: ...
     @overload
     def standard_gamma(
         self,
         shape: _ArrayLikeFloat_co,
-        size: Optional[_ShapeLike] = ...,
+        size: None | _ShapeLike = ...,
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def standard_gamma(
@@ -421,17 +412,17 @@ class Generator:
     def standard_gamma(
         self,
         shape: _ArrayLikeFloat_co,
-        size: Optional[_ShapeLike] = ...,
+        size: None | _ShapeLike = ...,
         dtype: _DTypeLikeFloat32 = ...,
-        out: Optional[ndarray[Any, dtype[float32]]] = ...,
+        out: None | ndarray[Any, dtype[float32]] = ...,
     ) -> ndarray[Any, dtype[float32]]: ...
     @overload
     def standard_gamma(
         self,
         shape: _ArrayLikeFloat_co,
-        size: Optional[_ShapeLike] = ...,
+        size: None | _ShapeLike = ...,
         dtype: _DTypeLikeFloat64 = ...,
-        out: Optional[ndarray[Any, dtype[float64]]] = ...,
+        out: None | ndarray[Any, dtype[float64]] = ...,
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def gamma(self, shape: float, scale: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
@@ -440,13 +431,13 @@ class Generator:
         self,
         shape: _ArrayLikeFloat_co,
         scale: _ArrayLikeFloat_co = ...,
-        size: Optional[_ShapeLike] = ...,
+        size: None | _ShapeLike = ...,
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def f(self, dfnum: float, dfden: float, size: None = ...) -> float: ...  # type: ignore[misc]
     @overload
     def f(
-        self, dfnum: _ArrayLikeFloat_co, dfden: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+        self, dfnum: _ArrayLikeFloat_co, dfden: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def noncentral_f(self, dfnum: float, dfden: float, nonc: float, size: None = ...) -> float: ...  # type: ignore[misc]
@@ -456,19 +447,19 @@ class Generator:
         dfnum: _ArrayLikeFloat_co,
         dfden: _ArrayLikeFloat_co,
         nonc: _ArrayLikeFloat_co,
-        size: Optional[_ShapeLike] = ...,
+        size: None | _ShapeLike = ...,
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def chisquare(self, df: float, size: None = ...) -> float: ...  # type: ignore[misc]
     @overload
     def chisquare(
-        self, df: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+        self, df: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def noncentral_chisquare(self, df: float, nonc: float, size: None = ...) -> float: ...  # type: ignore[misc]
     @overload
     def noncentral_chisquare(
-        self, df: _ArrayLikeFloat_co, nonc: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+        self, df: _ArrayLikeFloat_co, nonc: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def standard_t(self, df: float, size: None = ...) -> float: ...  # type: ignore[misc]
@@ -484,25 +475,25 @@ class Generator:
     def vonmises(self, mu: float, kappa: float, size: None = ...) -> float: ...  # type: ignore[misc]
     @overload
     def vonmises(
-        self, mu: _ArrayLikeFloat_co, kappa: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+        self, mu: _ArrayLikeFloat_co, kappa: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def pareto(self, a: float, size: None = ...) -> float: ...  # type: ignore[misc]
     @overload
     def pareto(
-        self, a: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+        self, a: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def weibull(self, a: float, size: None = ...) -> float: ...  # type: ignore[misc]
     @overload
     def weibull(
-        self, a: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+        self, a: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def power(self, a: float, size: None = ...) -> float: ...  # type: ignore[misc]
     @overload
     def power(
-        self, a: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+        self, a: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def standard_cauchy(self, size: None = ...) -> float: ...  # type: ignore[misc]
@@ -515,7 +506,7 @@ class Generator:
         self,
         loc: _ArrayLikeFloat_co = ...,
         scale: _ArrayLikeFloat_co = ...,
-        size: Optional[_ShapeLike] = ...,
+        size: None | _ShapeLike = ...,
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def gumbel(self, loc: float = ..., scale: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
@@ -524,7 +515,7 @@ class Generator:
         self,
         loc: _ArrayLikeFloat_co = ...,
         scale: _ArrayLikeFloat_co = ...,
-        size: Optional[_ShapeLike] = ...,
+        size: None | _ShapeLike = ...,
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def logistic(self, loc: float = ..., scale: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
@@ -533,7 +524,7 @@ class Generator:
         self,
         loc: _ArrayLikeFloat_co = ...,
         scale: _ArrayLikeFloat_co = ...,
-        size: Optional[_ShapeLike] = ...,
+        size: None | _ShapeLike = ...,
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def lognormal(self, mean: float = ..., sigma: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
@@ -542,19 +533,19 @@ class Generator:
         self,
         mean: _ArrayLikeFloat_co = ...,
         sigma: _ArrayLikeFloat_co = ...,
-        size: Optional[_ShapeLike] = ...,
+        size: None | _ShapeLike = ...,
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def rayleigh(self, scale: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
     @overload
     def rayleigh(
-        self, scale: _ArrayLikeFloat_co = ..., size: Optional[_ShapeLike] = ...
+        self, scale: _ArrayLikeFloat_co = ..., size: None | _ShapeLike = ...
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def wald(self, mean: float, scale: float, size: None = ...) -> float: ...  # type: ignore[misc]
     @overload
     def wald(
-        self, mean: _ArrayLikeFloat_co, scale: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+        self, mean: _ArrayLikeFloat_co, scale: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def triangular(self, left: float, mode: float, right: float, size: None = ...) -> float: ...  # type: ignore[misc]
@@ -564,37 +555,37 @@ class Generator:
         left: _ArrayLikeFloat_co,
         mode: _ArrayLikeFloat_co,
         right: _ArrayLikeFloat_co,
-        size: Optional[_ShapeLike] = ...,
+        size: None | _ShapeLike = ...,
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def binomial(self, n: int, p: float, size: None = ...) -> int: ...  # type: ignore[misc]
     @overload
     def binomial(
-        self, n: _ArrayLikeInt_co, p: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+        self, n: _ArrayLikeInt_co, p: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
     ) -> ndarray[Any, dtype[int64]]: ...
     @overload
     def negative_binomial(self, n: float, p: float, size: None = ...) -> int: ...  # type: ignore[misc]
     @overload
     def negative_binomial(
-        self, n: _ArrayLikeFloat_co, p: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+        self, n: _ArrayLikeFloat_co, p: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
     ) -> ndarray[Any, dtype[int64]]: ...
     @overload
     def poisson(self, lam: float = ..., size: None = ...) -> int: ...  # type: ignore[misc]
     @overload
     def poisson(
-        self, lam: _ArrayLikeFloat_co = ..., size: Optional[_ShapeLike] = ...
+        self, lam: _ArrayLikeFloat_co = ..., size: None | _ShapeLike = ...
     ) -> ndarray[Any, dtype[int64]]: ...
     @overload
     def zipf(self, a: float, size: None = ...) -> int: ...  # type: ignore[misc]
     @overload
     def zipf(
-        self, a: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+        self, a: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
     ) -> ndarray[Any, dtype[int64]]: ...
     @overload
     def geometric(self, p: float, size: None = ...) -> int: ...  # type: ignore[misc]
     @overload
     def geometric(
-        self, p: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+        self, p: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
     ) -> ndarray[Any, dtype[int64]]: ...
     @overload
     def hypergeometric(self, ngood: int, nbad: int, nsample: int, size: None = ...) -> int: ...  # type: ignore[misc]
@@ -604,19 +595,19 @@ class Generator:
         ngood: _ArrayLikeInt_co,
         nbad: _ArrayLikeInt_co,
         nsample: _ArrayLikeInt_co,
-        size: Optional[_ShapeLike] = ...,
+        size: None | _ShapeLike = ...,
     ) -> ndarray[Any, dtype[int64]]: ...
     @overload
     def logseries(self, p: float, size: None = ...) -> int: ...  # type: ignore[misc]
     @overload
     def logseries(
-        self, p: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+        self, p: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
     ) -> ndarray[Any, dtype[int64]]: ...
     def multivariate_normal(
         self,
         mean: _ArrayLikeFloat_co,
         cov: _ArrayLikeFloat_co,
-        size: Optional[_ShapeLike] = ...,
+        size: None | _ShapeLike = ...,
         check_valid: Literal["warn", "raise", "ignore"] = ...,
         tol: float = ...,
         *,
@@ -625,23 +616,23 @@ class Generator:
     def multinomial(
         self, n: _ArrayLikeInt_co,
             pvals: _ArrayLikeFloat_co,
-            size: Optional[_ShapeLike] = ...
+            size: None | _ShapeLike = ...
     ) -> ndarray[Any, dtype[int64]]: ...
     def multivariate_hypergeometric(
         self,
         colors: _ArrayLikeInt_co,
         nsample: int,
-        size: Optional[_ShapeLike] = ...,
+        size: None | _ShapeLike = ...,
         method: Literal["marginals", "count"] = ...,
     ) -> ndarray[Any, dtype[int64]]: ...
     def dirichlet(
-        self, alpha: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+        self, alpha: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
     ) -> ndarray[Any, dtype[float64]]: ...
     def permuted(
-        self, x: ArrayLike, *, axis: Optional[int] = ..., out: Optional[ndarray[Any, Any]] = ...
+        self, x: ArrayLike, *, axis: None | int = ..., out: None | ndarray[Any, Any] = ...
     ) -> ndarray[Any, Any]: ...
     def shuffle(self, x: ArrayLike, axis: int = ...) -> None: ...
 
 def default_rng(
-    seed: Union[None, _ArrayLikeInt_co, SeedSequence, BitGenerator, Generator] = ...
+    seed: None | _ArrayLikeInt_co | SeedSequence | BitGenerator | Generator = ...
 ) -> Generator: ...
diff --git a/numpy/random/_generator.pyx b/numpy/random/_generator.pyx
index 391987a1ecd3..266a0538799c 100644
--- a/numpy/random/_generator.pyx
+++ b/numpy/random/_generator.pyx
@@ -15,6 +15,7 @@ from numpy.core.multiarray import normalize_axis_index
 
 from .c_distributions cimport *
 from libc cimport string
+from libc.math cimport sqrt
 from libc.stdint cimport (uint8_t, uint16_t, uint32_t, uint64_t,
                           int32_t, int64_t, INT64_MAX, SIZE_MAX)
 from ._bounded_integers cimport (_rand_bool, _rand_int32, _rand_int64,
@@ -24,7 +25,7 @@ from ._pcg64 import PCG64
 from numpy.random cimport bitgen_t
 from ._common cimport (POISSON_LAM_MAX, CONS_POSITIVE, CONS_NONE,
             CONS_NON_NEGATIVE, CONS_BOUNDED_0_1, CONS_BOUNDED_GT_0_1,
-            CONS_GT_1, CONS_POSITIVE_NOT_NAN, CONS_POISSON,
+            CONS_BOUNDED_LT_0_1, CONS_GT_1, CONS_POSITIVE_NOT_NAN, CONS_POISSON,
             double_fill, cont, kahan_sum, cont_broadcast_3, float_fill, cont_f,
             check_array_constraint, check_constraint, disc, discrete_broadcast_iii,
             validate_output_shape
@@ -32,6 +33,8 @@ from ._common cimport (POISSON_LAM_MAX, CONS_POSITIVE, CONS_NONE,
 
 cdef extern from "numpy/arrayobject.h":
     int PyArray_ResolveWritebackIfCopy(np.ndarray)
+    int PyArray_FailUnlessWriteable(np.PyArrayObject *obj,
+                                    const char *name) except -1
     object PyArray_FromArray(np.PyArrayObject *, np.PyArray_Descr *, int)
 
     enum:
@@ -217,8 +220,11 @@ cdef class Generator:
         self.bit_generator.state = state
 
     def __reduce__(self):
+        ctor, name_tpl, state = self._bit_generator.__reduce__()
+
         from ._pickle import __generator_ctor
-        return __generator_ctor, (self.bit_generator.state['bit_generator'],), self.bit_generator.state
+        # Requirements of __generator_ctor are (name, ctor)
+        return __generator_ctor, (name_tpl[0], ctor), state
 
     @property
     def bit_generator(self):
@@ -239,10 +245,10 @@ cdef class Generator:
         Return random floats in the half-open interval [0.0, 1.0).
 
         Results are from the "continuous uniform" distribution over the
-        stated interval.  To sample :math:`Unif[a, b), b > a` multiply
-        the output of `random` by `(b-a)` and add `a`::
+        stated interval.  To sample :math:`Unif[a, b), b > a` use `uniform`
+        or multiply the output of `random` by ``(b - a)`` and add ``a``::
 
-          (b - a) * random() + a
+            (b - a) * random() + a
 
         Parameters
         ----------
@@ -264,6 +270,10 @@ cdef class Generator:
             Array of random floats of shape `size` (unless ``size=None``, in which
             case a single float is returned).
 
+        See Also
+        --------
+        uniform : Draw samples from the parameterized uniform distribution.
+
         Examples
         --------
         >>> rng = np.random.default_rng()
@@ -998,7 +1008,8 @@ cdef class Generator:
 
         Notes
         -----
-        For random samples from :math:`N(\\mu, \\sigma^2)`, use one of::
+        For random samples from the normal distribution with mean ``mu`` and
+        standard deviation ``sigma``, use one of::
 
             mu + sigma * rng.standard_normal(size=...)
             rng.normal(mu, sigma, size=...)
@@ -1019,7 +1030,8 @@ cdef class Generator:
         >>> s.shape
         (3, 4, 2)
 
-        Two-by-four array of samples from :math:`N(3, 6.25)`:
+        Two-by-four array of samples from the normal distribution with
+        mean 3 and standard deviation 2.5:
 
         >>> 3 + 2.5 * rng.standard_normal(size=(2, 4))
         array([[-4.49401501,  4.00950034, -1.81814867,  7.29718677],   # random
@@ -1123,7 +1135,8 @@ cdef class Generator:
         ...          linewidth=2, color='r')
         >>> plt.show()
 
-        Two-by-four array of samples from N(3, 6.25):
+        Two-by-four array of samples from the normal distribution with
+        mean 3 and standard deviation 2.5:
 
         >>> np.random.default_rng().normal(3, 2.5, size=(2, 4))
         array([[-4.49401501,  4.00950034, -1.81814867,  7.29718677],   # random
@@ -2987,7 +3000,7 @@ cdef class Generator:
         probability of success, :math:`N+n` is the number of trials, and
         :math:`\\Gamma` is the gamma function. When :math:`n` is an integer,
         :math:`\\frac{\\Gamma(N+n)}{N!\\Gamma(n)} = \\binom{N+n-1}{N}`, which is
-        the more common form of this term in the the pmf. The negative
+        the more common form of this term in the pmf. The negative
         binomial distribution gives the probability of N failures given n
         successes, with a success on the last trial.
 
@@ -2995,6 +3008,22 @@ cdef class Generator:
         then the probability distribution of the number of non-"1"s that
         appear before the third "1" is a negative binomial distribution.
 
+        Because this method internally calls ``Generator.poisson`` with an
+        intermediate random value, a ValueError is raised when the choice of 
+        :math:`n` and :math:`p` would result in the mean + 10 sigma of the sampled
+        intermediate distribution exceeding the max acceptable value of the 
+        ``Generator.poisson`` method. This happens when :math:`p` is too low 
+        (a lot of failures happen for every success) and :math:`n` is too big (
+        a lot of successes are allowed).
+        Therefore, the :math:`n` and :math:`p` values must satisfy the constraint:
+
+        .. math:: n\\frac{1-p}{p}+10n\\sqrt{n}\\frac{1-p}{p}<2^{63}-1-10\\sqrt{2^{63}-1},
+
+        Where the left side of the equation is the derived mean + 10 sigma of
+        a sample from the gamma distribution internally used as the :math:`lam`
+        parameter of a poisson sample, and the right side of the equation is
+        the constraint for maximum value of :math:`lam` in ``Generator.poisson``.
+
         References
         ----------
         .. [1] Weisstein, Eric W. "Negative Binomial Distribution." From
@@ -3019,9 +3048,41 @@ cdef class Generator:
         ...    print(i, "wells drilled, probability of one success =", probability)
 
         """
+
+        cdef bint is_scalar = True
+        cdef double *_dn
+        cdef double *_dp
+        cdef double _dmax_lam
+
+        p_arr = np.PyArray_FROM_OTF(p, np.NPY_DOUBLE, np.NPY_ALIGNED)
+        is_scalar = is_scalar and np.PyArray_NDIM(p_arr) == 0
+        n_arr = np.PyArray_FROM_OTF(n, np.NPY_DOUBLE, np.NPY_ALIGNED)
+        is_scalar = is_scalar and np.PyArray_NDIM(n_arr) == 0
+
+        if not is_scalar:
+            check_array_constraint(n_arr, 'n', CONS_POSITIVE_NOT_NAN)
+            check_array_constraint(p_arr, 'p', CONS_BOUNDED_GT_0_1)
+            # Check that the choice of negative_binomial parameters won't result in a
+            # call to the poisson distribution function with a value of lam too large.
+            max_lam_arr = (1 - p_arr) / p_arr * (n_arr + 10 * np.sqrt(n_arr))
+            if np.any(np.greater(max_lam_arr, POISSON_LAM_MAX)):
+                raise ValueError("n too large or p too small, see Generator.negative_binomial Notes")
+
+        else:
+            _dn = np.PyArray_DATA(n_arr)
+            _dp = np.PyArray_DATA(p_arr)
+
+            check_constraint(_dn[0], 'n', CONS_POSITIVE_NOT_NAN)
+            check_constraint(_dp[0], 'p', CONS_BOUNDED_GT_0_1)
+            # Check that the choice of negative_binomial parameters won't result in a
+            # call to the poisson distribution function with a value of lam too large.
+            _dmax_lam = (1 - _dp[0]) / _dp[0] * (_dn[0] + 10 * sqrt(_dn[0]))
+            if _dmax_lam > POISSON_LAM_MAX:
+                raise ValueError("n too large or p too small, see Generator.negative_binomial Notes")
+
         return disc(&random_negative_binomial, &self._bitgen, size, self.lock, 2, 0,
-                    n, 'n', CONS_POSITIVE_NOT_NAN,
-                    p, 'p', CONS_BOUNDED_GT_0_1,
+                    n_arr, 'n', CONS_NONE,
+                    p_arr, 'p', CONS_NONE,
                     0.0, '', CONS_NONE)
 
     def poisson(self, lam=1.0, size=None):
@@ -3386,12 +3447,12 @@ cdef class Generator:
         Draw samples from a logarithmic series distribution.
 
         Samples are drawn from a log series distribution with specified
-        shape parameter, 0 < ``p`` < 1.
+        shape parameter, 0 <= ``p`` < 1.
 
         Parameters
         ----------
         p : float or array_like of floats
-            Shape parameter for the distribution.  Must be in the range (0, 1).
+            Shape parameter for the distribution.  Must be in the range [0, 1).
         size : int or tuple of ints, optional
             Output shape.  If the given shape is, e.g., ``(m, n, k)``, then
             ``m * n * k`` samples are drawn.  If size is ``None`` (default),
@@ -3455,7 +3516,7 @@ cdef class Generator:
 
         """
         return disc(&random_logseries, &self._bitgen, size, self.lock, 1, 0,
-                 p, 'p', CONS_BOUNDED_0_1,
+                 p, 'p', CONS_BOUNDED_LT_0_1,
                  0.0, '', CONS_NONE,
                  0.0, '', CONS_NONE)
 
@@ -3572,12 +3633,35 @@ cdef class Generator:
         >>> y.shape
         (3, 3, 2)
 
-        The following is probably true, given that 0.6 is roughly twice the
-        standard deviation:
+        Here we generate 800 samples from the bivariate normal distribution
+        with mean [0, 0] and covariance matrix [[6, -3], [-3, 3.5]].  The
+        expected variances of the first and second components of the sample
+        are 6 and 3.5, respectively, and the expected correlation
+        coefficient is -3/sqrt(6*3.5) ≈ -0.65465.
+
+        >>> cov = np.array([[6, -3], [-3, 3.5]])
+        >>> pts = rng.multivariate_normal([0, 0], cov, size=800)
 
-        >>> list((x[0,0,:] - mean) < 0.6)
-        [True, True] # random
+        Check that the mean, covariance, and correlation coefficient of the
+        sample are close to the expected values:
 
+        >>> pts.mean(axis=0)
+        array([ 0.0326911 , -0.01280782])  # may vary
+        >>> np.cov(pts.T)
+        array([[ 5.96202397, -2.85602287],
+               [-2.85602287,  3.47613949]])  # may vary
+        >>> np.corrcoef(pts.T)[0, 1]
+        -0.6273591314603949  # may vary
+
+        We can visualize this data with a scatter plot.  The orientation
+        of the point cloud illustrates the negative correlation of the
+        components of this sample.
+
+        >>> import matplotlib.pyplot as plt
+        >>> plt.plot(pts[:, 0], pts[:, 1], '.', alpha=0.5)
+        >>> plt.axis('equal')
+        >>> plt.grid()
+        >>> plt.show()
         """
         if method not in {'eigh', 'svd', 'cholesky'}:
             raise ValueError(
@@ -3586,6 +3670,11 @@ cdef class Generator:
         # Check preconditions on arguments
         mean = np.array(mean)
         cov = np.array(cov)
+
+        if (np.issubdtype(mean.dtype, np.complexfloating) or
+                np.issubdtype(cov.dtype, np.complexfloating)):
+            raise TypeError("mean and cov must not be complex")
+
         if size is None:
             shape = []
         elif isinstance(size, (int, long, np.integer)):
@@ -3647,10 +3736,10 @@ cdef class Generator:
                 psd = not np.any(s < -tol)
             if not psd:
                 if check_valid == 'warn':
-                    warnings.warn("covariance is not positive-semidefinite.",
+                    warnings.warn("covariance is not symmetric positive-semidefinite.",
                                   RuntimeWarning)
                 else:
-                    raise ValueError("covariance is not positive-semidefinite.")
+                    raise ValueError("covariance is not symmetric positive-semidefinite.")
 
         if method == 'cholesky':
             _factor = l
@@ -3714,6 +3803,9 @@ cdef class Generator:
             Each entry ``out[i,j,...,:]`` is a ``p``-dimensional value drawn
             from the distribution.
 
+            .. versionchanged:: 1.22.0
+                Added support for broadcasting `pvals` against `n`
+
         Examples
         --------
         Throw a dice 20 times:
@@ -4341,7 +4433,7 @@ cdef class Generator:
             is shuffled independently of the others.  If `axis` is
             None, the flattened array is shuffled.
         out : ndarray, optional
-            If given, this is the destinaton of the shuffled array.
+            If given, this is the destination of the shuffled array.
             If `out` is None, a shuffled copy of the array is returned.
 
         Returns
@@ -4355,6 +4447,12 @@ cdef class Generator:
         --------
         shuffle
         permutation
+        
+        Notes
+        -----
+        An important distinction between methods ``shuffle``  and ``permuted`` is 
+        how they both treat the ``axis`` parameter which can be found at 
+        :ref:`generator-handling-axis-parameter`.
 
         Examples
         --------
@@ -4416,6 +4514,7 @@ cdef class Generator:
         else:
             if type(out) is not np.ndarray:
                 raise TypeError('out must be a numpy array')
+            PyArray_FailUnlessWriteable(out, "out")
             if out.shape != x.shape:
                 raise ValueError('out must have the same shape as x')
             np.copyto(out, x, casting='safe')
@@ -4496,15 +4595,32 @@ cdef class Generator:
         -------
         None
 
+        See Also
+        --------
+        permuted
+        permutation
+
+        Notes
+        -----
+        An important distinction between methods ``shuffle``  and ``permuted`` is 
+        how they both treat the ``axis`` parameter which can be found at 
+        :ref:`generator-handling-axis-parameter`.
+
         Examples
         --------
         >>> rng = np.random.default_rng()
         >>> arr = np.arange(10)
+        >>> arr
+        array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
         >>> rng.shuffle(arr)
         >>> arr
-        [1 7 5 2 9 4 3 6 0 8] # random
+        array([2, 0, 7, 5, 1, 4, 8, 9, 3, 6]) # random
 
         >>> arr = np.arange(9).reshape((3, 3))
+        >>> arr
+        array([[0, 1, 2],
+               [3, 4, 5],
+               [6, 7, 8]])
         >>> rng.shuffle(arr)
         >>> arr
         array([[3, 4, 5], # random
@@ -4512,6 +4628,10 @@ cdef class Generator:
                [0, 1, 2]])
 
         >>> arr = np.arange(9).reshape((3, 3))
+        >>> arr
+        array([[0, 1, 2],
+               [3, 4, 5],
+               [6, 7, 8]])
         >>> rng.shuffle(arr, axis=1)
         >>> arr
         array([[2, 0, 1], # random
@@ -4524,6 +4644,8 @@ cdef class Generator:
             char* buf_ptr
 
         if isinstance(x, np.ndarray):
+            if not x.flags.writeable:
+                raise ValueError('array is read-only')
             # Only call ndim on ndarrays, see GH 18142
             axis = normalize_axis_index(axis, np.ndim(x))
 
@@ -4657,6 +4779,7 @@ cdef class Generator:
         return arr[tuple(slices)]
 
 
+@cython.embedsignature(True)
 def default_rng(seed=None):
     """Construct a new Generator with the default BitGenerator (PCG64).
 
diff --git a/numpy/random/_mt19937.pyi b/numpy/random/_mt19937.pyi
index 820f27392f0f..55cfb2db42b1 100644
--- a/numpy/random/_mt19937.pyi
+++ b/numpy/random/_mt19937.pyi
@@ -1,8 +1,8 @@
-from typing import Any, Union, TypedDict
+from typing import Any, TypedDict
 
 from numpy import dtype, ndarray, uint32
 from numpy.random.bit_generator import BitGenerator, SeedSequence
-from numpy.typing import _ArrayLikeInt_co
+from numpy._typing import _ArrayLikeInt_co
 
 class _MT19937Internal(TypedDict):
     key: ndarray[Any, dtype[uint32]]
@@ -13,7 +13,7 @@ class _MT19937State(TypedDict):
     state: _MT19937Internal
 
 class MT19937(BitGenerator):
-    def __init__(self, seed: Union[None, _ArrayLikeInt_co, SeedSequence] = ...) -> None: ...
+    def __init__(self, seed: None | _ArrayLikeInt_co | SeedSequence = ...) -> None: ...
     def _legacy_seeding(self, seed: _ArrayLikeInt_co) -> None: ...
     def jumped(self, jumps: int = ...) -> MT19937: ...
     @property
diff --git a/numpy/random/_mt19937.pyx b/numpy/random/_mt19937.pyx
index 16a377cc63b9..5a8d52e6bde8 100644
--- a/numpy/random/_mt19937.pyx
+++ b/numpy/random/_mt19937.pyx
@@ -109,7 +109,7 @@ cdef class MT19937(BitGenerator):
 
     **Compatibility Guarantee**
 
-    ``MT19937`` makes a guarantee that a fixed seed and will always produce
+    ``MT19937`` makes a guarantee that a fixed seed will always produce
     the same random integer stream.
 
     References
@@ -214,7 +214,7 @@ cdef class MT19937(BitGenerator):
 
         Returns a new bit generator with the state jumped
 
-        The state of the returned big generator is jumped as-if
+        The state of the returned bit generator is jumped as-if
         2**(128 * jumps) random numbers have been generated.
 
         Parameters
diff --git a/numpy/random/_pcg64.pyi b/numpy/random/_pcg64.pyi
index 4881a987e2a7..470aee867493 100644
--- a/numpy/random/_pcg64.pyi
+++ b/numpy/random/_pcg64.pyi
@@ -1,7 +1,7 @@
-from typing import Union, TypedDict
+from typing import TypedDict
 
 from numpy.random.bit_generator import BitGenerator, SeedSequence
-from numpy.typing import _ArrayLikeInt_co
+from numpy._typing import _ArrayLikeInt_co
 
 class _PCG64Internal(TypedDict):
     state: int
@@ -14,7 +14,7 @@ class _PCG64State(TypedDict):
     uinteger: int
 
 class PCG64(BitGenerator):
-    def __init__(self, seed: Union[None, _ArrayLikeInt_co, SeedSequence] = ...) -> None: ...
+    def __init__(self, seed: None | _ArrayLikeInt_co | SeedSequence = ...) -> None: ...
     def jumped(self, jumps: int = ...) -> PCG64: ...
     @property
     def state(
@@ -28,7 +28,7 @@ class PCG64(BitGenerator):
     def advance(self, delta: int) -> PCG64: ...
 
 class PCG64DXSM(BitGenerator):
-    def __init__(self, seed: Union[None, _ArrayLikeInt_co, SeedSequence] = ...) -> None: ...
+    def __init__(self, seed: None | _ArrayLikeInt_co | SeedSequence = ...) -> None: ...
     def jumped(self, jumps: int = ...) -> PCG64DXSM: ...
     @property
     def state(
diff --git a/numpy/random/_philox.pyi b/numpy/random/_philox.pyi
index dd1c5e6e9bab..26ce726ecf4a 100644
--- a/numpy/random/_philox.pyi
+++ b/numpy/random/_philox.pyi
@@ -1,8 +1,8 @@
-from typing import Any, Union, TypedDict
+from typing import Any, TypedDict
 
 from numpy import dtype, ndarray, uint64
 from numpy.random.bit_generator import BitGenerator, SeedSequence
-from numpy.typing import _ArrayLikeInt_co
+from numpy._typing import _ArrayLikeInt_co
 
 class _PhiloxInternal(TypedDict):
     counter: ndarray[Any, dtype[uint64]]
@@ -19,9 +19,9 @@ class _PhiloxState(TypedDict):
 class Philox(BitGenerator):
     def __init__(
         self,
-        seed: Union[None, _ArrayLikeInt_co, SeedSequence] = ...,
-        counter: Union[None, _ArrayLikeInt_co] = ...,
-        key: Union[None, _ArrayLikeInt_co] = ...,
+        seed: None | _ArrayLikeInt_co | SeedSequence = ...,
+        counter: None | _ArrayLikeInt_co = ...,
+        key: None | _ArrayLikeInt_co = ...,
     ) -> None: ...
     @property
     def state(
diff --git a/numpy/random/_philox.pyx b/numpy/random/_philox.pyx
index 0fe8ebd7cd5f..d9a366e86554 100644
--- a/numpy/random/_philox.pyx
+++ b/numpy/random/_philox.pyx
@@ -266,8 +266,8 @@ cdef class Philox(BitGenerator):
 
         Returns a new bit generator with the state jumped
 
-        The state of the returned big generator is jumped as-if
-        2**(128 * jumps) random numbers have been generated.
+        The state of the returned bit generator is jumped as-if
+        (2**128) * jumps random numbers have been generated.
 
         Parameters
         ----------
diff --git a/numpy/random/_pickle.py b/numpy/random/_pickle.py
index a32f64f4a3d3..073993726eb3 100644
--- a/numpy/random/_pickle.py
+++ b/numpy/random/_pickle.py
@@ -14,19 +14,19 @@
                  }
 
 
-def __generator_ctor(bit_generator_name='MT19937'):
+def __bit_generator_ctor(bit_generator_name='MT19937'):
     """
-    Pickling helper function that returns a Generator object
+    Pickling helper function that returns a bit generator object
 
     Parameters
     ----------
     bit_generator_name : str
-        String containing the core BitGenerator
+        String containing the name of the BitGenerator
 
     Returns
     -------
-    rg: Generator
-        Generator using the named core BitGenerator
+    bit_generator : BitGenerator
+        BitGenerator instance
     """
     if bit_generator_name in BitGenerators:
         bit_generator = BitGenerators[bit_generator_name]
@@ -34,50 +34,47 @@ def __generator_ctor(bit_generator_name='MT19937'):
         raise ValueError(str(bit_generator_name) + ' is not a known '
                                                    'BitGenerator module.')
 
-    return Generator(bit_generator())
+    return bit_generator()
 
 
-def __bit_generator_ctor(bit_generator_name='MT19937'):
+def __generator_ctor(bit_generator_name="MT19937",
+                     bit_generator_ctor=__bit_generator_ctor):
     """
-    Pickling helper function that returns a bit generator object
+    Pickling helper function that returns a Generator object
 
     Parameters
     ----------
     bit_generator_name : str
-        String containing the name of the BitGenerator
+        String containing the core BitGenerator's name
+    bit_generator_ctor : callable, optional
+        Callable function that takes bit_generator_name as its only argument
+        and returns an instantized bit generator.
 
     Returns
     -------
-    bit_generator: BitGenerator
-        BitGenerator instance
+    rg : Generator
+        Generator using the named core BitGenerator
     """
-    if bit_generator_name in BitGenerators:
-        bit_generator = BitGenerators[bit_generator_name]
-    else:
-        raise ValueError(str(bit_generator_name) + ' is not a known '
-                                                   'BitGenerator module.')
-
-    return bit_generator()
+    return Generator(bit_generator_ctor(bit_generator_name))
 
 
-def __randomstate_ctor(bit_generator_name='MT19937'):
+def __randomstate_ctor(bit_generator_name="MT19937",
+                       bit_generator_ctor=__bit_generator_ctor):
     """
     Pickling helper function that returns a legacy RandomState-like object
 
     Parameters
     ----------
     bit_generator_name : str
-        String containing the core BitGenerator
+        String containing the core BitGenerator's name
+    bit_generator_ctor : callable, optional
+        Callable function that takes bit_generator_name as its only argument
+        and returns an instantized bit generator.
 
     Returns
     -------
-    rs: RandomState
+    rs : RandomState
         Legacy RandomState using the named core BitGenerator
     """
-    if bit_generator_name in BitGenerators:
-        bit_generator = BitGenerators[bit_generator_name]
-    else:
-        raise ValueError(str(bit_generator_name) + ' is not a known '
-                                                   'BitGenerator module.')
 
-    return RandomState(bit_generator())
+    return RandomState(bit_generator_ctor(bit_generator_name))
diff --git a/numpy/random/_sfc64.pyi b/numpy/random/_sfc64.pyi
index 94d11a210fe6..e1810e7d5261 100644
--- a/numpy/random/_sfc64.pyi
+++ b/numpy/random/_sfc64.pyi
@@ -1,10 +1,10 @@
-from typing import Any, Union, TypedDict
+from typing import Any, TypedDict
 
 from numpy import dtype as dtype
 from numpy import ndarray as ndarray
 from numpy import uint64
 from numpy.random.bit_generator import BitGenerator, SeedSequence
-from numpy.typing import _ArrayLikeInt_co
+from numpy._typing import _ArrayLikeInt_co
 
 class _SFC64Internal(TypedDict):
     state: ndarray[Any, dtype[uint64]]
@@ -16,7 +16,7 @@ class _SFC64State(TypedDict):
     uinteger: int
 
 class SFC64(BitGenerator):
-    def __init__(self, seed: Union[None, _ArrayLikeInt_co, SeedSequence] = ...) -> None: ...
+    def __init__(self, seed: None | _ArrayLikeInt_co | SeedSequence = ...) -> None: ...
     @property
     def state(
         self,
diff --git a/numpy/random/bit_generator.pyi b/numpy/random/bit_generator.pyi
index fa2f1ab12c90..e6e3b10cd450 100644
--- a/numpy/random/bit_generator.pyi
+++ b/numpy/random/bit_generator.pyi
@@ -1,16 +1,9 @@
 import abc
 from threading import Lock
+from collections.abc import Callable, Mapping, Sequence
 from typing import (
     Any,
-    Callable,
-    Dict,
-    List,
-    Mapping,
     NamedTuple,
-    Optional,
-    Sequence,
-    Tuple,
-    Type,
     TypedDict,
     TypeVar,
     Union,
@@ -19,26 +12,26 @@ from typing import (
 )
 
 from numpy import dtype, ndarray, uint32, uint64
-from numpy.typing import _ArrayLikeInt_co, _ShapeLike, _SupportsDType, _UInt32Codes, _UInt64Codes
+from numpy._typing import _ArrayLikeInt_co, _ShapeLike, _SupportsDType, _UInt32Codes, _UInt64Codes
 
 _T = TypeVar("_T")
 
 _DTypeLikeUint32 = Union[
     dtype[uint32],
     _SupportsDType[dtype[uint32]],
-    Type[uint32],
+    type[uint32],
     _UInt32Codes,
 ]
 _DTypeLikeUint64 = Union[
     dtype[uint64],
     _SupportsDType[dtype[uint64]],
-    Type[uint64],
+    type[uint64],
     _UInt64Codes,
 ]
 
 class _SeedSeqState(TypedDict):
-    entropy: Union[None, int, Sequence[int]]
-    spawn_key: Tuple[int, ...]
+    entropy: None | int | Sequence[int]
+    spawn_key: tuple[int, ...]
     pool_size: int
     n_children_spawned: int
 
@@ -53,28 +46,28 @@ class _Interface(NamedTuple):
 class ISeedSequence(abc.ABC):
     @abc.abstractmethod
     def generate_state(
-        self, n_words: int, dtype: Union[_DTypeLikeUint32, _DTypeLikeUint64] = ...
-    ) -> ndarray[Any, dtype[Union[uint32, uint64]]]: ...
+        self, n_words: int, dtype: _DTypeLikeUint32 | _DTypeLikeUint64 = ...
+    ) -> ndarray[Any, dtype[uint32 | uint64]]: ...
 
 class ISpawnableSeedSequence(ISeedSequence):
     @abc.abstractmethod
-    def spawn(self: _T, n_children: int) -> List[_T]: ...
+    def spawn(self: _T, n_children: int) -> list[_T]: ...
 
 class SeedlessSeedSequence(ISpawnableSeedSequence):
     def generate_state(
-        self, n_words: int, dtype: Union[_DTypeLikeUint32, _DTypeLikeUint64] = ...
-    ) -> ndarray[Any, dtype[Union[uint32, uint64]]]: ...
-    def spawn(self: _T, n_children: int) -> List[_T]: ...
+        self, n_words: int, dtype: _DTypeLikeUint32 | _DTypeLikeUint64 = ...
+    ) -> ndarray[Any, dtype[uint32 | uint64]]: ...
+    def spawn(self: _T, n_children: int) -> list[_T]: ...
 
 class SeedSequence(ISpawnableSeedSequence):
-    entropy: Union[None, int, Sequence[int]]
-    spawn_key: Tuple[int, ...]
+    entropy: None | int | Sequence[int]
+    spawn_key: tuple[int, ...]
     pool_size: int
     n_children_spawned: int
     pool: ndarray[Any, dtype[uint32]]
     def __init__(
         self,
-        entropy: Union[None, int, Sequence[int], _ArrayLikeInt_co] = ...,
+        entropy: None | int | Sequence[int] | _ArrayLikeInt_co = ...,
         *,
         spawn_key: Sequence[int] = ...,
         pool_size: int = ...,
@@ -86,18 +79,18 @@ class SeedSequence(ISpawnableSeedSequence):
         self,
     ) -> _SeedSeqState: ...
     def generate_state(
-        self, n_words: int, dtype: Union[_DTypeLikeUint32, _DTypeLikeUint64] = ...
-    ) -> ndarray[Any, dtype[Union[uint32, uint64]]]: ...
-    def spawn(self, n_children: int) -> List[SeedSequence]: ...
+        self, n_words: int, dtype: _DTypeLikeUint32 | _DTypeLikeUint64 = ...
+    ) -> ndarray[Any, dtype[uint32 | uint64]]: ...
+    def spawn(self, n_children: int) -> list[SeedSequence]: ...
 
 class BitGenerator(abc.ABC):
     lock: Lock
-    def __init__(self, seed: Union[None, _ArrayLikeInt_co, SeedSequence] = ...) -> None: ...
-    def __getstate__(self) -> Dict[str, Any]: ...
-    def __setstate__(self, state: Dict[str, Any]) -> None: ...
+    def __init__(self, seed: None | _ArrayLikeInt_co | SeedSequence = ...) -> None: ...
+    def __getstate__(self) -> dict[str, Any]: ...
+    def __setstate__(self, state: dict[str, Any]) -> None: ...
     def __reduce__(
         self,
-    ) -> Tuple[Callable[[str], BitGenerator], Tuple[str], Tuple[Dict[str, Any]]]: ...
+    ) -> tuple[Callable[[str], BitGenerator], tuple[str], tuple[dict[str, Any]]]: ...
     @abc.abstractmethod
     @property
     def state(self) -> Mapping[str, Any]: ...
@@ -108,7 +101,7 @@ class BitGenerator(abc.ABC):
     @overload
     def random_raw(self, size: _ShapeLike = ..., output: Literal[True] = ...) -> ndarray[Any, dtype[uint64]]: ...  # type: ignore[misc]
     @overload
-    def random_raw(self, size: Optional[_ShapeLike] = ..., output: Literal[False] = ...) -> None: ...  # type: ignore[misc]
+    def random_raw(self, size: None | _ShapeLike = ..., output: Literal[False] = ...) -> None: ...  # type: ignore[misc]
     def _benchmark(self, cnt: int, method: str = ...) -> None: ...
     @property
     def ctypes(self) -> _Interface: ...
diff --git a/numpy/random/bit_generator.pyx b/numpy/random/bit_generator.pyx
index 123d77b40e2e..3da4fabce881 100644
--- a/numpy/random/bit_generator.pyx
+++ b/numpy/random/bit_generator.pyx
@@ -35,13 +35,7 @@ import abc
 import sys
 from itertools import cycle
 import re
-
-try:
-    from secrets import randbits
-except ImportError:
-    # secrets unavailable on python 3.5 and before
-    from random import SystemRandom
-    randbits = SystemRandom().getrandbits
+from secrets import randbits
 
 from threading import Lock
 
@@ -74,12 +68,12 @@ def _int_to_uint32_array(n):
         raise ValueError("expected non-negative integer")
     if n == 0:
         arr.append(np.uint32(n))
-    if isinstance(n, np.unsignedinteger):
-        # Cannot do n & MASK32, convert to python int
-        n = int(n)
+
+    # NumPy ints may not like `n & MASK32` or ``//= 2**32` so use Python int
+    n = int(n)
     while n > 0:
         arr.append(np.uint32(n & MASK32))
-        n //= (2**32)
+        n //= 2**32
     return np.array(arr, dtype=np.uint32)
 
 def _coerce_to_uint32_array(x):
@@ -267,8 +261,10 @@ cdef class SeedSequence():
     entropy : {None, int, sequence[int]}, optional
         The entropy for creating a `SeedSequence`.
     spawn_key : {(), sequence[int]}, optional
-        A third source of entropy, used internally when calling
-        `SeedSequence.spawn`
+        An additional source of entropy based on the position of this
+        `SeedSequence` in the tree of such objects created with the
+        `SeedSequence.spawn` method. Typically, only `SeedSequence.spawn` will
+        set this, and users will not.
     pool_size : {int}, optional
         Size of the pooled entropy to store. Default is 4 to give a 128-bit
         entropy pool. 8 (for 256 bits) is another reasonable choice if working
@@ -492,7 +488,7 @@ cdef class BitGenerator():
         A seed to initialize the `BitGenerator`. If None, then fresh,
         unpredictable entropy will be pulled from the OS. If an ``int`` or
         ``array_like[ints]`` is passed, then it will be passed to
-        ~`numpy.random.SeedSequence` to derive the initial `BitGenerator` state.
+        `~numpy.random.SeedSequence` to derive the initial `BitGenerator` state.
         One may also pass in a `SeedSequence` instance.
 
     Attributes
@@ -576,7 +572,7 @@ cdef class BitGenerator():
 
         Notes
         -----
-        This method directly exposes the the raw underlying pseudo-random
+        This method directly exposes the raw underlying pseudo-random
         number generator. All values are returned as unsigned 64-bit
         values irrespective of the number of bits produced by the PRNG.
 
diff --git a/numpy/random/mtrand.pyi b/numpy/random/mtrand.pyi
index cbe87a299842..271cb9787470 100644
--- a/numpy/random/mtrand.pyi
+++ b/numpy/random/mtrand.pyi
@@ -1,4 +1,5 @@
-from typing import Any, Callable, Dict, Optional, Tuple, Type, Union, overload, Literal
+from collections.abc import Callable
+from typing import Any, Union, overload, Literal
 
 from numpy import (
     bool_,
@@ -18,7 +19,7 @@ from numpy import (
     uint64,
 )
 from numpy.random.bit_generator import BitGenerator
-from numpy.typing import (
+from numpy._typing import (
     ArrayLike,
     _ArrayLikeFloat_co,
     _ArrayLikeInt_co,
@@ -46,7 +47,7 @@ from numpy.typing import (
 _DTypeLikeFloat32 = Union[
     dtype[float32],
     _SupportsDType[dtype[float32]],
-    Type[float32],
+    type[float32],
     _Float32Codes,
     _SingleCodes,
 ]
@@ -54,29 +55,29 @@ _DTypeLikeFloat32 = Union[
 _DTypeLikeFloat64 = Union[
     dtype[float64],
     _SupportsDType[dtype[float64]],
-    Type[float],
-    Type[float64],
+    type[float],
+    type[float64],
     _Float64Codes,
     _DoubleCodes,
 ]
 
 class RandomState:
     _bit_generator: BitGenerator
-    def __init__(self, seed: Union[None, _ArrayLikeInt_co, BitGenerator] = ...) -> None: ...
+    def __init__(self, seed: None | _ArrayLikeInt_co | BitGenerator = ...) -> None: ...
     def __repr__(self) -> str: ...
     def __str__(self) -> str: ...
-    def __getstate__(self) -> Dict[str, Any]: ...
-    def __setstate__(self, state: Dict[str, Any]) -> None: ...
-    def __reduce__(self) -> Tuple[Callable[[str], RandomState], Tuple[str], Dict[str, Any]]: ...
-    def seed(self, seed: Optional[_ArrayLikeFloat_co] = ...) -> None: ...
+    def __getstate__(self) -> dict[str, Any]: ...
+    def __setstate__(self, state: dict[str, Any]) -> None: ...
+    def __reduce__(self) -> tuple[Callable[[str], RandomState], tuple[str], dict[str, Any]]: ...
+    def seed(self, seed: None | _ArrayLikeFloat_co = ...) -> None: ...
     @overload
-    def get_state(self, legacy: Literal[False] = ...) -> Dict[str, Any]: ...
+    def get_state(self, legacy: Literal[False] = ...) -> dict[str, Any]: ...
     @overload
     def get_state(
         self, legacy: Literal[True] = ...
-    ) -> Union[Dict[str, Any], Tuple[str, ndarray[Any, dtype[uint32]], int, int, float]]: ...
+    ) -> dict[str, Any] | tuple[str, ndarray[Any, dtype[uint32]], int, int, float]: ...
     def set_state(
-        self, state: Union[Dict[str, Any], Tuple[str, ndarray[Any, dtype[uint32]], int, int, float]]
+        self, state: dict[str, Any] | tuple[str, ndarray[Any, dtype[uint32]], int, int, float]
     ) -> None: ...
     @overload
     def random_sample(self, size: None = ...) -> float: ...  # type: ignore[misc]
@@ -90,13 +91,13 @@ class RandomState:
     def beta(self, a: float, b: float, size: None = ...) -> float: ...  # type: ignore[misc]
     @overload
     def beta(
-        self, a: _ArrayLikeFloat_co, b: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+        self, a: _ArrayLikeFloat_co, b: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def exponential(self, scale: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
     @overload
     def exponential(
-        self, scale: _ArrayLikeFloat_co = ..., size: Optional[_ShapeLike] = ...
+        self, scale: _ArrayLikeFloat_co = ..., size: None | _ShapeLike = ...
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def standard_exponential(self, size: None = ...) -> float: ...  # type: ignore[misc]
@@ -110,13 +111,13 @@ class RandomState:
     def randint(  # type: ignore[misc]
         self,
         low: int,
-        high: Optional[int] = ...,
+        high: None | int = ...,
     ) -> int: ...
     @overload
     def randint(  # type: ignore[misc]
         self,
         low: int,
-        high: Optional[int] = ...,
+        high: None | int = ...,
         size: None = ...,
         dtype: _DTypeLikeBool = ...,
     ) -> bool: ...
@@ -124,114 +125,104 @@ class RandomState:
     def randint(  # type: ignore[misc]
         self,
         low: int,
-        high: Optional[int] = ...,
+        high: None | int = ...,
         size: None = ...,
-        dtype: Union[_DTypeLikeInt, _DTypeLikeUInt] = ...,
+        dtype: _DTypeLikeInt | _DTypeLikeUInt = ...,
     ) -> int: ...
     @overload
     def randint(  # type: ignore[misc]
         self,
         low: _ArrayLikeInt_co,
-        high: Optional[_ArrayLikeInt_co] = ...,
-        size: Optional[_ShapeLike] = ...,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
     ) -> ndarray[Any, dtype[int_]]: ...
     @overload
     def randint(  # type: ignore[misc]
         self,
         low: _ArrayLikeInt_co,
-        high: Optional[_ArrayLikeInt_co] = ...,
-        size: Optional[_ShapeLike] = ...,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
         dtype: _DTypeLikeBool = ...,
     ) -> ndarray[Any, dtype[bool_]]: ...
     @overload
     def randint(  # type: ignore[misc]
         self,
         low: _ArrayLikeInt_co,
-        high: Optional[_ArrayLikeInt_co] = ...,
-        size: Optional[_ShapeLike] = ...,
-        dtype: Union[dtype[int8], Type[int8], _Int8Codes, _SupportsDType[dtype[int8]]] = ...,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+        dtype: dtype[int8] | type[int8] | _Int8Codes | _SupportsDType[dtype[int8]] = ...,
     ) -> ndarray[Any, dtype[int8]]: ...
     @overload
     def randint(  # type: ignore[misc]
         self,
         low: _ArrayLikeInt_co,
-        high: Optional[_ArrayLikeInt_co] = ...,
-        size: Optional[_ShapeLike] = ...,
-        dtype: Union[dtype[int16], Type[int16], _Int16Codes, _SupportsDType[dtype[int16]]] = ...,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+        dtype: dtype[int16] | type[int16] | _Int16Codes | _SupportsDType[dtype[int16]] = ...,
     ) -> ndarray[Any, dtype[int16]]: ...
     @overload
     def randint(  # type: ignore[misc]
         self,
         low: _ArrayLikeInt_co,
-        high: Optional[_ArrayLikeInt_co] = ...,
-        size: Optional[_ShapeLike] = ...,
-        dtype: Union[dtype[int32], Type[int32], _Int32Codes, _SupportsDType[dtype[int32]]] = ...,
-    ) -> ndarray[Any, dtype[Union[int32]]]: ...
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+        dtype: dtype[int32] | type[int32] | _Int32Codes | _SupportsDType[dtype[int32]] = ...,
+    ) -> ndarray[Any, dtype[int32]]: ...
     @overload
     def randint(  # type: ignore[misc]
         self,
         low: _ArrayLikeInt_co,
-        high: Optional[_ArrayLikeInt_co] = ...,
-        size: Optional[_ShapeLike] = ...,
-        dtype: Optional[
-            Union[dtype[int64], Type[int64], _Int64Codes, _SupportsDType[dtype[int64]]]
-        ] = ...,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+        dtype: None | dtype[int64] | type[int64] | _Int64Codes | _SupportsDType[dtype[int64]] = ...,
     ) -> ndarray[Any, dtype[int64]]: ...
     @overload
     def randint(  # type: ignore[misc]
         self,
         low: _ArrayLikeInt_co,
-        high: Optional[_ArrayLikeInt_co] = ...,
-        size: Optional[_ShapeLike] = ...,
-        dtype: Union[dtype[uint8], Type[uint8], _UInt8Codes, _SupportsDType[dtype[uint8]]] = ...,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+        dtype: dtype[uint8] | type[uint8] | _UInt8Codes | _SupportsDType[dtype[uint8]] = ...,
     ) -> ndarray[Any, dtype[uint8]]: ...
     @overload
     def randint(  # type: ignore[misc]
         self,
         low: _ArrayLikeInt_co,
-        high: Optional[_ArrayLikeInt_co] = ...,
-        size: Optional[_ShapeLike] = ...,
-        dtype: Union[
-            dtype[uint16], Type[uint16], _UInt16Codes, _SupportsDType[dtype[uint16]]
-        ] = ...,
-    ) -> ndarray[Any, dtype[Union[uint16]]]: ...
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+        dtype: dtype[uint16] | type[uint16] | _UInt16Codes | _SupportsDType[dtype[uint16]] = ...,
+    ) -> ndarray[Any, dtype[uint16]]: ...
     @overload
     def randint(  # type: ignore[misc]
         self,
         low: _ArrayLikeInt_co,
-        high: Optional[_ArrayLikeInt_co] = ...,
-        size: Optional[_ShapeLike] = ...,
-        dtype: Union[
-            dtype[uint32], Type[uint32], _UInt32Codes, _SupportsDType[dtype[uint32]]
-        ] = ...,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+        dtype: dtype[uint32] | type[uint32] | _UInt32Codes | _SupportsDType[dtype[uint32]] = ...,
     ) -> ndarray[Any, dtype[uint32]]: ...
     @overload
     def randint(  # type: ignore[misc]
         self,
         low: _ArrayLikeInt_co,
-        high: Optional[_ArrayLikeInt_co] = ...,
-        size: Optional[_ShapeLike] = ...,
-        dtype: Union[
-            dtype[uint64], Type[uint64], _UInt64Codes, _SupportsDType[dtype[uint64]]
-        ] = ...,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+        dtype: dtype[uint64] | type[uint64] | _UInt64Codes | _SupportsDType[dtype[uint64]] = ...,
     ) -> ndarray[Any, dtype[uint64]]: ...
     @overload
     def randint(  # type: ignore[misc]
         self,
         low: _ArrayLikeInt_co,
-        high: Optional[_ArrayLikeInt_co] = ...,
-        size: Optional[_ShapeLike] = ...,
-        dtype: Union[
-            dtype[int_], Type[int], Type[int_], _IntCodes, _SupportsDType[dtype[int_]]
-        ] = ...,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+        dtype: dtype[int_] | type[int] | type[int_] | _IntCodes | _SupportsDType[dtype[int_]] = ...,
     ) -> ndarray[Any, dtype[int_]]: ...
     @overload
     def randint(  # type: ignore[misc]
         self,
         low: _ArrayLikeInt_co,
-        high: Optional[_ArrayLikeInt_co] = ...,
-        size: Optional[_ShapeLike] = ...,
-        dtype: Union[dtype[uint], Type[uint], _UIntCodes, _SupportsDType[dtype[uint]]] = ...,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+        dtype: dtype[uint] | type[uint] | _UIntCodes | _SupportsDType[dtype[uint]] = ...,
     ) -> ndarray[Any, dtype[uint]]: ...
     def bytes(self, length: int) -> bytes: ...
     @overload
@@ -240,7 +231,7 @@ class RandomState:
         a: int,
         size: None = ...,
         replace: bool = ...,
-        p: Optional[_ArrayLikeFloat_co] = ...,
+        p: None | _ArrayLikeFloat_co = ...,
     ) -> int: ...
     @overload
     def choice(
@@ -248,7 +239,7 @@ class RandomState:
         a: int,
         size: _ShapeLike = ...,
         replace: bool = ...,
-        p: Optional[_ArrayLikeFloat_co] = ...,
+        p: None | _ArrayLikeFloat_co = ...,
     ) -> ndarray[Any, dtype[int_]]: ...
     @overload
     def choice(
@@ -256,7 +247,7 @@ class RandomState:
         a: ArrayLike,
         size: None = ...,
         replace: bool = ...,
-        p: Optional[_ArrayLikeFloat_co] = ...,
+        p: None | _ArrayLikeFloat_co = ...,
     ) -> Any: ...
     @overload
     def choice(
@@ -264,7 +255,7 @@ class RandomState:
         a: ArrayLike,
         size: _ShapeLike = ...,
         replace: bool = ...,
-        p: Optional[_ArrayLikeFloat_co] = ...,
+        p: None | _ArrayLikeFloat_co = ...,
     ) -> ndarray[Any, Any]: ...
     @overload
     def uniform(self, low: float = ..., high: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
@@ -273,7 +264,7 @@ class RandomState:
         self,
         low: _ArrayLikeFloat_co = ...,
         high: _ArrayLikeFloat_co = ...,
-        size: Optional[_ShapeLike] = ...,
+        size: None | _ShapeLike = ...,
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def rand(self) -> float: ...
@@ -284,13 +275,13 @@ class RandomState:
     @overload
     def randn(self, *args: int) -> ndarray[Any, dtype[float64]]: ...
     @overload
-    def random_integers(self, low: int, high: Optional[int] = ..., size: None = ...) -> int: ...  # type: ignore[misc]
+    def random_integers(self, low: int, high: None | int = ..., size: None = ...) -> int: ...  # type: ignore[misc]
     @overload
     def random_integers(
         self,
         low: _ArrayLikeInt_co,
-        high: Optional[_ArrayLikeInt_co] = ...,
-        size: Optional[_ShapeLike] = ...,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
     ) -> ndarray[Any, dtype[int_]]: ...
     @overload
     def standard_normal(self, size: None = ...) -> float: ...  # type: ignore[misc]
@@ -305,7 +296,7 @@ class RandomState:
         self,
         loc: _ArrayLikeFloat_co = ...,
         scale: _ArrayLikeFloat_co = ...,
-        size: Optional[_ShapeLike] = ...,
+        size: None | _ShapeLike = ...,
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def standard_gamma(  # type: ignore[misc]
@@ -317,7 +308,7 @@ class RandomState:
     def standard_gamma(
         self,
         shape: _ArrayLikeFloat_co,
-        size: Optional[_ShapeLike] = ...,
+        size: None | _ShapeLike = ...,
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def gamma(self, shape: float, scale: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
@@ -326,13 +317,13 @@ class RandomState:
         self,
         shape: _ArrayLikeFloat_co,
         scale: _ArrayLikeFloat_co = ...,
-        size: Optional[_ShapeLike] = ...,
+        size: None | _ShapeLike = ...,
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def f(self, dfnum: float, dfden: float, size: None = ...) -> float: ...  # type: ignore[misc]
     @overload
     def f(
-        self, dfnum: _ArrayLikeFloat_co, dfden: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+        self, dfnum: _ArrayLikeFloat_co, dfden: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def noncentral_f(self, dfnum: float, dfden: float, nonc: float, size: None = ...) -> float: ...  # type: ignore[misc]
@@ -342,19 +333,19 @@ class RandomState:
         dfnum: _ArrayLikeFloat_co,
         dfden: _ArrayLikeFloat_co,
         nonc: _ArrayLikeFloat_co,
-        size: Optional[_ShapeLike] = ...,
+        size: None | _ShapeLike = ...,
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def chisquare(self, df: float, size: None = ...) -> float: ...  # type: ignore[misc]
     @overload
     def chisquare(
-        self, df: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+        self, df: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def noncentral_chisquare(self, df: float, nonc: float, size: None = ...) -> float: ...  # type: ignore[misc]
     @overload
     def noncentral_chisquare(
-        self, df: _ArrayLikeFloat_co, nonc: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+        self, df: _ArrayLikeFloat_co, nonc: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def standard_t(self, df: float, size: None = ...) -> float: ...  # type: ignore[misc]
@@ -370,25 +361,25 @@ class RandomState:
     def vonmises(self, mu: float, kappa: float, size: None = ...) -> float: ...  # type: ignore[misc]
     @overload
     def vonmises(
-        self, mu: _ArrayLikeFloat_co, kappa: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+        self, mu: _ArrayLikeFloat_co, kappa: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def pareto(self, a: float, size: None = ...) -> float: ...  # type: ignore[misc]
     @overload
     def pareto(
-        self, a: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+        self, a: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def weibull(self, a: float, size: None = ...) -> float: ...  # type: ignore[misc]
     @overload
     def weibull(
-        self, a: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+        self, a: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def power(self, a: float, size: None = ...) -> float: ...  # type: ignore[misc]
     @overload
     def power(
-        self, a: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+        self, a: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def standard_cauchy(self, size: None = ...) -> float: ...  # type: ignore[misc]
@@ -401,7 +392,7 @@ class RandomState:
         self,
         loc: _ArrayLikeFloat_co = ...,
         scale: _ArrayLikeFloat_co = ...,
-        size: Optional[_ShapeLike] = ...,
+        size: None | _ShapeLike = ...,
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def gumbel(self, loc: float = ..., scale: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
@@ -410,7 +401,7 @@ class RandomState:
         self,
         loc: _ArrayLikeFloat_co = ...,
         scale: _ArrayLikeFloat_co = ...,
-        size: Optional[_ShapeLike] = ...,
+        size: None | _ShapeLike = ...,
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def logistic(self, loc: float = ..., scale: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
@@ -419,7 +410,7 @@ class RandomState:
         self,
         loc: _ArrayLikeFloat_co = ...,
         scale: _ArrayLikeFloat_co = ...,
-        size: Optional[_ShapeLike] = ...,
+        size: None | _ShapeLike = ...,
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def lognormal(self, mean: float = ..., sigma: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
@@ -428,19 +419,19 @@ class RandomState:
         self,
         mean: _ArrayLikeFloat_co = ...,
         sigma: _ArrayLikeFloat_co = ...,
-        size: Optional[_ShapeLike] = ...,
+        size: None | _ShapeLike = ...,
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def rayleigh(self, scale: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
     @overload
     def rayleigh(
-        self, scale: _ArrayLikeFloat_co = ..., size: Optional[_ShapeLike] = ...
+        self, scale: _ArrayLikeFloat_co = ..., size: None | _ShapeLike = ...
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def wald(self, mean: float, scale: float, size: None = ...) -> float: ...  # type: ignore[misc]
     @overload
     def wald(
-        self, mean: _ArrayLikeFloat_co, scale: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+        self, mean: _ArrayLikeFloat_co, scale: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def triangular(self, left: float, mode: float, right: float, size: None = ...) -> float: ...  # type: ignore[misc]
@@ -450,37 +441,37 @@ class RandomState:
         left: _ArrayLikeFloat_co,
         mode: _ArrayLikeFloat_co,
         right: _ArrayLikeFloat_co,
-        size: Optional[_ShapeLike] = ...,
+        size: None | _ShapeLike = ...,
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def binomial(self, n: int, p: float, size: None = ...) -> int: ...  # type: ignore[misc]
     @overload
     def binomial(
-        self, n: _ArrayLikeInt_co, p: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+        self, n: _ArrayLikeInt_co, p: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
     ) -> ndarray[Any, dtype[int_]]: ...
     @overload
     def negative_binomial(self, n: float, p: float, size: None = ...) -> int: ...  # type: ignore[misc]
     @overload
     def negative_binomial(
-        self, n: _ArrayLikeFloat_co, p: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+        self, n: _ArrayLikeFloat_co, p: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
     ) -> ndarray[Any, dtype[int_]]: ...
     @overload
     def poisson(self, lam: float = ..., size: None = ...) -> int: ...  # type: ignore[misc]
     @overload
     def poisson(
-        self, lam: _ArrayLikeFloat_co = ..., size: Optional[_ShapeLike] = ...
+        self, lam: _ArrayLikeFloat_co = ..., size: None | _ShapeLike = ...
     ) -> ndarray[Any, dtype[int_]]: ...
     @overload
     def zipf(self, a: float, size: None = ...) -> int: ...  # type: ignore[misc]
     @overload
     def zipf(
-        self, a: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+        self, a: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
     ) -> ndarray[Any, dtype[int_]]: ...
     @overload
     def geometric(self, p: float, size: None = ...) -> int: ...  # type: ignore[misc]
     @overload
     def geometric(
-        self, p: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+        self, p: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
     ) -> ndarray[Any, dtype[int_]]: ...
     @overload
     def hypergeometric(self, ngood: int, nbad: int, nsample: int, size: None = ...) -> int: ...  # type: ignore[misc]
@@ -490,27 +481,27 @@ class RandomState:
         ngood: _ArrayLikeInt_co,
         nbad: _ArrayLikeInt_co,
         nsample: _ArrayLikeInt_co,
-        size: Optional[_ShapeLike] = ...,
+        size: None | _ShapeLike = ...,
     ) -> ndarray[Any, dtype[int_]]: ...
     @overload
     def logseries(self, p: float, size: None = ...) -> int: ...  # type: ignore[misc]
     @overload
     def logseries(
-        self, p: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+        self, p: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
     ) -> ndarray[Any, dtype[int_]]: ...
     def multivariate_normal(
         self,
         mean: _ArrayLikeFloat_co,
         cov: _ArrayLikeFloat_co,
-        size: Optional[_ShapeLike] = ...,
+        size: None | _ShapeLike = ...,
         check_valid: Literal["warn", "raise", "ignore"] = ...,
         tol: float = ...,
     ) -> ndarray[Any, dtype[float64]]: ...
     def multinomial(
-        self, n: _ArrayLikeInt_co, pvals: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+        self, n: _ArrayLikeInt_co, pvals: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
     ) -> ndarray[Any, dtype[int_]]: ...
     def dirichlet(
-        self, alpha: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+        self, alpha: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
     ) -> ndarray[Any, dtype[float64]]: ...
     def shuffle(self, x: ArrayLike) -> None: ...
     @overload
@@ -571,3 +562,9 @@ zipf = _rand.zipf
 # Two legacy that are trivial wrappers around random_sample
 sample = _rand.random_sample
 ranf = _rand.random_sample
+
+def set_bit_generator(bitgen: BitGenerator) -> None:
+    ...
+
+def get_bit_generator() -> BitGenerator:
+    ...
diff --git a/numpy/random/mtrand.pyx b/numpy/random/mtrand.pyx
index 3e13503d01b2..edf812a4d85b 100644
--- a/numpy/random/mtrand.pyx
+++ b/numpy/random/mtrand.pyx
@@ -19,8 +19,8 @@ from ._bounded_integers cimport (_rand_bool, _rand_int32, _rand_int64,
 from ._mt19937 import MT19937 as _MT19937
 from numpy.random cimport bitgen_t
 from ._common cimport (POISSON_LAM_MAX, CONS_POSITIVE, CONS_NONE,
-            CONS_NON_NEGATIVE, CONS_BOUNDED_0_1, CONS_BOUNDED_GT_0_1, CONS_GTE_1,
-            CONS_GT_1, LEGACY_CONS_POISSON,
+            CONS_NON_NEGATIVE, CONS_BOUNDED_0_1, CONS_BOUNDED_GT_0_1,
+            CONS_BOUNDED_LT_0_1, CONS_GTE_1, CONS_GT_1, LEGACY_CONS_POISSON,
             double_fill, cont, kahan_sum, cont_broadcast_3,
             check_array_constraint, check_constraint, disc, discrete_broadcast_iii,
             validate_output_shape
@@ -139,7 +139,7 @@ cdef class RandomState:
     'RandomState' methods using the same parameters will always produce the
     same results up to roundoff error except when the values were incorrect.
     `RandomState` is effectively frozen and will only receive updates that
-    are required by changes in the the internals of Numpy. More substantial
+    are required by changes in the internals of Numpy. More substantial
     changes, including algorithmic improvements, are reserved for
     `Generator`.
 
@@ -186,16 +186,7 @@ cdef class RandomState:
         else:
             bit_generator = seed
 
-        self._bit_generator = bit_generator
-        capsule = bit_generator.capsule
-        cdef const char *name = "BitGenerator"
-        if not PyCapsule_IsValid(capsule, name):
-            raise ValueError("Invalid bit generator. The bit generator must "
-                             "be instantized.")
-        self._bitgen = ( PyCapsule_GetPointer(capsule, name))[0]
-        self._aug_state.bit_generator = &self._bitgen
-        self._reset_gauss()
-        self.lock = bit_generator.lock
+        self._initialize_bit_generator(bit_generator)
 
     def __repr__(self):
         return self.__str__() + ' at 0x{:X}'.format(id(self))
@@ -213,9 +204,22 @@ cdef class RandomState:
         self.set_state(state)
 
     def __reduce__(self):
-        state = self.get_state(legacy=False)
+        ctor, name_tpl, _ = self._bit_generator.__reduce__()
+
         from ._pickle import __randomstate_ctor
-        return __randomstate_ctor, (state['bit_generator'],), state
+        return __randomstate_ctor, (name_tpl[0], ctor), self.get_state(legacy=False)
+
+    cdef _initialize_bit_generator(self, bit_generator):
+        self._bit_generator = bit_generator
+        capsule = bit_generator.capsule
+        cdef const char *name = "BitGenerator"
+        if not PyCapsule_IsValid(capsule, name):
+            raise ValueError("Invalid bit generator. The bit generator must "
+                             "be instantized.")
+        self._bitgen = ( PyCapsule_GetPointer(capsule, name))[0]
+        self._aug_state.bit_generator = &self._bitgen
+        self._reset_gauss()
+        self.lock = bit_generator.lock
 
     cdef _reset_gauss(self):
         self._aug_state.has_gauss = 0
@@ -223,7 +227,7 @@ cdef class RandomState:
 
     def seed(self, seed=None):
         """
-        seed(self, seed=None)
+        seed(seed=None)
 
         Reseed a legacy MT19937 BitGenerator
 
@@ -248,7 +252,7 @@ cdef class RandomState:
 
     def get_state(self, legacy=True):
         """
-        get_state()
+        get_state(legacy=True)
 
         Return a tuple representing the internal state of the generator.
 
@@ -258,12 +262,13 @@ cdef class RandomState:
         ----------
         legacy : bool, optional
             Flag indicating to return a legacy tuple state when the BitGenerator
-            is MT19937, instead of a dict.
+            is MT19937, instead of a dict. Raises ValueError if the underlying
+            bit generator is not an instance of MT19937.
 
         Returns
         -------
         out : {tuple(str, ndarray of 624 uints, int, int, float), dict}
-            The returned tuple has the following items:
+            If legacy is True, the returned tuple has the following items:
 
             1. the string 'MT19937'.
             2. a 1-D array of 624 unsigned integer keys.
@@ -293,6 +298,11 @@ cdef class RandomState:
             legacy = False
         st['has_gauss'] = self._aug_state.has_gauss
         st['gauss'] = self._aug_state.gauss
+        if legacy and not isinstance(self._bit_generator, _MT19937):
+            raise ValueError(
+                "legacy can only be True when the underlyign bitgenerator is "
+                "an instance of MT19937."
+            )
         if legacy:
             return (st['bit_generator'], st['state']['key'], st['state']['pos'],
                     st['has_gauss'], st['gauss'])
@@ -384,8 +394,9 @@ cdef class RandomState:
           (b - a) * random_sample() + a
 
         .. note::
-            New code should use the ``random`` method of a ``default_rng()``
-            instance instead; please see the :ref:`random-quick-start`.
+            New code should use the `~numpy.random.Generator.random`
+            method of a `~numpy.random.Generator` instance instead;
+            please see the :ref:`random-quick-start`.
 
         Parameters
         ----------
@@ -402,7 +413,7 @@ cdef class RandomState:
 
         See Also
         --------
-        Generator.random: which should be used for new code.
+        random.Generator.random: which should be used for new code.
 
         Examples
         --------
@@ -454,8 +465,10 @@ cdef class RandomState:
         It is often seen in Bayesian inference and order statistics.
 
         .. note::
-            New code should use the ``beta`` method of a ``default_rng()``
-            instance instead; please see the :ref:`random-quick-start`.
+            New code should use the `~numpy.random.Generator.beta`
+            method of a `~numpy.random.Generator` instance instead;
+            please see the :ref:`random-quick-start`.
+
 
         Parameters
         ----------
@@ -476,7 +489,7 @@ cdef class RandomState:
 
         See Also
         --------
-        Generator.beta: which should be used for new code.
+        random.Generator.beta: which should be used for new code.
         """
         return cont(&legacy_beta, &self._aug_state, size, self.lock, 2,
                     a, 'a', CONS_POSITIVE,
@@ -504,8 +517,9 @@ cdef class RandomState:
         between page requests to Wikipedia [2]_.
 
         .. note::
-            New code should use the ``exponential`` method of a ``default_rng()``
-            instance instead; please see the :ref:`random-quick-start`.
+            New code should use the `~numpy.random.Generator.exponential`
+            method of a `~numpy.random.Generator` instance instead;
+            please see the :ref:`random-quick-start`.
 
         Parameters
         ----------
@@ -525,7 +539,7 @@ cdef class RandomState:
 
         See Also
         --------
-        Generator.exponential: which should be used for new code.
+        random.Generator.exponential: which should be used for new code.
 
         References
         ----------
@@ -553,8 +567,10 @@ cdef class RandomState:
         with a scale parameter of 1.
 
         .. note::
-            New code should use the ``standard_exponential`` method of a ``default_rng()``
-            instance instead; please see the :ref:`random-quick-start`.
+            New code should use the
+            `~numpy.random.Generator.standard_exponential`
+            method of a `~numpy.random.Generator` instance instead;
+            please see the :ref:`random-quick-start`.
 
         Parameters
         ----------
@@ -570,7 +586,7 @@ cdef class RandomState:
 
         See Also
         --------
-        Generator.standard_exponential: which should be used for new code.
+        random.Generator.standard_exponential: which should be used for new code.
 
         Examples
         --------
@@ -654,8 +670,9 @@ cdef class RandomState:
         `high` is None (the default), then results are from [0, `low`).
 
         .. note::
-            New code should use the ``integers`` method of a ``default_rng()``
-            instance instead; please see the :ref:`random-quick-start`.
+            New code should use the `~numpy.random.Generator.randint`
+            method of a `~numpy.random.Generator` instance instead;
+            please see the :ref:`random-quick-start`.
 
         Parameters
         ----------
@@ -688,7 +705,7 @@ cdef class RandomState:
         random_integers : similar to `randint`, only for the closed
             interval [`low`, `high`], and 1 is the lowest value if `high` is
             omitted.
-        Generator.integers: which should be used for new code.
+        random.Generator.integers: which should be used for new code.
 
         Examples
         --------
@@ -775,8 +792,9 @@ cdef class RandomState:
         Return random bytes.
 
         .. note::
-            New code should use the ``bytes`` method of a ``default_rng()``
-            instance instead; please see the :ref:`random-quick-start`.
+            New code should use the `~numpy.random.Generator.bytes`
+            method of a `~numpy.random.Generator` instance instead;
+            please see the :ref:`random-quick-start`.
 
         Parameters
         ----------
@@ -790,7 +808,7 @@ cdef class RandomState:
 
         See Also
         --------
-        Generator.bytes: which should be used for new code.
+        random.Generator.bytes: which should be used for new code.
 
         Examples
         --------
@@ -813,8 +831,9 @@ cdef class RandomState:
         .. versionadded:: 1.7.0
 
         .. note::
-            New code should use the ``choice`` method of a ``default_rng()``
-            instance instead; please see the :ref:`random-quick-start`.
+            New code should use the `~numpy.random.Generator.choice`
+            method of a `~numpy.random.Generator` instance instead;
+            please see the :ref:`random-quick-start`.
 
         Parameters
         ----------
@@ -850,7 +869,7 @@ cdef class RandomState:
         See Also
         --------
         randint, shuffle, permutation
-        Generator.choice: which should be used in new code
+        random.Generator.choice: which should be used in new code
 
         Notes
         -----
@@ -1023,8 +1042,9 @@ cdef class RandomState:
         by `uniform`.
 
         .. note::
-            New code should use the ``uniform`` method of a ``default_rng()``
-            instance instead; please see the :ref:`random-quick-start`.
+            New code should use the `~numpy.random.Generator.uniform`
+            method of a `~numpy.random.Generator` instance instead;
+            please see the :ref:`random-quick-start`.
 
         Parameters
         ----------
@@ -1058,7 +1078,7 @@ cdef class RandomState:
         rand : Convenience function that accepts dimensions as input, e.g.,
                ``rand(2,2)`` would generate a 2-by-2 array of floats,
                uniformly distributed over ``[0, 1)``.
-        Generator.uniform: which should be used for new code.
+        random.Generator.uniform: which should be used for new code.
 
         Notes
         -----
@@ -1194,8 +1214,10 @@ cdef class RandomState:
             other NumPy functions like `numpy.zeros` and `numpy.ones`.
 
         .. note::
-            New code should use the ``standard_normal`` method of a ``default_rng()``
-            instance instead; please see the :ref:`random-quick-start`.
+            New code should use the
+            `~numpy.random.Generator.standard_normal`
+            method of a `~numpy.random.Generator` instance instead;
+            please see the :ref:`random-quick-start`.
 
         If positive int_like arguments are provided, `randn` generates an array
         of shape ``(d0, d1, ..., dn)``, filled
@@ -1220,20 +1242,22 @@ cdef class RandomState:
         --------
         standard_normal : Similar, but takes a tuple as its argument.
         normal : Also accepts mu and sigma arguments.
-        Generator.standard_normal: which should be used for new code.
+        random.Generator.standard_normal: which should be used for new code.
 
         Notes
         -----
-        For random samples from :math:`N(\\mu, \\sigma^2)`, use:
+        For random samples from the normal distribution with mean ``mu`` and
+        standard deviation ``sigma``, use::
 
-        ``sigma * np.random.randn(...) + mu``
+            sigma * np.random.randn(...) + mu
 
         Examples
         --------
         >>> np.random.randn()
         2.1923875335537315  # random
 
-        Two-by-four array of samples from N(3, 6.25):
+        Two-by-four array of samples from the normal distribution with
+        mean 3 and standard deviation 2.5:
 
         >>> 3 + 2.5 * np.random.randn(2, 4)
         array([[-4.49401501,  4.00950034, -1.81814867,  7.29718677],   # random
@@ -1348,8 +1372,10 @@ cdef class RandomState:
         Draw samples from a standard Normal distribution (mean=0, stdev=1).
 
         .. note::
-            New code should use the ``standard_normal`` method of a ``default_rng()``
-            instance instead; please see the :ref:`random-quick-start`.
+            New code should use the
+            `~numpy.random.Generator.standard_normal`
+            method of a `~numpy.random.Generator` instance instead;
+            please see the :ref:`random-quick-start`.
 
         Parameters
         ----------
@@ -1369,11 +1395,12 @@ cdef class RandomState:
         normal :
             Equivalent function with additional ``loc`` and ``scale`` arguments
             for setting the mean and standard deviation.
-        Generator.standard_normal: which should be used for new code.
+        random.Generator.standard_normal: which should be used for new code.
 
         Notes
         -----
-        For random samples from :math:`N(\\mu, \\sigma^2)`, use one of::
+        For random samples from the normal distribution with mean ``mu`` and
+        standard deviation ``sigma``, use one of::
 
             mu + sigma * np.random.standard_normal(size=...)
             np.random.normal(mu, sigma, size=...)
@@ -1393,7 +1420,8 @@ cdef class RandomState:
         >>> s.shape
         (3, 4, 2)
 
-        Two-by-four array of samples from :math:`N(3, 6.25)`:
+        Two-by-four array of samples from the normal distribution with
+        mean 3 and standard deviation 2.5:
 
         >>> 3 + 2.5 * np.random.standard_normal(size=(2, 4))
         array([[-4.49401501,  4.00950034, -1.81814867,  7.29718677],   # random
@@ -1423,8 +1451,9 @@ cdef class RandomState:
         unique distribution [2]_.
 
         .. note::
-            New code should use the ``normal`` method of a ``default_rng()``
-            instance instead; please see the :ref:`random-quick-start`.
+            New code should use the `~numpy.random.Generator.normal`
+            method of a `~numpy.random.Generator` instance instead;
+            please see the :ref:`random-quick-start`.
 
         Parameters
         ----------
@@ -1448,7 +1477,7 @@ cdef class RandomState:
         --------
         scipy.stats.norm : probability density function, distribution or
             cumulative density function, etc.
-        Generator.normal: which should be used for new code.
+        random.Generator.normal: which should be used for new code.
 
         Notes
         -----
@@ -1500,7 +1529,8 @@ cdef class RandomState:
         ...          linewidth=2, color='r')
         >>> plt.show()
 
-        Two-by-four array of samples from N(3, 6.25):
+        Two-by-four array of samples from the normal distribution with
+        mean 3 and standard deviation 2.5:
 
         >>> np.random.normal(3, 2.5, size=(2, 4))
         array([[-4.49401501,  4.00950034, -1.81814867,  7.29718677],   # random
@@ -1523,8 +1553,10 @@ cdef class RandomState:
         shape (sometimes designated "k") and scale=1.
 
         .. note::
-            New code should use the ``standard_gamma`` method of a ``default_rng()``
-            instance instead; please see the :ref:`random-quick-start`.
+            New code should use the
+            `~numpy.random.Generator.standard_gamma`
+            method of a `~numpy.random.Generator` instance instead;
+            please see the :ref:`random-quick-start`.
 
         Parameters
         ----------
@@ -1545,7 +1577,7 @@ cdef class RandomState:
         --------
         scipy.stats.gamma : probability density function, distribution or
             cumulative density function, etc.
-        Generator.standard_gamma: which should be used for new code.
+        random.Generator.standard_gamma: which should be used for new code.
 
         Notes
         -----
@@ -1604,8 +1636,9 @@ cdef class RandomState:
         "theta"), where both parameters are > 0.
 
         .. note::
-            New code should use the ``gamma`` method of a ``default_rng()``
-            instance instead; please see the :ref:`random-quick-start`.
+            New code should use the `~numpy.random.Generator.gamma`
+            method of a `~numpy.random.Generator` instance instead;
+            please see the :ref:`random-quick-start`.
 
         Parameters
         ----------
@@ -1629,7 +1662,7 @@ cdef class RandomState:
         --------
         scipy.stats.gamma : probability density function, distribution or
             cumulative density function, etc.
-        Generator.gamma: which should be used for new code.
+        random.Generator.gamma: which should be used for new code.
 
         Notes
         -----
@@ -1693,8 +1726,9 @@ cdef class RandomState:
         variates.
 
         .. note::
-            New code should use the ``f`` method of a ``default_rng()``
-            instance instead; please see the :ref:`random-quick-start`.
+            New code should use the `~numpy.random.Generator.f`
+            method of a `~numpy.random.Generator` instance instead;
+            please see the :ref:`random-quick-start`.
 
         Parameters
         ----------
@@ -1717,7 +1751,7 @@ cdef class RandomState:
         --------
         scipy.stats.f : probability density function, distribution or
             cumulative density function, etc.
-        Generator.f: which should be used for new code.
+        random.Generator.f: which should be used for new code.
 
         Notes
         -----
@@ -1781,8 +1815,10 @@ cdef class RandomState:
         `nonc` is the non-centrality parameter.
 
         .. note::
-            New code should use the ``noncentral_f`` method of a ``default_rng()``
-            instance instead; please see the :ref:`random-quick-start`.
+            New code should use the
+            `~numpy.random.Generator.noncentral_f`
+            method of a `~numpy.random.Generator` instance instead;
+            please see the :ref:`random-quick-start`.
 
         Parameters
         ----------
@@ -1810,7 +1846,7 @@ cdef class RandomState:
 
         See Also
         --------
-        Generator.noncentral_f: which should be used for new code.
+        random.Generator.noncentral_f: which should be used for new code.
 
         Notes
         -----
@@ -1866,8 +1902,9 @@ cdef class RandomState:
         is often used in hypothesis testing.
 
         .. note::
-            New code should use the ``chisquare`` method of a ``default_rng()``
-            instance instead; please see the :ref:`random-quick-start`.
+            New code should use the `~numpy.random.Generator.chisquare`
+            method of a `~numpy.random.Generator` instance instead;
+            please see the :ref:`random-quick-start`.
 
         Parameters
         ----------
@@ -1892,7 +1929,7 @@ cdef class RandomState:
 
         See Also
         --------
-        Generator.chisquare: which should be used for new code.
+        random.Generator.chisquare: which should be used for new code.
 
         Notes
         -----
@@ -1939,8 +1976,10 @@ cdef class RandomState:
         the :math:`\\chi^2` distribution.
 
         .. note::
-            New code should use the ``noncentral_chisquare`` method of a ``default_rng()``
-            instance instead; please see the :ref:`random-quick-start`.
+            New code should use the
+            `~numpy.random.Generator.noncentral_chisquare`
+            method of a `~numpy.random.Generator` instance instead;
+            please see the :ref:`random-quick-start`.
 
         Parameters
         ----------
@@ -1964,7 +2003,7 @@ cdef class RandomState:
 
         See Also
         --------
-        Generator.noncentral_chisquare: which should be used for new code.
+        random.Generator.noncentral_chisquare: which should be used for new code.
 
         Notes
         -----
@@ -2025,8 +2064,10 @@ cdef class RandomState:
         Also known as the Lorentz distribution.
 
         .. note::
-            New code should use the ``standard_cauchy`` method of a ``default_rng()``
-            instance instead; please see the :ref:`random-quick-start`.
+            New code should use the
+            `~numpy.random.Generator.standard_cauchy`
+            method of a `~numpy.random.Generator` instance instead;
+            please see the :ref:`random-quick-start`.
 
         Parameters
         ----------
@@ -2042,7 +2083,7 @@ cdef class RandomState:
 
         See Also
         --------
-        Generator.standard_cauchy: which should be used for new code.
+        random.Generator.standard_cauchy: which should be used for new code.
 
         Notes
         -----
@@ -2101,8 +2142,9 @@ cdef class RandomState:
         distribution (`standard_normal`).
 
         .. note::
-            New code should use the ``standard_t`` method of a ``default_rng()``
-            instance instead; please see the :ref:`random-quick-start`.
+            New code should use the `~numpy.random.Generator.standard_t`
+            method of a `~numpy.random.Generator` instance instead;
+            please see the :ref:`random-quick-start`.
 
         Parameters
         ----------
@@ -2121,7 +2163,7 @@ cdef class RandomState:
 
         See Also
         --------
-        Generator.standard_t: which should be used for new code.
+        random.Generator.standard_t: which should be used for new code.
 
         Notes
         -----
@@ -2218,8 +2260,9 @@ cdef class RandomState:
         distribution.
 
         .. note::
-            New code should use the ``vonmises`` method of a ``default_rng()``
-            instance instead; please see the :ref:`random-quick-start`.
+            New code should use the `~numpy.random.Generator.vonmises`
+            method of a `~numpy.random.Generator` instance instead;
+            please see the :ref:`random-quick-start`.
 
         Parameters
         ----------
@@ -2242,7 +2285,7 @@ cdef class RandomState:
         --------
         scipy.stats.vonmises : probability density function, distribution, or
             cumulative density function, etc.
-        Generator.vonmises: which should be used for new code.
+        random.Generator.vonmises: which should be used for new code.
 
         Notes
         -----
@@ -2316,8 +2359,9 @@ cdef class RandomState:
         remaining 80 percent of the range.
 
         .. note::
-            New code should use the ``pareto`` method of a ``default_rng()``
-            instance instead; please see the :ref:`random-quick-start`.
+            New code should use the `~numpy.random.Generator.pareto`
+            method of a `~numpy.random.Generator` instance instead;
+            please see the :ref:`random-quick-start`.
 
         Parameters
         ----------
@@ -2340,7 +2384,7 @@ cdef class RandomState:
             cumulative density function, etc.
         scipy.stats.genpareto : probability density function, distribution or
             cumulative density function, etc.
-        Generator.pareto: which should be used for new code.
+        random.Generator.pareto: which should be used for new code.
 
         Notes
         -----
@@ -2410,8 +2454,9 @@ cdef class RandomState:
         :math:`\\lambda` is just :math:`X = \\lambda(-ln(U))^{1/a}`.
 
         .. note::
-            New code should use the ``weibull`` method of a ``default_rng()``
-            instance instead; please see the :ref:`random-quick-start`.
+            New code should use the `~numpy.random.Generator.weibull`
+            method of a `~numpy.random.Generator` instance instead;
+            please see the :ref:`random-quick-start`.
 
         Parameters
         ----------
@@ -2434,7 +2479,7 @@ cdef class RandomState:
         scipy.stats.weibull_min
         scipy.stats.genextreme
         gumbel
-        Generator.weibull: which should be used for new code.
+        random.Generator.weibull: which should be used for new code.
 
         Notes
         -----
@@ -2506,8 +2551,9 @@ cdef class RandomState:
         Also known as the power function distribution.
 
         .. note::
-            New code should use the ``power`` method of a ``default_rng()``
-            instance instead; please see the :ref:`random-quick-start`.
+            New code should use the `~numpy.random.Generator.power`
+            method of a `~numpy.random.Generator` instance instead;
+            please see the :ref:`random-quick-start`.
 
         Parameters
         ----------
@@ -2531,7 +2577,7 @@ cdef class RandomState:
 
         See Also
         --------
-        Generator.power: which should be used for new code.
+        random.Generator.power: which should be used for new code.
 
         Notes
         -----
@@ -2617,8 +2663,9 @@ cdef class RandomState:
         random variables.
 
         .. note::
-            New code should use the ``laplace`` method of a ``default_rng()``
-            instance instead; please see the :ref:`random-quick-start`.
+            New code should use the `~numpy.random.Generator.laplace`
+            method of a `~numpy.random.Generator` instance instead;
+            please see the :ref:`random-quick-start`.
 
         Parameters
         ----------
@@ -2640,7 +2687,7 @@ cdef class RandomState:
 
         See Also
         --------
-        Generator.laplace: which should be used for new code.
+        random.Generator.laplace: which should be used for new code.
 
         Notes
         -----
@@ -2708,8 +2755,9 @@ cdef class RandomState:
         Notes and References below.
 
         .. note::
-            New code should use the ``gumbel`` method of a ``default_rng()``
-            instance instead; please see the :ref:`random-quick-start`.
+            New code should use the `~numpy.random.Generator.gumbel`
+            method of a `~numpy.random.Generator` instance instead;
+            please see the :ref:`random-quick-start`.
 
         Parameters
         ----------
@@ -2735,7 +2783,7 @@ cdef class RandomState:
         scipy.stats.gumbel_r
         scipy.stats.genextreme
         weibull
-        Generator.gumbel: which should be used for new code.
+        random.Generator.gumbel: which should be used for new code.
 
         Notes
         -----
@@ -2830,8 +2878,9 @@ cdef class RandomState:
         parameters, loc (location or mean, also median), and scale (>0).
 
         .. note::
-            New code should use the ``logistic`` method of a ``default_rng()``
-            instance instead; please see the :ref:`random-quick-start`.
+            New code should use the `~numpy.random.Generator.logistic`
+            method of a `~numpy.random.Generator` instance instead;
+            please see the :ref:`random-quick-start`.
 
         Parameters
         ----------
@@ -2855,7 +2904,7 @@ cdef class RandomState:
         --------
         scipy.stats.logistic : probability density function, distribution or
             cumulative density function, etc.
-        Generator.logistic: which should be used for new code.
+        random.Generator.logistic: which should be used for new code.
 
         Notes
         -----
@@ -2917,8 +2966,9 @@ cdef class RandomState:
         underlying normal distribution it is derived from.
 
         .. note::
-            New code should use the ``lognormal`` method of a ``default_rng()``
-            instance instead; please see the :ref:`random-quick-start`.
+            New code should use the `~numpy.random.Generator.lognormal`
+            method of a `~numpy.random.Generator` instance instead;
+            please see the :ref:`random-quick-start`.
 
         Parameters
         ----------
@@ -2942,7 +2992,7 @@ cdef class RandomState:
         --------
         scipy.stats.lognorm : probability density function, distribution,
             cumulative density function, etc.
-        Generator.lognormal: which should be used for new code.
+        random.Generator.lognormal: which should be used for new code.
 
         Notes
         -----
@@ -3030,8 +3080,9 @@ cdef class RandomState:
         Rayleigh.
 
         .. note::
-            New code should use the ``rayleigh`` method of a ``default_rng()``
-            instance instead; please see the :ref:`random-quick-start`.
+            New code should use the `~numpy.random.Generator.rayleigh`
+            method of a `~numpy.random.Generator` instance instead;
+            please see the :ref:`random-quick-start`.
 
         Parameters
         ----------
@@ -3050,7 +3101,7 @@ cdef class RandomState:
 
         See Also
         --------
-        Generator.rayleigh: which should be used for new code.
+        random.Generator.rayleigh: which should be used for new code.
 
         Notes
         -----
@@ -3112,8 +3163,9 @@ cdef class RandomState:
         unit distance and distance covered in unit time.
 
         .. note::
-            New code should use the ``wald`` method of a ``default_rng()``
-            instance instead; please see the :ref:`random-quick-start`.
+            New code should use the `~numpy.random.Generator.wald`
+            method of a `~numpy.random.Generator` instance instead;
+            please see the :ref:`random-quick-start`.
 
         Parameters
         ----------
@@ -3134,7 +3186,7 @@ cdef class RandomState:
 
         See Also
         --------
-        Generator.wald: which should be used for new code.
+        random.Generator.wald: which should be used for new code.
 
         Notes
         -----
@@ -3185,8 +3237,9 @@ cdef class RandomState:
         directly define the shape of the pdf.
 
         .. note::
-            New code should use the ``triangular`` method of a ``default_rng()``
-            instance instead; please see the :ref:`random-quick-start`.
+            New code should use the `~numpy.random.Generator.triangular`
+            method of a `~numpy.random.Generator` instance instead;
+            please see the :ref:`random-quick-start`.
 
         Parameters
         ----------
@@ -3211,7 +3264,7 @@ cdef class RandomState:
 
         See Also
         --------
-        Generator.triangular: which should be used for new code.
+        random.Generator.triangular: which should be used for new code.
 
         Notes
         -----
@@ -3292,8 +3345,9 @@ cdef class RandomState:
         input as a float, but it is truncated to an integer in use)
 
         .. note::
-            New code should use the ``binomial`` method of a ``default_rng()``
-            instance instead; please see the :ref:`random-quick-start`.
+            New code should use the `~numpy.random.Generator.binomial`
+            method of a `~numpy.random.Generator` instance instead;
+            please see the :ref:`random-quick-start`.
 
         Parameters
         ----------
@@ -3318,7 +3372,7 @@ cdef class RandomState:
         --------
         scipy.stats.binom : probability density function, distribution or
             cumulative density function, etc.
-        Generator.binomial: which should be used for new code.
+        random.Generator.binomial: which should be used for new code.
 
         Notes
         -----
@@ -3442,8 +3496,10 @@ cdef class RandomState:
         is > 0 and `p` is in the interval [0, 1].
 
         .. note::
-            New code should use the ``negative_binomial`` method of a ``default_rng()``
-            instance instead; please see the :ref:`random-quick-start`.
+            New code should use the
+            `~numpy.random.Generator.negative_binomial`
+            method of a `~numpy.random.Generator` instance instead;
+            please see the :ref:`random-quick-start`.
 
         Parameters
         ----------
@@ -3466,7 +3522,7 @@ cdef class RandomState:
 
         See Also
         --------
-        Generator.negative_binomial: which should be used for new code.
+        random.Generator.negative_binomial: which should be used for new code.
 
         Notes
         -----
@@ -3478,7 +3534,7 @@ cdef class RandomState:
         probability of success, :math:`N+n` is the number of trials, and
         :math:`\\Gamma` is the gamma function. When :math:`n` is an integer,
         :math:`\\frac{\\Gamma(N+n)}{N!\\Gamma(n)} = \\binom{N+n-1}{N}`, which is
-        the more common form of this term in the the pmf. The negative
+        the more common form of this term in the pmf. The negative
         binomial distribution gives the probability of N failures given n
         successes, with a success on the last trial.
 
@@ -3527,8 +3583,9 @@ cdef class RandomState:
         for large N.
 
         .. note::
-            New code should use the ``poisson`` method of a ``default_rng()``
-            instance instead; please see the :ref:`random-quick-start`.
+            New code should use the `~numpy.random.Generator.poisson`
+            method of a `~numpy.random.Generator` instance instead;
+            please see the :ref:`random-quick-start`.
 
         Parameters
         ----------
@@ -3549,7 +3606,7 @@ cdef class RandomState:
 
         See Also
         --------
-        Generator.poisson: which should be used for new code.
+        random.Generator.poisson: which should be used for new code.
 
         Notes
         -----
@@ -3614,8 +3671,9 @@ cdef class RandomState:
         frequency table.
 
         .. note::
-            New code should use the ``zipf`` method of a ``default_rng()``
-            instance instead; please see the :ref:`random-quick-start`.
+            New code should use the `~numpy.random.Generator.zipf`
+            method of a `~numpy.random.Generator` instance instead;
+            please see the :ref:`random-quick-start`.
 
         Parameters
         ----------
@@ -3636,7 +3694,7 @@ cdef class RandomState:
         --------
         scipy.stats.zipf : probability density function, distribution, or
             cumulative density function, etc.
-        Generator.zipf: which should be used for new code.
+        random.Generator.zipf: which should be used for new code.
 
         Notes
         -----
@@ -3713,8 +3771,9 @@ cdef class RandomState:
         where `p` is the probability of success of an individual trial.
 
         .. note::
-            New code should use the ``geometric`` method of a ``default_rng()``
-            instance instead; please see the :ref:`random-quick-start`.
+            New code should use the `~numpy.random.Generator.geometric`
+            method of a `~numpy.random.Generator` instance instead;
+            please see the :ref:`random-quick-start`.
 
         Parameters
         ----------
@@ -3733,7 +3792,7 @@ cdef class RandomState:
 
         See Also
         --------
-        Generator.geometric: which should be used for new code.
+        random.Generator.geometric: which should be used for new code.
 
         Examples
         --------
@@ -3767,8 +3826,10 @@ cdef class RandomState:
         than or equal to the sum ``ngood + nbad``).
 
         .. note::
-            New code should use the ``hypergeometric`` method of a ``default_rng()``
-            instance instead; please see the :ref:`random-quick-start`.
+            New code should use the
+            `~numpy.random.Generator.hypergeometric`
+            method of a `~numpy.random.Generator` instance instead;
+            please see the :ref:`random-quick-start`.
 
         Parameters
         ----------
@@ -3797,7 +3858,7 @@ cdef class RandomState:
         --------
         scipy.stats.hypergeom : probability density function, distribution or
             cumulative density function, etc.
-        Generator.hypergeometric: which should be used for new code.
+        random.Generator.hypergeometric: which should be used for new code.
 
         Notes
         -----
@@ -3895,16 +3956,17 @@ cdef class RandomState:
         Draw samples from a logarithmic series distribution.
 
         Samples are drawn from a log series distribution with specified
-        shape parameter, 0 < ``p`` < 1.
+        shape parameter, 0 <= ``p`` < 1.
 
         .. note::
-            New code should use the ``logseries`` method of a ``default_rng()``
-            instance instead; please see the :ref:`random-quick-start`.
+            New code should use the `~numpy.random.Generator.logseries`
+            method of a `~numpy.random.Generator` instance instead;
+            please see the :ref:`random-quick-start`.
 
         Parameters
         ----------
         p : float or array_like of floats
-            Shape parameter for the distribution.  Must be in the range (0, 1).
+            Shape parameter for the distribution.  Must be in the range [0, 1).
         size : int or tuple of ints, optional
             Output shape.  If the given shape is, e.g., ``(m, n, k)``, then
             ``m * n * k`` samples are drawn.  If size is ``None`` (default),
@@ -3920,7 +3982,7 @@ cdef class RandomState:
         --------
         scipy.stats.logser : probability density function, distribution or
             cumulative density function, etc.
-        Generator.logseries: which should be used for new code.
+        random.Generator.logseries: which should be used for new code.
 
         Notes
         -----
@@ -3969,7 +4031,7 @@ cdef class RandomState:
 
         """
         out = disc(&legacy_logseries, &self._bitgen, size, self.lock, 1, 0,
-                   p, 'p', CONS_BOUNDED_0_1,
+                   p, 'p', CONS_BOUNDED_LT_0_1,
                    0.0, '', CONS_NONE,
                    0.0, '', CONS_NONE)
         # Match historical output type
@@ -3991,8 +4053,10 @@ cdef class RandomState:
         squared) of the one-dimensional normal distribution.
 
         .. note::
-            New code should use the ``multivariate_normal`` method of a ``default_rng()``
-            instance instead; please see the :ref:`random-quick-start`.
+            New code should use the
+            `~numpy.random.Generator.multivariate_normal`
+            method of a `~numpy.random.Generator` instance instead;
+            please see the :ref:`random-quick-start`.
 
         Parameters
         ----------
@@ -4023,7 +4087,7 @@ cdef class RandomState:
 
         See Also
         --------
-        Generator.multivariate_normal: which should be used for new code.
+        random.Generator.multivariate_normal: which should be used for new code.
 
         Notes
         -----
@@ -4079,12 +4143,35 @@ cdef class RandomState:
         >>> x.shape
         (3, 3, 2)
 
-        The following is probably true, given that 0.6 is roughly twice the
-        standard deviation:
+        Here we generate 800 samples from the bivariate normal distribution
+        with mean [0, 0] and covariance matrix [[6, -3], [-3, 3.5]].  The
+        expected variances of the first and second components of the sample
+        are 6 and 3.5, respectively, and the expected correlation
+        coefficient is -3/sqrt(6*3.5) ≈ -0.65465.
+
+        >>> cov = np.array([[6, -3], [-3, 3.5]])
+        >>> pts = np.random.multivariate_normal([0, 0], cov, size=800)
+
+        Check that the mean, covariance, and correlation coefficient of the
+        sample are close to the expected values:
 
-        >>> list((x[0,0,:] - mean) < 0.6)
-        [True, True] # random
+        >>> pts.mean(axis=0)
+        array([ 0.0326911 , -0.01280782])  # may vary
+        >>> np.cov(pts.T)
+        array([[ 5.96202397, -2.85602287],
+               [-2.85602287,  3.47613949]])  # may vary
+        >>> np.corrcoef(pts.T)[0, 1]
+        -0.6273591314603949  # may vary
 
+        We can visualize this data with a scatter plot.  The orientation
+        of the point cloud illustrates the negative correlation of the
+        components of this sample.
+
+        >>> import matplotlib.pyplot as plt
+        >>> plt.plot(pts[:, 0], pts[:, 1], '.', alpha=0.5)
+        >>> plt.axis('equal')
+        >>> plt.grid()
+        >>> plt.show()
         """
         from numpy.linalg import svd
 
@@ -4139,11 +4226,11 @@ cdef class RandomState:
             psd = np.allclose(np.dot(v.T * s, v), cov, rtol=tol, atol=tol)
             if not psd:
                 if check_valid == 'warn':
-                    warnings.warn("covariance is not positive-semidefinite.",
+                    warnings.warn("covariance is not symmetric positive-semidefinite.",
                         RuntimeWarning)
                 else:
                     raise ValueError(
-                        "covariance is not positive-semidefinite.")
+                        "covariance is not symmetric positive-semidefinite.")
 
         x = np.dot(x, np.sqrt(s)[:, None] * v)
         x += mean
@@ -4165,8 +4252,9 @@ cdef class RandomState:
         outcome was ``i``.
 
         .. note::
-            New code should use the ``multinomial`` method of a ``default_rng()``
-            instance instead; please see the :ref:`random-quick-start`.
+            New code should use the `~numpy.random.Generator.multinomial`
+            method of a `~numpy.random.Generator` instance instead;
+            please see the :ref:`random-quick-start`.
 
         Parameters
         ----------
@@ -4193,7 +4281,7 @@ cdef class RandomState:
 
         See Also
         --------
-        Generator.multinomial: which should be used for new code.
+        random.Generator.multinomial: which should be used for new code.
 
         Examples
         --------
@@ -4234,18 +4322,21 @@ cdef class RandomState:
         ValueError: pvals < 0, pvals > 1 or pvals contains NaNs
 
         """
-        cdef np.npy_intp d, i, sz, offset
+        cdef np.npy_intp d, i, sz, offset, niter
         cdef np.ndarray parr, mnarr
         cdef double *pix
         cdef long *mnix
         cdef long ni
 
-        d = len(pvals)
         parr = np.PyArray_FROMANY(
-            pvals, np.NPY_DOUBLE, 1, 1, np.NPY_ARRAY_ALIGNED | np.NPY_ARRAY_C_CONTIGUOUS)
+            pvals, np.NPY_DOUBLE, 0, 1, np.NPY_ARRAY_ALIGNED | np.NPY_ARRAY_C_CONTIGUOUS)
+        if np.PyArray_NDIM(parr) == 0:
+            raise TypeError("pvals must be a 1-d sequence")
+        d = np.PyArray_SIZE(parr)
         pix = np.PyArray_DATA(parr)
         check_array_constraint(parr, 'pvals', CONS_BOUNDED_0_1)
-        if kahan_sum(pix, d-1) > (1.0 + 1e-12):
+        # Only check if pvals is non-empty due no checks in kahan_sum
+        if d and kahan_sum(pix, d-1) > (1.0 + 1e-12):
             # When floating, but not float dtype, and close, improve the error
             # 1.0001 works for float16 and float32
             if (isinstance(pvals, np.ndarray)
@@ -4260,7 +4351,6 @@ cdef class RandomState:
             else:
                 msg = "sum(pvals[:-1]) > 1.0"
             raise ValueError(msg)
-
         if size is None:
             shape = (d,)
         else:
@@ -4268,7 +4358,6 @@ cdef class RandomState:
                 shape = (operator.index(size), d)
             except:
                 shape = tuple(size) + (d,)
-
         multin = np.zeros(shape, dtype=int)
         mnarr = multin
         mnix = np.PyArray_DATA(mnarr)
@@ -4276,8 +4365,10 @@ cdef class RandomState:
         ni = n
         check_constraint(ni, 'n', CONS_NON_NEGATIVE)
         offset = 0
+        # gh-20483: Avoids divide by 0
+        niter = sz // d if d else 0
         with self.lock, nogil:
-            for i in range(sz // d):
+            for i in range(niter):
                 legacy_random_multinomial(&self._bitgen, ni, &mnix[offset], pix, d, &self._binomial)
                 offset += d
 
@@ -4296,8 +4387,9 @@ cdef class RandomState:
         inference.
 
         .. note::
-            New code should use the ``dirichlet`` method of a ``default_rng()``
-            instance instead; please see the :ref:`random-quick-start`.
+            New code should use the `~numpy.random.Generator.dirichlet`
+            method of a `~numpy.random.Generator` instance instead;
+            please see the :ref:`random-quick-start`.
 
         Parameters
         ----------
@@ -4315,13 +4407,13 @@ cdef class RandomState:
             The drawn samples, of shape ``(size, k)``.
 
         Raises
-        -------
+        ------
         ValueError
             If any value in ``alpha`` is less than or equal to zero
 
         See Also
         --------
-        Generator.dirichlet: which should be used for new code.
+        random.Generator.dirichlet: which should be used for new code.
 
         Notes
         -----
@@ -4442,8 +4534,9 @@ cdef class RandomState:
         their contents remains the same.
 
         .. note::
-            New code should use the ``shuffle`` method of a ``default_rng()``
-            instance instead; please see the :ref:`random-quick-start`.
+            New code should use the `~numpy.random.Generator.shuffle`
+            method of a `~numpy.random.Generator` instance instead;
+            please see the :ref:`random-quick-start`.
 
         Parameters
         ----------
@@ -4456,7 +4549,7 @@ cdef class RandomState:
 
         See Also
         --------
-        Generator.shuffle: which should be used for new code.
+        random.Generator.shuffle: which should be used for new code.
 
         Examples
         --------
@@ -4480,6 +4573,9 @@ cdef class RandomState:
             char* x_ptr
             char* buf_ptr
 
+        if isinstance(x, np.ndarray) and not x.flags.writeable:
+            raise ValueError('array is read-only')
+
         if type(x) is np.ndarray and x.ndim == 1 and x.size:
             # Fast, statically typed path: shuffle the underlying buffer.
             # Only for non-empty, 1d objects of class ndarray (subclasses such
@@ -4511,7 +4607,7 @@ cdef class RandomState:
                         "Shuffling a one dimensional array subclass containing "
                         "objects gives incorrect results for most array "
                         "subclasses.  "
-                        "Please us the new random number API instead: "
+                        "Please use the new random number API instead: "
                         "https://numpy.org/doc/stable/reference/random/index.html\n"
                         "The new API fixes this issue. This version will not "
                         "be fixed due to stability guarantees of the API.",
@@ -4562,8 +4658,10 @@ cdef class RandomState:
         first index.
 
         .. note::
-            New code should use the ``permutation`` method of a ``default_rng()``
-            instance instead; please see the :ref:`random-quick-start`.
+            New code should use the
+            `~numpy.random.Generator.permutation`
+            method of a `~numpy.random.Generator` instance instead;
+            please see the :ref:`random-quick-start`.
 
         Parameters
         ----------
@@ -4579,7 +4677,7 @@ cdef class RandomState:
 
         See Also
         --------
-        Generator.permutation: which should be used for new code.
+        random.Generator.permutation: which should be used for new code.
 
         Examples
         --------
@@ -4655,7 +4753,6 @@ random = _rand.random
 random_integers = _rand.random_integers
 random_sample = _rand.random_sample
 rayleigh = _rand.rayleigh
-seed = _rand.seed
 set_state = _rand.set_state
 shuffle = _rand.shuffle
 standard_cauchy = _rand.standard_cauchy
@@ -4670,6 +4767,85 @@ wald = _rand.wald
 weibull = _rand.weibull
 zipf = _rand.zipf
 
+def seed(seed=None):
+    """
+    seed(seed=None)
+
+    Reseed the singleton RandomState instance.
+
+    Notes
+    -----
+    This is a convenience, legacy function that exists to support
+    older code that uses the singleton RandomState. Best practice
+    is to use a dedicated ``Generator`` instance rather than
+    the random variate generation methods exposed directly in
+    the random module.
+
+    See Also
+    --------
+    numpy.random.Generator
+    """
+    if isinstance(_rand._bit_generator, _MT19937):
+        return _rand.seed(seed)
+    else:
+        bg_type = type(_rand._bit_generator)
+        _rand._bit_generator.state = bg_type(seed).state
+
+def get_bit_generator():
+    """
+    Returns the singleton RandomState's bit generator
+
+    Returns
+    -------
+    BitGenerator
+        The bit generator that underlies the singleton RandomState instance
+
+    Notes
+    -----
+    The singleton RandomState provides the random variate generators in the
+    ``numpy.random`` namespace. This function, and its counterpart set method,
+    provides a path to hot-swap the default MT19937 bit generator with a
+    user provided alternative. These function are intended to provide
+    a continuous path where a single underlying bit generator can be
+    used both with an instance of ``Generator`` and with the singleton
+    instance of RandomState.
+
+    See Also
+    --------
+    set_bit_generator
+    numpy.random.Generator
+    """
+    return _rand._bit_generator
+
+def set_bit_generator(bitgen):
+    """
+    Sets the singleton RandomState's bit generator
+
+    Parameters
+    ----------
+    bitgen
+        A bit generator instance
+
+    Notes
+    -----
+    The singleton RandomState provides the random variate generators in the
+    ``numpy.random``namespace. This function, and its counterpart get method,
+    provides a path to hot-swap the default MT19937 bit generator with a
+    user provided alternative. These function are intended to provide
+    a continuous path where a single underlying bit generator can be
+    used both with an instance of ``Generator`` and with the singleton
+    instance of RandomState.
+
+    See Also
+    --------
+    get_bit_generator
+    numpy.random.Generator
+    """
+    cdef RandomState singleton
+    singleton = _rand
+    singleton._initialize_bit_generator(bitgen)
+
+
 # Old aliases that should not be removed
 def sample(*args, **kwargs):
     """
@@ -4696,6 +4872,7 @@ __all__ = [
     'f',
     'gamma',
     'geometric',
+    'get_bit_generator',
     'get_state',
     'gumbel',
     'hypergeometric',
@@ -4723,6 +4900,7 @@ __all__ = [
     'rayleigh',
     'sample',
     'seed',
+    'set_bit_generator',
     'set_state',
     'shuffle',
     'standard_cauchy',
diff --git a/numpy/random/setup.py b/numpy/random/setup.py
index 866c0cb2f0ab..cd9ad976c31a 100644
--- a/numpy/random/setup.py
+++ b/numpy/random/setup.py
@@ -1,12 +1,9 @@
 import os
-import platform
 import sys
 from os.path import join
 
 from numpy.distutils.system_info import platform_bits
-
-is_msvc = (platform.platform().startswith('Windows') and
-           platform.python_compiler().startswith('MS'))
+from numpy.distutils.msvccompiler import lib_opts_if_msvc
 
 
 def configuration(parent_package='', top_path=None):
@@ -43,12 +40,12 @@ def generate_libraries(ext, build_dir):
     # Some bit generators exclude GCC inlining
     EXTRA_COMPILE_ARGS = ['-U__GNUC_GNU_INLINE__']
 
-    if is_msvc and platform_bits == 32:
-        # 32-bit windows requires explicit sse2 option
-        EXTRA_COMPILE_ARGS += ['/arch:SSE2']
-    elif not is_msvc:
-        # Some bit generators require c99
-        EXTRA_COMPILE_ARGS += ['-std=c99']
+    if sys.platform == 'cygwin':
+        # Export symbols without __declspec(dllexport) for using by cython.
+        # Using __declspec(dllexport) does not export other necessary symbols
+        # in Cygwin package's Cython environment, making it impossible to
+        # import modules.
+        EXTRA_LINK_ARGS += ['-Wl,--export-all-symbols']
 
     # Use legacy integer variable sizes
     LEGACY_DEFS = [('NP_RANDOM_LEGACY', '1')]
@@ -66,25 +63,25 @@ def generate_libraries(ext, build_dir):
         'src/distributions/random_hypergeometric.c',
     ]
 
-    def gl_if_msvc(build_cmd):
-        """ Add flag if we are using MSVC compiler
+    def lib_opts(build_cmd):
+        """ Add flags that depend on the compiler.
 
-        We can't see this in our scope, because we have not initialized the
-        distutils build command, so use this deferred calculation to run when
-        we are building the library.
+        We can't see which compiler we are using in our scope, because we have
+        not initialized the distutils build command, so use this deferred
+        calculation to run when we are building the library.
         """
-        # Keep in sync with numpy/core/setup.py
-        if build_cmd.compiler.compiler_type == 'msvc':
-            # explicitly disable whole-program optimization
-            return ['/GL-']
-        return []
+        opts = lib_opts_if_msvc(build_cmd)
+        if build_cmd.compiler.compiler_type != 'msvc':
+            # Some bit generators require c99
+            opts.append('-std=c99')
+        return opts
 
     config.add_installed_library('npyrandom',
         sources=npyrandom_sources,
         install_dir='lib',
         build_info={
             'include_dirs' : [],  # empty list required for creating npyrandom.h
-            'extra_compiler_args': [gl_if_msvc],
+            'extra_compiler_args': [lib_opts],
         })
 
     for gen in ['mt19937']:
diff --git a/numpy/random/src/mt19937/mt19937.h b/numpy/random/src/mt19937/mt19937.h
index 1b39e0b6434c..83129336a953 100644
--- a/numpy/random/src/mt19937/mt19937.h
+++ b/numpy/random/src/mt19937/mt19937.h
@@ -2,7 +2,7 @@
 #include 
 #include 
 
-#ifdef _WIN32
+#if defined(_WIN32) && !defined (__MINGW32__)
 #define inline __forceinline
 #endif
 
diff --git a/numpy/random/src/pcg64/pcg64.h b/numpy/random/src/pcg64/pcg64.h
index 90a83fd5edf9..b33a39fc632f 100644
--- a/numpy/random/src/pcg64/pcg64.h
+++ b/numpy/random/src/pcg64/pcg64.h
@@ -54,6 +54,9 @@
 
 #ifdef _WIN32
 #include 
+#endif
+
+#if defined(_WIN32) && !defined (__MINGW32__)
 #define inline __forceinline
 #endif
 
@@ -128,7 +131,7 @@ static inline pcg128_t pcg128_add(pcg128_t a, pcg128_t b) {
 static inline void _pcg_mult64(uint64_t x, uint64_t y, uint64_t *z1,
                                uint64_t *z0) {
 
-#if defined _WIN32 && _MSC_VER >= 1900 && _M_AMD64
+#if defined _WIN32 && _M_AMD64
   z0[0] = _umul128(x, y, z1);
 #else
   uint64_t x0, x1, y0, y1;
@@ -182,7 +185,7 @@ static inline void pcg_setseq_128_srandom_r(pcg_state_setseq_128 *rng,
 
 static inline uint64_t
 pcg_setseq_128_xsl_rr_64_random_r(pcg_state_setseq_128 *rng) {
-#if defined _WIN32 && _MSC_VER >= 1900 && _M_AMD64
+#if defined _WIN32 && _M_AMD64
   uint64_t h1;
   pcg128_t product;
 
@@ -212,7 +215,7 @@ static inline pcg128_t pcg128_mult_64(pcg128_t a, uint64_t b) {
 }
 
 static inline void pcg_cm_step_r(pcg_state_setseq_128 *rng) {
-#if defined _WIN32 && _MSC_VER >= 1900 && _M_AMD64
+#if defined _WIN32 && _M_AMD64
   uint64_t h1;
   pcg128_t product;
 
@@ -255,7 +258,7 @@ static inline uint64_t pcg_cm_random_r(pcg_state_setseq_128* rng)
   hi *= lo;
 
   /* Run the CM step. */
-#if defined _WIN32 && _MSC_VER >= 1900 && _M_AMD64
+#if defined _WIN32 && _M_AMD64
   uint64_t h1;
   pcg128_t product;
 
diff --git a/numpy/random/src/philox/philox.h b/numpy/random/src/philox/philox.h
index 8844acc15725..81e034a47931 100644
--- a/numpy/random/src/philox/philox.h
+++ b/numpy/random/src/philox/philox.h
@@ -33,7 +33,7 @@ static NPY_INLINE uint64_t mulhilo64(uint64_t a, uint64_t b, uint64_t *hip) {
   return (uint64_t)product;
 }
 #else
-#if defined(_WIN32)
+#if defined(_WIN32) && !defined(__MINGW32__)
 #include 
 #if defined(_WIN64) && defined(_M_AMD64)
 #pragma intrinsic(_umul128)
diff --git a/numpy/random/tests/test_extending.py b/numpy/random/tests/test_extending.py
index 99a819efb576..bc24bd259e8f 100644
--- a/numpy/random/tests/test_extending.py
+++ b/numpy/random/tests/test_extending.py
@@ -5,6 +5,8 @@
 import sys
 import warnings
 import numpy as np
+from numpy.distutils.misc_util import exec_mod_from_location
+from numpy.testing import IS_WASM
 
 try:
     import cffi
@@ -21,7 +23,8 @@
         # numba issue gh-4733
         warnings.filterwarnings('always', '', DeprecationWarning)
         import numba
-except ImportError:
+except (ImportError, SystemError):
+    # Certain numpy/numba versions trigger a SystemError due to a numba bug
     numba = None
 
 try:
@@ -30,16 +33,18 @@
 except ImportError:
     cython = None
 else:
-    from distutils.version import LooseVersion
-    # Cython 0.29.21 is required for Python 3.9 and there are
+    from numpy.compat import _pep440
+    # Cython 0.29.30 is required for Python 3.11 and there are
     # other fixes in the 0.29 series that are needed even for earlier
     # Python versions.
     # Note: keep in sync with the one in pyproject.toml
-    required_version = LooseVersion('0.29.21')
-    if LooseVersion(cython_version) < required_version:
+    required_version = '0.29.30'
+    if _pep440.parse(cython_version) < _pep440.Version(required_version):
         # too old or wrong cython, skip the test
         cython = None
 
+
+@pytest.mark.skipif(IS_WASM, reason="Can't start subprocess")
 @pytest.mark.skipif(cython is None, reason="requires cython")
 @pytest.mark.slow
 def test_cython(tmp_path):
@@ -75,10 +80,9 @@ def test_cython(tmp_path):
     assert so1 is not None
     assert so2 is not None
     # import the so's without adding the directory to sys.path
-    from importlib.machinery import ExtensionFileLoader 
-    extending = ExtensionFileLoader('extending', so1).load_module()
-    extending_distributions = ExtensionFileLoader('extending_distributions', so2).load_module()
-
+    exec_mod_from_location('extending', so1)
+    extending_distributions = exec_mod_from_location(
+                    'extending_distributions', so2)
     # actually test the cython c-extension
     from numpy.random import PCG64
     values = extending_distributions.uniforms_ex(PCG64(0), 10, 'd')
diff --git a/numpy/random/tests/test_generator_mt19937.py b/numpy/random/tests/test_generator_mt19937.py
index e5411b8ef569..54a5b73a31fe 100644
--- a/numpy/random/tests/test_generator_mt19937.py
+++ b/numpy/random/tests/test_generator_mt19937.py
@@ -8,7 +8,7 @@
 from numpy.testing import (
     assert_, assert_raises, assert_equal, assert_allclose,
     assert_warns, assert_no_warnings, assert_array_equal,
-    assert_array_almost_equal, suppress_warnings)
+    assert_array_almost_equal, suppress_warnings, IS_WASM)
 
 from numpy.random import Generator, MT19937, SeedSequence, RandomState
 
@@ -147,7 +147,7 @@ def test_multinomial_pvals_float32(self):
 
 class TestMultivariateHypergeometric:
 
-    def setup(self):
+    def setup_method(self):
         self.seed = 8675309
 
     def test_argument_validation(self):
@@ -280,7 +280,7 @@ def test_repeatability3(self):
 
 
 class TestSetState:
-    def setup(self):
+    def setup_method(self):
         self.seed = 1234567890
         self.rg = Generator(MT19937(self.seed))
         self.bit_generator = self.rg.bit_generator
@@ -707,7 +707,7 @@ class TestRandomDist:
     # Make sure the random distribution returns the correct value for a
     # given seed
 
-    def setup(self):
+    def setup_method(self):
         self.seed = 1234567890
 
     def test_integers(self):
@@ -1020,6 +1020,13 @@ def test_shuffle_exceptions(self):
         arr = np.ones((3, 2))
         assert_raises(np.AxisError, random.shuffle, arr, 2)
 
+    def test_shuffle_not_writeable(self):
+        random = Generator(MT19937(self.seed))
+        a = np.zeros(5)
+        a.flags.writeable = False
+        with pytest.raises(ValueError, match='read-only'):
+            random.shuffle(a)
+
     def test_permutation(self):
         random = Generator(MT19937(self.seed))
         alist = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
@@ -1116,6 +1123,12 @@ def test_permuted_out_with_wrong_type(self):
         with pytest.raises(TypeError, match='Cannot cast'):
             random.permuted(x, axis=1, out=out)
 
+    def test_permuted_not_writeable(self):
+        x = np.zeros((2, 5))
+        x.flags.writeable = False
+        with pytest.raises(ValueError, match='read-only'):
+            random.permuted(x, axis=1, out=x)
+
     def test_beta(self):
         random = Generator(MT19937(self.seed))
         actual = random.beta(.1, .9, size=(3, 2))
@@ -1350,10 +1363,22 @@ def test_logseries(self):
                             [5, 1]])
         assert_array_equal(actual, desired)
 
-    def test_logseries_exceptions(self):
-        with np.errstate(invalid='ignore'):
-            assert_raises(ValueError, random.logseries, np.nan)
-            assert_raises(ValueError, random.logseries, [np.nan] * 10)
+    def test_logseries_zero(self):
+        random = Generator(MT19937(self.seed))
+        assert random.logseries(0) == 1
+
+    @pytest.mark.parametrize("value", [np.nextafter(0., -1), 1., np.nan, 5.])
+    def test_logseries_exceptions(self, value):
+        random = Generator(MT19937(self.seed))
+        with np.errstate(invalid="ignore"):
+            with pytest.raises(ValueError):
+                random.logseries(value)
+            with pytest.raises(ValueError):
+                # contiguous path:
+                random.logseries(np.array([value] * 10))
+            with pytest.raises(ValueError):
+                # non-contiguous path:
+                random.logseries(np.array([value] * 10)[::2])
 
     def test_multinomial(self):
         random = Generator(MT19937(self.seed))
@@ -1366,6 +1391,7 @@ def test_multinomial(self):
                              [5, 5, 3, 1, 2, 4]]])
         assert_array_equal(actual, desired)
 
+    @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm")
     @pytest.mark.parametrize("method", ["svd", "eigh", "cholesky"])
     def test_multivariate_normal(self, method):
         random = Generator(MT19937(self.seed))
@@ -1439,6 +1465,12 @@ def test_multivariate_normal(self, method):
                       mu, np.empty((3, 2)))
         assert_raises(ValueError, random.multivariate_normal,
                       mu, np.eye(3))
+        
+    @pytest.mark.parametrize('mean, cov', [([0], [[1+1j]]), ([0j], [[1]])])
+    def test_multivariate_normal_disallow_complex(self, mean, cov):
+        random = Generator(MT19937(self.seed))
+        with pytest.raises(TypeError, match="must not be complex"):
+            random.multivariate_normal(mean, cov)
 
     @pytest.mark.parametrize("method", ["svd", "eigh", "cholesky"])
     def test_multivariate_normal_basic_stats(self, method):
@@ -1472,6 +1504,13 @@ def test_negative_binomial_p0_exception(self):
         with assert_raises(ValueError):
             x = random.negative_binomial(1, 0)
 
+    def test_negative_binomial_invalid_p_n_combination(self):
+        # Verify that values of p and n that would result in an overflow
+        # or infinite loop raise an exception.
+        with np.errstate(invalid='ignore'):
+            assert_raises(ValueError, random.negative_binomial, 2**62, 0.1)
+            assert_raises(ValueError, random.negative_binomial, [2**62], [0.1])
+
     def test_noncentral_chisquare(self):
         random = Generator(MT19937(self.seed))
         actual = random.noncentral_chisquare(df=5, nonc=5, size=(3, 2))
@@ -1803,7 +1842,7 @@ def test_zipf(self):
 class TestBroadcast:
     # tests that functions that broadcast behave
     # correctly when presented with non-scalar arguments
-    def setup(self):
+    def setup_method(self):
         self.seed = 123456789
 
 
@@ -2414,9 +2453,10 @@ def test_empty_outputs(self):
         assert actual.shape == (3, 0, 7, 4)
 
 
+@pytest.mark.skipif(IS_WASM, reason="can't start thread")
 class TestThread:
     # make sure each state produces the same sequence even in threads
-    def setup(self):
+    def setup_method(self):
         self.seeds = range(4)
 
     def check_function(self, function, sz):
@@ -2462,7 +2502,7 @@ def gen_random(state, out):
 
 # See Issue #4263
 class TestSingleEltArrayInput:
-    def setup(self):
+    def setup_method(self):
         self.argOne = np.array([2])
         self.argTwo = np.array([3])
         self.argThree = np.array([4])
@@ -2550,7 +2590,7 @@ def test_three_arg_funcs(self):
 def test_jumped(config):
     # Each config contains the initial seed, a number of raw steps
     # the sha256 hashes of the initial and the final states' keys and
-    # the position of of the initial and the final state.
+    # the position of the initial and the final state.
     # These were produced using the original C implementation.
     seed = config["seed"]
     steps = config["steps"]
@@ -2669,3 +2709,16 @@ def test_contig_req_out(dist, order, dtype):
     assert variates is out
     variates = dist(out=out, dtype=dtype, size=out.shape)
     assert variates is out
+
+
+def test_generator_ctor_old_style_pickle():
+    rg = np.random.Generator(np.random.PCG64DXSM(0))
+    rg.standard_normal(1)
+    # Directly call reduce which is used in pickling
+    ctor, args, state_a = rg.__reduce__()
+    # Simulate unpickling an old pickle that only has the name
+    assert args[:1] == ("PCG64DXSM",)
+    b = ctor(*args[:1])
+    b.bit_generator.state = state_a
+    state_b = b.bit_generator.state
+    assert state_a == state_b
diff --git a/numpy/random/tests/test_random.py b/numpy/random/tests/test_random.py
index 6a584a511e1c..0f4e7925a501 100644
--- a/numpy/random/tests/test_random.py
+++ b/numpy/random/tests/test_random.py
@@ -6,7 +6,7 @@
 from numpy.testing import (
         assert_, assert_raises, assert_equal, assert_warns,
         assert_no_warnings, assert_array_equal, assert_array_almost_equal,
-        suppress_warnings
+        suppress_warnings, IS_WASM
         )
 from numpy import random
 import sys
@@ -101,7 +101,7 @@ def test_multidimensional_pvals(self):
 
 
 class TestSetState:
-    def setup(self):
+    def setup_method(self):
         self.seed = 1234567890
         self.prng = random.RandomState(self.seed)
         self.state = self.prng.get_state()
@@ -290,7 +290,7 @@ class TestRandomDist:
     # Make sure the random distribution returns the correct value for a
     # given seed
 
-    def setup(self):
+    def setup_method(self):
         self.seed = 1234567890
 
     def test_rand(self):
@@ -564,6 +564,12 @@ def test_shuffle_memoryview(self):
         rng.shuffle(a)
         assert_equal(np.asarray(a), [4, 1, 0, 3, 2])
 
+    def test_shuffle_not_writeable(self):
+        a = np.zeros(3)
+        a.flags.writeable = False
+        with pytest.raises(ValueError, match='read-only'):
+            np.random.shuffle(a)
+
     def test_beta(self):
         np.random.seed(self.seed)
         actual = np.random.beta(.1, .9, size=(3, 2))
@@ -1042,7 +1048,7 @@ def test_zipf(self):
 class TestBroadcast:
     # tests that functions that broadcast behave
     # correctly when presented with non-scalar arguments
-    def setup(self):
+    def setup_method(self):
         self.seed = 123456789
 
     def setSeed(self):
@@ -1609,9 +1615,10 @@ def test_logseries(self):
         assert_raises(ValueError, logseries, bad_p_two * 3)
 
 
+@pytest.mark.skipif(IS_WASM, reason="can't start thread")
 class TestThread:
     # make sure each state produces the same sequence even in threads
-    def setup(self):
+    def setup_method(self):
         self.seeds = range(4)
 
     def check_function(self, function, sz):
@@ -1654,7 +1661,7 @@ def gen_random(state, out):
 
 # See Issue #4263
 class TestSingleEltArrayInput:
-    def setup(self):
+    def setup_method(self):
         self.argOne = np.array([2])
         self.argTwo = np.array([3])
         self.argThree = np.array([4])
@@ -1706,23 +1713,22 @@ def test_two_arg_funcs(self):
             out = func(self.argOne, argTwo[0])
             assert_equal(out.shape, self.tgtShape)
 
-# TODO: Uncomment once randint can broadcast arguments
-#    def test_randint(self):
-#        itype = [bool, np.int8, np.uint8, np.int16, np.uint16,
-#                 np.int32, np.uint32, np.int64, np.uint64]
-#        func = np.random.randint
-#        high = np.array([1])
-#        low = np.array([0])
-#
-#        for dt in itype:
-#            out = func(low, high, dtype=dt)
-#            self.assert_equal(out.shape, self.tgtShape)
-#
-#            out = func(low[0], high, dtype=dt)
-#            self.assert_equal(out.shape, self.tgtShape)
-#
-#            out = func(low, high[0], dtype=dt)
-#            self.assert_equal(out.shape, self.tgtShape)
+    def test_randint(self):
+        itype = [bool, np.int8, np.uint8, np.int16, np.uint16,
+                 np.int32, np.uint32, np.int64, np.uint64]
+        func = np.random.randint
+        high = np.array([1])
+        low = np.array([0])
+
+        for dt in itype:
+            out = func(low, high, dtype=dt)
+            assert_equal(out.shape, self.tgtShape)
+
+            out = func(low[0], high, dtype=dt)
+            assert_equal(out.shape, self.tgtShape)
+
+            out = func(low, high[0], dtype=dt)
+            assert_equal(out.shape, self.tgtShape)
 
     def test_three_arg_funcs(self):
         funcs = [np.random.noncentral_f, np.random.triangular,
diff --git a/numpy/random/tests/test_randomstate.py b/numpy/random/tests/test_randomstate.py
index 861813a95d1f..8b911cb3a81b 100644
--- a/numpy/random/tests/test_randomstate.py
+++ b/numpy/random/tests/test_randomstate.py
@@ -8,7 +8,7 @@
 from numpy.testing import (
         assert_, assert_raises, assert_equal, assert_warns,
         assert_no_warnings, assert_array_equal, assert_array_almost_equal,
-        suppress_warnings
+        suppress_warnings, IS_WASM
         )
 
 from numpy.random import MT19937, PCG64
@@ -53,6 +53,14 @@ def int_func(request):
             INT_FUNC_HASHES[request.param])
 
 
+@pytest.fixture
+def restore_singleton_bitgen():
+    """Ensures that the singleton bitgen is restored after a test"""
+    orig_bitgen = np.random.get_bit_generator()
+    yield
+    np.random.set_bit_generator(orig_bitgen)
+
+
 def assert_mt19937_state_equal(a, b):
     assert_equal(a['bit_generator'], b['bit_generator'])
     assert_array_equal(a['state']['key'], b['state']['key'])
@@ -177,7 +185,7 @@ def test_multinomial_pvals_float32(self):
 
 
 class TestSetState:
-    def setup(self):
+    def setup_method(self):
         self.seed = 1234567890
         self.random_state = random.RandomState(self.seed)
         self.state = self.random_state.get_state()
@@ -428,7 +436,7 @@ class TestRandomDist:
     # Make sure the random distribution returns the correct value for a
     # given seed
 
-    def setup(self):
+    def setup_method(self):
         self.seed = 1234567890
 
     def test_rand(self):
@@ -942,11 +950,20 @@ def test_logseries(self):
                             [3, 6]])
         assert_array_equal(actual, desired)
 
-    def test_logseries_exceptions(self):
-        with suppress_warnings() as sup:
-            sup.record(RuntimeWarning)
-            assert_raises(ValueError, random.logseries, np.nan)
-            assert_raises(ValueError, random.logseries, [np.nan] * 10)
+    def test_logseries_zero(self):
+        assert random.logseries(0) == 1
+
+    @pytest.mark.parametrize("value", [np.nextafter(0., -1), 1., np.nan, 5.])
+    def test_logseries_exceptions(self, value):
+        with np.errstate(invalid="ignore"):
+            with pytest.raises(ValueError):
+                random.logseries(value)
+            with pytest.raises(ValueError):
+                # contiguous path:
+                random.logseries(np.array([value] * 10))
+            with pytest.raises(ValueError):
+                # non-contiguous path:
+                random.logseries(np.array([value] * 10)[::2])
 
     def test_multinomial(self):
         random.seed(self.seed)
@@ -1293,7 +1310,7 @@ def test_zipf(self):
 class TestBroadcast:
     # tests that functions that broadcast behave
     # correctly when presented with non-scalar arguments
-    def setup(self):
+    def setup_method(self):
         self.seed = 123456789
 
     def set_seed(self):
@@ -1877,9 +1894,10 @@ def test_logseries(self):
         assert_raises(ValueError, logseries, bad_p_two * 3)
 
 
+@pytest.mark.skipif(IS_WASM, reason="can't start thread")
 class TestThread:
     # make sure each state produces the same sequence even in threads
-    def setup(self):
+    def setup_method(self):
         self.seeds = range(4)
 
     def check_function(self, function, sz):
@@ -1925,7 +1943,7 @@ def gen_random(state, out):
 
 # See Issue #4263
 class TestSingleEltArrayInput:
-    def setup(self):
+    def setup_method(self):
         self.argOne = np.array([2])
         self.argTwo = np.array([3])
         self.argThree = np.array([4])
@@ -2020,3 +2038,80 @@ def test_broadcast_size_error():
         random.binomial([1, 2], 0.3, size=(2, 1))
     with pytest.raises(ValueError):
         random.binomial([1, 2], [0.3, 0.7], size=(2, 1))
+
+
+def test_randomstate_ctor_old_style_pickle():
+    rs = np.random.RandomState(MT19937(0))
+    rs.standard_normal(1)
+    # Directly call reduce which is used in pickling
+    ctor, args, state_a = rs.__reduce__()
+    # Simulate unpickling an old pickle that only has the name
+    assert args[:1] == ("MT19937",)
+    b = ctor(*args[:1])
+    b.set_state(state_a)
+    state_b = b.get_state(legacy=False)
+
+    assert_equal(state_a['bit_generator'], state_b['bit_generator'])
+    assert_array_equal(state_a['state']['key'], state_b['state']['key'])
+    assert_array_equal(state_a['state']['pos'], state_b['state']['pos'])
+    assert_equal(state_a['has_gauss'], state_b['has_gauss'])
+    assert_equal(state_a['gauss'], state_b['gauss'])
+
+def test_hot_swap(restore_singleton_bitgen):
+    # GH 21808
+    def_bg = np.random.default_rng(0)
+    bg = def_bg.bit_generator
+    np.random.set_bit_generator(bg)
+    assert isinstance(np.random.mtrand._rand._bit_generator, type(bg))
+
+    second_bg = np.random.get_bit_generator()
+    assert bg is second_bg
+
+
+def test_seed_alt_bit_gen(restore_singleton_bitgen):
+    # GH 21808
+    bg = PCG64(0)
+    np.random.set_bit_generator(bg)
+    state = np.random.get_state(legacy=False)
+    np.random.seed(1)
+    new_state = np.random.get_state(legacy=False)
+    print(state)
+    print(new_state)
+    assert state["bit_generator"] == "PCG64"
+    assert state["state"]["state"] != new_state["state"]["state"]
+    assert state["state"]["inc"] != new_state["state"]["inc"]
+
+
+def test_state_error_alt_bit_gen(restore_singleton_bitgen):
+    # GH 21808
+    state = np.random.get_state()
+    bg = PCG64(0)
+    np.random.set_bit_generator(bg)
+    with pytest.raises(ValueError, match="state must be for a PCG64"):
+        np.random.set_state(state)
+
+
+def test_swap_worked(restore_singleton_bitgen):
+    # GH 21808
+    np.random.seed(98765)
+    vals = np.random.randint(0, 2 ** 30, 10)
+    bg = PCG64(0)
+    state = bg.state
+    np.random.set_bit_generator(bg)
+    state_direct = np.random.get_state(legacy=False)
+    for field in state:
+        assert state[field] == state_direct[field]
+    np.random.seed(98765)
+    pcg_vals = np.random.randint(0, 2 ** 30, 10)
+    assert not np.all(vals == pcg_vals)
+    new_state = bg.state
+    assert new_state["state"]["state"] != state["state"]["state"]
+    assert new_state["state"]["inc"] == new_state["state"]["inc"]
+
+
+def test_swapped_singleton_against_direct(restore_singleton_bitgen):
+    np.random.set_bit_generator(PCG64(98765))
+    singleton_vals = np.random.randint(0, 2 ** 30, 10)
+    rg = np.random.RandomState(PCG64(98765))
+    non_singleton_vals = rg.randint(0, 2 ** 30, 10)
+    assert_equal(non_singleton_vals, singleton_vals)
diff --git a/numpy/random/tests/test_randomstate_regression.py b/numpy/random/tests/test_randomstate_regression.py
index 595fb5fd308e..7ad19ab5562b 100644
--- a/numpy/random/tests/test_randomstate_regression.py
+++ b/numpy/random/tests/test_randomstate_regression.py
@@ -201,3 +201,16 @@ def test_n_zero_stream(self):
                              [3, 4, 2, 3, 3, 1, 5, 3, 1, 3]])
         assert_array_equal(random.binomial([[0], [10]], 0.25, size=(2, 10)),
                            expected)
+
+
+def test_multinomial_empty():
+    # gh-20483
+    # Ensure that empty p-vals are correctly handled
+    assert random.multinomial(10, []).shape == (0,)
+    assert random.multinomial(3, [], size=(7, 5, 3)).shape == (7, 5, 3, 0)
+
+
+def test_multinomial_1d_pval():
+    # gh-20483
+    with pytest.raises(TypeError, match="pvals must be a 1-d"):
+        random.multinomial(10, 0.3)
diff --git a/numpy/setup.py b/numpy/setup.py
index a0ca99919b3a..28c28d1acffa 100644
--- a/numpy/setup.py
+++ b/numpy/setup.py
@@ -19,10 +19,12 @@ def configuration(parent_package='',top_path=None):
     config.add_subpackage('random')
     config.add_subpackage('testing')
     config.add_subpackage('typing')
+    config.add_subpackage('_typing')
     config.add_data_dir('doc')
     config.add_data_files('py.typed')
     config.add_data_files('*.pyi')
     config.add_subpackage('tests')
+    config.add_subpackage('_pyinstaller')
     config.make_config_py() # installs __config__.py
     return config
 
diff --git a/numpy/testing/__init__.py b/numpy/testing/__init__.py
index 6e06c5b49af1..087527e43ebb 100644
--- a/numpy/testing/__init__.py
+++ b/numpy/testing/__init__.py
@@ -7,6 +7,7 @@
 """
 from unittest import TestCase
 
+from . import _private
 from ._private.utils import *
 from ._private.utils import (_assert_valid_refcount, _gen_alignment_data)
 from ._private import extbuild, decorators as dec
diff --git a/numpy/testing/__init__.pyi b/numpy/testing/__init__.pyi
index def0f9f58321..a981d61136dc 100644
--- a/numpy/testing/__init__.pyi
+++ b/numpy/testing/__init__.pyi
@@ -1,5 +1,3 @@
-from typing import List
-
 from numpy._pytesttester import PytestTester
 
 from unittest import (
@@ -48,11 +46,11 @@ from numpy.testing._private.utils import (
     HAS_LAPACK64 as HAS_LAPACK64,
 )
 
-__all__: List[str]
-__path__: List[str]
+__all__: list[str]
+__path__: list[str]
 test: PytestTester
 
 def run_module_suite(
     file_to_run: None | str = ...,
-    argv: None | List[str] = ...,
+    argv: None | list[str] = ...,
 ) -> None: ...
diff --git a/numpy/testing/_private/extbuild.py b/numpy/testing/_private/extbuild.py
index 20bf3dceac02..9b4e95366d8d 100644
--- a/numpy/testing/_private/extbuild.py
+++ b/numpy/testing/_private/extbuild.py
@@ -8,8 +8,6 @@
 import pathlib
 import sys
 import sysconfig
-from numpy.distutils.ccompiler import new_compiler
-from distutils.errors import CompileError
 
 __all__ = ['build_and_import_extension', 'compile_extension_module']
 
@@ -27,7 +25,7 @@ def build_and_import_extension(
     functions : list of fragments
         Each fragment is a sequence of func_name, calling convention, snippet.
     prologue : string
-        Code to preceed the rest, usually extra ``#include`` or ``#define``
+        Code to precede the rest, usually extra ``#include`` or ``#define``
         macros.
     build_dir : pathlib.Path
         Where to build the module, usually a temporary directory
@@ -53,6 +51,7 @@ def build_and_import_extension(
     >>> assert not mod.test_bytes(u'abc')
     >>> assert mod.test_bytes(b'abc')
     """
+    from distutils.errors import CompileError
 
     body = prologue + _make_methods(functions, modname)
     init = """PyObject *mod = PyModule_Create(&moduledef);
@@ -103,7 +102,7 @@ def compile_extension_module(
     dirname = builddir / name
     dirname.mkdir(exist_ok=True)
     cfile = _convert_str_to_file(source_string, dirname)
-    include_dirs = [sysconfig.get_config_var('INCLUDEPY')] + include_dirs
+    include_dirs = include_dirs + [sysconfig.get_config_var('INCLUDEPY')]
 
     return _c_compile(
         cfile, outputfilename=dirname / modname,
@@ -221,6 +220,7 @@ def _c_compile(cfile, outputfilename, include_dirs=[], libraries=[],
 def build(cfile, outputfilename, compile_extra, link_extra,
           include_dirs, libraries, library_dirs):
     "cd into the directory where the cfile is, use distutils to build"
+    from numpy.distutils.ccompiler import new_compiler
 
     compiler = new_compiler(force=1, verbose=2)
     compiler.customize('')
diff --git a/numpy/testing/_private/parameterized.py b/numpy/testing/_private/parameterized.py
index db9629a94680..3a29a1811d34 100644
--- a/numpy/testing/_private/parameterized.py
+++ b/numpy/testing/_private/parameterized.py
@@ -1,5 +1,5 @@
 """
-tl;dr: all code code is licensed under simplified BSD, unless stated otherwise.
+tl;dr: all code is licensed under simplified BSD, unless stated otherwise.
 
 Unless stated otherwise in the source files, all code is copyright 2010 David
 Wolever . All rights reserved.
diff --git a/numpy/testing/_private/utils.py b/numpy/testing/_private/utils.py
index 4c6b64bc90dd..2a2126503058 100644
--- a/numpy/testing/_private/utils.py
+++ b/numpy/testing/_private/utils.py
@@ -34,8 +34,9 @@
         'assert_array_max_ulp', 'assert_warns', 'assert_no_warnings',
         'assert_allclose', 'IgnoreException', 'clear_and_catch_warnings',
         'SkipTest', 'KnownFailureException', 'temppath', 'tempdir', 'IS_PYPY',
-        'HAS_REFCOUNT', 'suppress_warnings', 'assert_array_compare',
+        'HAS_REFCOUNT', "IS_WASM", 'suppress_warnings', 'assert_array_compare',
         'assert_no_gc_cycles', 'break_cycles', 'HAS_LAPACK64', 'IS_PYSTON',
+        '_OLD_PROMOTION'
         ]
 
 
@@ -47,11 +48,14 @@ class KnownFailureException(Exception):
 KnownFailureTest = KnownFailureException  # backwards compat
 verbose = 0
 
-IS_PYPY = platform.python_implementation() == 'PyPy'
+IS_WASM = platform.machine() in ["wasm32", "wasm64"]
+IS_PYPY = sys.implementation.name == 'pypy'
 IS_PYSTON = hasattr(sys, "pyston_version_info")
 HAS_REFCOUNT = getattr(sys, 'getrefcount', None) is not None and not IS_PYSTON
 HAS_LAPACK64 = numpy.linalg.lapack_lite._ilp64
 
+_OLD_PROMOTION = lambda: np._get_promotion_state() == 'legacy'
+
 
 def import_nose():
     """ Import nose only when needed.
@@ -473,6 +477,7 @@ def print_assert_equal(test_string, actual, desired):
         raise AssertionError(msg.getvalue())
 
 
+@np._no_nep50_warning()
 def assert_almost_equal(actual,desired,decimal=7,err_msg='',verbose=True):
     """
     Raises an AssertionError if two items are not equal up to desired
@@ -485,7 +490,7 @@ def assert_almost_equal(actual,desired,decimal=7,err_msg='',verbose=True):
 
     The test verifies that the elements of `actual` and `desired` satisfy.
 
-        ``abs(desired-actual) < 1.5 * 10**(-decimal)``
+        ``abs(desired-actual) < float64(1.5 * 10**(-decimal))``
 
     That is a looser test than originally documented, but agrees with what the
     actual implementation in `assert_array_almost_equal` did up to rounding
@@ -595,10 +600,11 @@ def _build_err_msg():
             return
     except (NotImplementedError, TypeError):
         pass
-    if abs(desired - actual) >= 1.5 * 10.0**(-decimal):
+    if abs(desired - actual) >= np.float64(1.5 * 10.0**(-decimal)):
         raise AssertionError(_build_err_msg())
 
 
+@np._no_nep50_warning()
 def assert_approx_equal(actual,desired,significant=7,err_msg='',verbose=True):
     """
     Raises an AssertionError if two items are not equal up to significant
@@ -698,8 +704,10 @@ def assert_approx_equal(actual,desired,significant=7,err_msg='',verbose=True):
         raise AssertionError(msg)
 
 
+@np._no_nep50_warning()
 def assert_array_compare(comparison, x, y, err_msg='', verbose=True, header='',
-                         precision=6, equal_nan=True, equal_inf=True):
+                         precision=6, equal_nan=True, equal_inf=True,
+                         *, strict=False):
     __tracebackhide__ = True  # Hide traceback for py.test
     from numpy.core import array, array2string, isnan, inf, bool_, errstate, all, max, object_
 
@@ -753,11 +761,18 @@ def func_assert_same_pos(x, y, func=isnan, hasval='nan'):
             return y_id
 
     try:
-        cond = (x.shape == () or y.shape == ()) or x.shape == y.shape
+        if strict:
+            cond = x.shape == y.shape and x.dtype == y.dtype
+        else:
+            cond = (x.shape == () or y.shape == ()) or x.shape == y.shape
         if not cond:
+            if x.shape != y.shape:
+                reason = f'\n(shapes {x.shape}, {y.shape} mismatch)'
+            else:
+                reason = f'\n(dtypes {x.dtype}, {y.dtype} mismatch)'
             msg = build_err_msg([x, y],
                                 err_msg
-                                + f'\n(shapes {x.shape}, {y.shape} mismatch)',
+                                + reason,
                                 verbose=verbose, header=header,
                                 names=('x', 'y'), precision=precision)
             raise AssertionError(msg)
@@ -810,10 +825,13 @@ def func_assert_same_pos(x, y, func=isnan, hasval='nan'):
                 'Mismatched elements: {} / {} ({:.3g}%)'.format(
                     n_mismatch, n_elements, percent_mismatch)]
 
-            with errstate(invalid='ignore', divide='ignore'):
+            with errstate(all='ignore'):
                 # ignore errors for non-numeric types
                 with contextlib.suppress(TypeError):
                     error = abs(x - y)
+                    if np.issubdtype(x.dtype, np.unsignedinteger):
+                        error2 = abs(y - x)
+                        np.minimum(error, error2, out=error)
                     max_abs_error = max(error)
                     if getattr(error, 'dtype', object_) == object_:
                         remarks.append('Max absolute difference: '
@@ -852,7 +870,7 @@ def func_assert_same_pos(x, y, func=isnan, hasval='nan'):
         raise ValueError(msg)
 
 
-def assert_array_equal(x, y, err_msg='', verbose=True):
+def assert_array_equal(x, y, err_msg='', verbose=True, *, strict=False):
     """
     Raises an AssertionError if two array_like objects are not equal.
 
@@ -876,6 +894,12 @@ def assert_array_equal(x, y, err_msg='', verbose=True):
         The error message to be printed in case of failure.
     verbose : bool, optional
         If True, the conflicting values are appended to the error message.
+    strict : bool, optional
+        If True, raise an AssertionError when either the shape or the data
+        type of the array_like objects does not match. The special
+        handling for scalars mentioned in the Notes section is disabled.
+
+        .. versionadded:: 1.24.0
 
     Raises
     ------
@@ -892,7 +916,7 @@ def assert_array_equal(x, y, err_msg='', verbose=True):
     -----
     When one of `x` and `y` is a scalar and the other is array_like, the
     function checks that each element of the array_like object is equal to
-    the scalar.
+    the scalar. This behaviour can be disabled with the `strict` parameter.
 
     Examples
     --------
@@ -929,12 +953,41 @@ def assert_array_equal(x, y, err_msg='', verbose=True):
     >>> x = np.full((2, 5), fill_value=3)
     >>> np.testing.assert_array_equal(x, 3)
 
+    Use `strict` to raise an AssertionError when comparing a scalar with an
+    array:
+
+    >>> np.testing.assert_array_equal(x, 3, strict=True)
+    Traceback (most recent call last):
+        ...
+    AssertionError:
+    Arrays are not equal
+    
+    (shapes (2, 5), () mismatch)
+     x: array([[3, 3, 3, 3, 3],
+           [3, 3, 3, 3, 3]])
+     y: array(3)
+
+    The `strict` parameter also ensures that the array data types match:
+
+    >>> x = np.array([2, 2, 2])
+    >>> y = np.array([2., 2., 2.], dtype=np.float32)
+    >>> np.testing.assert_array_equal(x, y, strict=True)
+    Traceback (most recent call last):
+        ...
+    AssertionError:
+    Arrays are not equal
+    
+    (dtypes int64, float32 mismatch)
+     x: array([2, 2, 2])
+     y: array([2., 2., 2.], dtype=float32)
     """
     __tracebackhide__ = True  # Hide traceback for py.test
     assert_array_compare(operator.__eq__, x, y, err_msg=err_msg,
-                         verbose=verbose, header='Arrays are not equal')
+                         verbose=verbose, header='Arrays are not equal',
+                         strict=strict)
 
 
+@np._no_nep50_warning()
 def assert_array_almost_equal(x, y, decimal=6, err_msg='', verbose=True):
     """
     Raises an AssertionError if two objects are not equal up to desired
@@ -1228,13 +1281,13 @@ def rundocs(filename=None, raise_on_error=True):
 
     >>> np.lib.test(doctests=True)  # doctest: +SKIP
     """
-    from numpy.compat import npy_load_module
+    from numpy.distutils.misc_util import exec_mod_from_location
     import doctest
     if filename is None:
         f = sys._getframe(1)
         filename = f.f_globals['__file__']
     name = os.path.splitext(os.path.basename(filename))[0]
-    m = npy_load_module(name, filename)
+    m = exec_mod_from_location(name, filename)
 
     tests = doctest.DocTestFinder().find(m)
     runner = doctest.DocTestRunner(verbose=False)
@@ -1342,9 +1395,6 @@ def assert_raises_regex(exception_class, expected_regexp, *args, **kwargs):
 
     Alternatively, can be used as a context manager like `assert_raises`.
 
-    Name of this function adheres to Python 3.2+ reference, but should work in
-    all versions down to 2.6.
-
     Notes
     -----
     .. versionadded:: 1.9.0
@@ -1479,6 +1529,12 @@ def assert_allclose(actual, desired, rtol=1e-7, atol=0, equal_nan=True,
     Raises an AssertionError if two objects are not equal up to desired
     tolerance.
 
+    Given two array_like objects, check that their shapes and all elements
+    are equal (but see the Notes for the special handling of a scalar). An
+    exception is raised if the shapes mismatch or any values conflict. In 
+    contrast to the standard usage in numpy, NaNs are compared like numbers,
+    no assertion is raised if both objects have NaNs in the same positions.
+
     The test is equivalent to ``allclose(actual, desired, rtol, atol)`` (note
     that ``allclose`` has different default values). It compares the difference
     between `actual` and `desired` to ``atol + rtol * abs(desired)``.
@@ -1511,6 +1567,12 @@ def assert_allclose(actual, desired, rtol=1e-7, atol=0, equal_nan=True,
     --------
     assert_array_almost_equal_nulp, assert_array_max_ulp
 
+    Notes
+    -----
+    When one of `actual` and `desired` is a scalar and the other is
+    array_like, the function checks that each element of the array_like
+    object is equal to the scalar.
+
     Examples
     --------
     >>> x = [1e-5, 1e-3, 1e-1]
@@ -1566,7 +1628,7 @@ def assert_array_almost_equal_nulp(x, y, nulp=1):
     -----
     An assertion is raised if the following condition is not met::
 
-        abs(x - y) <= nulps * spacing(maximum(abs(x), abs(y)))
+        abs(x - y) <= nulp * spacing(maximum(abs(x), abs(y)))
 
     Examples
     --------
@@ -2518,3 +2580,16 @@ def wrapper(*args, **kwargs):
             finally:
                 sys.settrace(original_trace)
         return wrapper
+
+
+def _get_glibc_version():
+    try:
+        ver = os.confstr('CS_GNU_LIBC_VERSION').rsplit(' ')[1]
+    except Exception as inst:
+        ver = '0.0'
+
+    return ver
+
+
+_glibcver = _get_glibc_version()
+_glibc_older_than = lambda x: (_glibcver != '0.0' and _glibcver < x)
diff --git a/numpy/testing/_private/utils.pyi b/numpy/testing/_private/utils.pyi
index 4ba5d82ee7bf..6e051e914177 100644
--- a/numpy/testing/_private/utils.pyi
+++ b/numpy/testing/_private/utils.pyi
@@ -5,31 +5,25 @@ import types
 import warnings
 import unittest
 import contextlib
+from re import Pattern
+from collections.abc import Callable, Iterable, Sequence
 from typing import (
     Literal as L,
     Any,
     AnyStr,
-    Callable,
     ClassVar,
-    Dict,
-    Iterable,
-    List,
     NoReturn,
     overload,
-    Pattern,
-    Sequence,
-    Set,
-    Tuple,
-    Type,
     type_check_only,
     TypeVar,
     Union,
     Final,
     SupportsIndex,
 )
+from typing_extensions import ParamSpec
 
 from numpy import generic, dtype, number, object_, bool_, _FloatValue
-from numpy.typing import (
+from numpy._typing import (
     NDArray,
     ArrayLike,
     DTypeLike,
@@ -43,6 +37,7 @@ from unittest.case import (
     SkipTest as SkipTest,
 )
 
+_P = ParamSpec("_P")
 _T = TypeVar("_T")
 _ET = TypeVar("_ET", bound=BaseException)
 _FT = TypeVar("_FT", bound=Callable[..., Any])
@@ -59,14 +54,14 @@ _ComparisonFunc = Callable[
     ],
 ]
 
-__all__: List[str]
+__all__: list[str]
 
 class KnownFailureException(Exception): ...
 class IgnoreException(Exception): ...
 
 class clear_and_catch_warnings(warnings.catch_warnings):
-    class_modules: ClassVar[Tuple[types.ModuleType, ...]]
-    modules: Set[types.ModuleType]
+    class_modules: ClassVar[tuple[types.ModuleType, ...]]
+    modules: set[types.ModuleType]
     @overload
     def __new__(
         cls,
@@ -85,10 +80,10 @@ class clear_and_catch_warnings(warnings.catch_warnings):
         record: bool,
         modules: Iterable[types.ModuleType] = ...,
     ) -> clear_and_catch_warnings: ...
-    def __enter__(self) -> None | List[warnings.WarningMessage]: ...
+    def __enter__(self) -> None | list[warnings.WarningMessage]: ...
     def __exit__(
         self,
-        __exc_type: None | Type[BaseException] = ...,
+        __exc_type: None | type[BaseException] = ...,
         __exc_val: None | BaseException = ...,
         __exc_tb: None | types.TracebackType = ...,
     ) -> None: ...
@@ -98,34 +93,34 @@ class clear_and_catch_warnings(warnings.catch_warnings):
 
 @type_check_only
 class _clear_and_catch_warnings_with_records(clear_and_catch_warnings):
-    def __enter__(self) -> List[warnings.WarningMessage]: ...
+    def __enter__(self) -> list[warnings.WarningMessage]: ...
 
 @type_check_only
 class _clear_and_catch_warnings_without_records(clear_and_catch_warnings):
     def __enter__(self) -> None: ...
 
 class suppress_warnings:
-    log: List[warnings.WarningMessage]
+    log: list[warnings.WarningMessage]
     def __init__(
         self,
         forwarding_rule: L["always", "module", "once", "location"] = ...,
     ) -> None: ...
     def filter(
         self,
-        category: Type[Warning] = ...,
+        category: type[Warning] = ...,
         message: str = ...,
         module: None | types.ModuleType = ...,
     ) -> None: ...
     def record(
         self,
-        category: Type[Warning] = ...,
+        category: type[Warning] = ...,
         message: str = ...,
         module: None | types.ModuleType = ...,
-    ) -> List[warnings.WarningMessage]: ...
+    ) -> list[warnings.WarningMessage]: ...
     def __enter__(self: _T) -> _T: ...
     def __exit__(
         self,
-        __exc_type: None | Type[BaseException] = ...,
+        __exc_type: None | type[BaseException] = ...,
         __exc_val: None | BaseException = ...,
         __exc_tb: None | types.TracebackType = ...,
     ) -> None: ...
@@ -151,10 +146,10 @@ else:
 if sys.platform == "linux":
     def jiffies(
         _proc_pid_stat: str | bytes | os.PathLike[Any] = ...,
-        _load_time: List[float] = ...,
+        _load_time: list[float] = ...,
     ) -> int: ...
 else:
-    def jiffies(_load_time: List[float] = ...) -> int: ...
+    def jiffies(_load_time: list[float] = ...) -> int: ...
 
 def build_err_msg(
     arrays: Iterable[object],
@@ -205,6 +200,8 @@ def assert_array_compare(
     precision: SupportsIndex = ...,
     equal_nan: bool = ...,
     equal_inf: bool = ...,
+    *,
+    strict: bool = ...
 ) -> None: ...
 
 def assert_array_equal(
@@ -212,6 +209,8 @@ def assert_array_equal(
     y: ArrayLike,
     err_msg: str = ...,
     verbose: bool = ...,
+    *,
+    strict: bool = ...
 ) -> None: ...
 
 def assert_array_almost_equal(
@@ -246,7 +245,7 @@ def assert_array_less(
 
 def runstring(
     astr: str | bytes | types.CodeType,
-    dict: None | Dict[str, Any],
+    dict: None | dict[str, Any],
 ) -> Any: ...
 
 def assert_string_equal(actual: str, desired: str) -> None: ...
@@ -256,42 +255,42 @@ def rundocs(
     raise_on_error: bool = ...,
 ) -> None: ...
 
-def raises(*args: Type[BaseException]) -> Callable[[_FT], _FT]: ...
+def raises(*args: type[BaseException]) -> Callable[[_FT], _FT]: ...
 
 @overload
 def assert_raises(  # type: ignore
-    expected_exception: Type[BaseException] | Tuple[Type[BaseException], ...],
-    callable: Callable[..., Any],
+    expected_exception: type[BaseException] | tuple[type[BaseException], ...],
+    callable: Callable[_P, Any],
     /,
-    *args: Any,
-    **kwargs: Any,
+    *args: _P.args,
+    **kwargs: _P.kwargs,
 ) -> None: ...
 @overload
 def assert_raises(
-    expected_exception: Type[_ET] | Tuple[Type[_ET], ...],
+    expected_exception: type[_ET] | tuple[type[_ET], ...],
     *,
     msg: None | str = ...,
 ) -> unittest.case._AssertRaisesContext[_ET]: ...
 
 @overload
 def assert_raises_regex(
-    expected_exception: Type[BaseException] | Tuple[Type[BaseException], ...],
+    expected_exception: type[BaseException] | tuple[type[BaseException], ...],
     expected_regex: str | bytes | Pattern[Any],
-    callable: Callable[..., Any],
+    callable: Callable[_P, Any],
     /,
-    *args: Any,
-    **kwargs: Any,
+    *args: _P.args,
+    **kwargs: _P.kwargs,
 ) -> None: ...
 @overload
 def assert_raises_regex(
-    expected_exception: Type[_ET] | Tuple[Type[_ET], ...],
+    expected_exception: type[_ET] | tuple[type[_ET], ...],
     expected_regex: str | bytes | Pattern[Any],
     *,
     msg: None | str = ...,
 ) -> unittest.case._AssertRaisesContext[_ET]: ...
 
 def decorate_methods(
-    cls: Type[Any],
+    cls: type[Any],
     decorator: Callable[[Callable[..., Any]], Any],
     testmatch: None | str | bytes | Pattern[Any] = ...,
 ) -> None: ...
@@ -338,25 +337,25 @@ def assert_array_max_ulp(
 
 @overload
 def assert_warns(
-    warning_class: Type[Warning],
+    warning_class: type[Warning],
 ) -> contextlib._GeneratorContextManager[None]: ...
 @overload
 def assert_warns(
-    warning_class: Type[Warning],
-    func: Callable[..., _T],
+    warning_class: type[Warning],
+    func: Callable[_P, _T],
     /,
-    *args: Any,
-    **kwargs: Any,
+    *args: _P.args,
+    **kwargs: _P.kwargs,
 ) -> _T: ...
 
 @overload
 def assert_no_warnings() -> contextlib._GeneratorContextManager[None]: ...
 @overload
 def assert_no_warnings(
-    func: Callable[..., _T],
+    func: Callable[_P, _T],
     /,
-    *args: Any,
-    **kwargs: Any,
+    *args: _P.args,
+    **kwargs: _P.kwargs,
 ) -> _T: ...
 
 @overload
@@ -391,10 +390,10 @@ def temppath(
 def assert_no_gc_cycles() -> contextlib._GeneratorContextManager[None]: ...
 @overload
 def assert_no_gc_cycles(
-    func: Callable[..., Any],
+    func: Callable[_P, Any],
     /,
-    *args: Any,
-    **kwargs: Any,
+    *args: _P.args,
+    **kwargs: _P.kwargs,
 ) -> None: ...
 
 def break_cycles() -> None: ...
diff --git a/numpy/testing/print_coercion_tables.py b/numpy/testing/print_coercion_tables.py
index 3a447cd2db5e..c1d4cdff8fd0 100755
--- a/numpy/testing/print_coercion_tables.py
+++ b/numpy/testing/print_coercion_tables.py
@@ -87,11 +87,12 @@ def print_new_cast_table(*, can_cast=True, legacy=False, flags=False):
     from numpy.core._multiarray_tests import get_all_cast_information
 
     cast_table = {
-        0 : "#",  # No cast (classify as equivalent here)
-        1 : "#",  # equivalent casting
-        2 : "=",  # safe casting
-        3 : "~",  # same-kind casting
-        4 : ".",  # unsafe casting
+        -1: " ",
+        0: "#",  # No cast (classify as equivalent here)
+        1: "#",  # equivalent casting
+        2: "=",  # safe casting
+        3: "~",  # same-kind casting
+        4: ".",  # unsafe casting
     }
     flags_table = {
         0 : "▗", 7: "█",
diff --git a/numpy/testing/tests/test_utils.py b/numpy/testing/tests/test_utils.py
index 31d2cdc76b3e..052cc3aa13d7 100644
--- a/numpy/testing/tests/test_utils.py
+++ b/numpy/testing/tests/test_utils.py
@@ -65,7 +65,7 @@ def test_array_likes(self):
 
 class TestArrayEqual(_GenericTest):
 
-    def setup(self):
+    def setup_method(self):
         self._assert_func = assert_array_equal
 
     def test_generic_rank1(self):
@@ -151,14 +151,13 @@ def test_recarrays(self):
 
         self._test_equal(a, b)
 
-        c = np.empty(2, [('floupipi', float), ('floupa', float)])
+        c = np.empty(2, [('floupipi', float),
+                         ('floupi', float), ('floupa', float)])
         c['floupipi'] = a['floupi'].copy()
         c['floupa'] = a['floupa'].copy()
 
-        with suppress_warnings() as sup:
-            l = sup.record(FutureWarning, message="elementwise == ")
+        with pytest.raises(TypeError):
             self._test_not_equal(c, b)
-            assert_equal(len(l), 1)
 
     def test_masked_nan_inf(self):
         # Regression test for gh-11121
@@ -207,6 +206,51 @@ def __array_function__(self, *args, **kwargs):
         self._test_not_equal(a, b)
         self._test_not_equal(b, a)
 
+    def test_suppress_overflow_warnings(self):
+        # Based on issue #18992
+        with pytest.raises(AssertionError):
+            with np.errstate(all="raise"):
+                np.testing.assert_array_equal(
+                    np.array([1, 2, 3], np.float32),
+                    np.array([1, 1e-40, 3], np.float32))
+
+    def test_array_vs_scalar_is_equal(self):
+        """Test comparing an array with a scalar when all values are equal."""
+        a = np.array([1., 1., 1.])
+        b = 1.
+
+        self._test_equal(a, b)
+
+    def test_array_vs_scalar_not_equal(self):
+        """Test comparing an array with a scalar when not all values equal."""
+        a = np.array([1., 2., 3.])
+        b = 1.
+
+        self._test_not_equal(a, b)
+
+    def test_array_vs_scalar_strict(self):
+        """Test comparing an array with a scalar with strict option."""
+        a = np.array([1., 1., 1.])
+        b = 1.
+
+        with pytest.raises(AssertionError):
+            assert_array_equal(a, b, strict=True)
+
+    def test_array_vs_array_strict(self):
+        """Test comparing two arrays with strict option."""
+        a = np.array([1., 1., 1.])
+        b = np.array([1., 1., 1.])
+
+        assert_array_equal(a, b, strict=True)
+
+    def test_array_vs_float_array_strict(self):
+        """Test comparing two arrays with strict option."""
+        a = np.array([1, 1, 1])
+        b = np.array([1., 1., 1.])
+
+        with pytest.raises(AssertionError):
+            assert_array_equal(a, b, strict=True)
+
 
 class TestBuildErrorMessage:
 
@@ -255,7 +299,7 @@ def test_build_err_msg_custom_precision(self):
 
 class TestEqual(TestArrayEqual):
 
-    def setup(self):
+    def setup_method(self):
         self._assert_func = assert_equal
 
     def test_nan_items(self):
@@ -350,7 +394,7 @@ def test_object(self):
 
 class TestArrayAlmostEqual(_GenericTest):
 
-    def setup(self):
+    def setup_method(self):
         self._assert_func = assert_array_almost_equal
 
     def test_closeness(self):
@@ -448,7 +492,7 @@ def all(self, *args, **kwargs):
 
 class TestAlmostEqual(_GenericTest):
 
-    def setup(self):
+    def setup_method(self):
         self._assert_func = assert_almost_equal
 
     def test_closeness(self):
@@ -599,7 +643,7 @@ def all(self, *args, **kwargs):
 
 class TestApproxEqual:
 
-    def setup(self):
+    def setup_method(self):
         self._assert_func = assert_approx_equal
 
     def test_simple_0d_arrays(self):
@@ -642,7 +686,7 @@ def test_nan_items(self):
 
 class TestArrayAssertLess:
 
-    def setup(self):
+    def setup_method(self):
         self._assert_func = assert_array_less
 
     def test_simple_arrays(self):
@@ -752,7 +796,7 @@ def test_inf_compare_array(self):
 @pytest.mark.skip(reason="The raises decorator depends on Nose")
 class TestRaises:
 
-    def setup(self):
+    def setup_method(self):
         class MyException(Exception):
             pass
 
@@ -909,6 +953,20 @@ def test_timedelta(self):
         a = np.array([[1, 2, 3, "NaT"]], dtype="m8[ns]")
         assert_allclose(a, a)
 
+    def test_error_message_unsigned(self):
+        """Check the the message is formatted correctly when overflow can occur
+           (gh21768)"""
+        # Ensure to test for potential overflow in the case of:
+        #        x - y
+        # and
+        #        y - x
+        x = np.asarray([0, 1, 8], dtype='uint8')
+        y = np.asarray([4, 4, 4], dtype='uint8')
+        with pytest.raises(AssertionError) as exc_info:
+            assert_allclose(x, y, atol=3)
+        msgs = str(exc_info.value).split('\n')
+        assert_equal(msgs[4], 'Max absolute difference: 4')
+
 
 class TestArrayAlmostEqualNulp:
 
@@ -1216,7 +1274,7 @@ def test_regex(self):
                       lambda: assert_string_equal("aaa", "a+b"))
 
 
-def assert_warn_len_equal(mod, n_in_context, py34=None, py37=None):
+def assert_warn_len_equal(mod, n_in_context):
     try:
         mod_warns = mod.__warningregistry__
     except AttributeError:
@@ -1230,26 +1288,15 @@ def assert_warn_len_equal(mod, n_in_context, py34=None, py37=None):
         mod_warns = {}
 
     num_warns = len(mod_warns)
-    # Python 3.4 appears to clear any pre-existing warnings of the same type,
-    # when raising warnings inside a catch_warnings block. So, there is a
-    # warning generated by the tests within the context manager, but no
-    # previous warnings.
+
     if 'version' in mod_warns:
         # Python 3 adds a 'version' entry to the registry,
         # do not count it.
         num_warns -= 1
 
-        # Behavior of warnings is Python version dependent. Adjust the
-        # expected result to compensate. In particular, Python 3.7 does
-        # not make an entry for ignored warnings.
-        if sys.version_info[:2] >= (3, 7):
-            if py37 is not None:
-                n_in_context = py37
-        else:
-            if py34 is not None:
-                n_in_context = py34
     assert_equal(num_warns, n_in_context)
 
+
 def test_warn_len_equal_call_scenarios():
     # assert_warn_len_equal is called under
     # varying circumstances depending on serial
@@ -1298,24 +1345,28 @@ def test_clear_and_catch_warnings():
         warnings.simplefilter('ignore')
         warnings.warn('Some warning')
     assert_equal(my_mod.__warningregistry__, {})
-    # Without specified modules, don't clear warnings during context
-    # Python 3.7 catch_warnings doesn't make an entry for 'ignore'.
+    # Without specified modules, don't clear warnings during context.
+    # catch_warnings doesn't make an entry for 'ignore'.
     with clear_and_catch_warnings():
         warnings.simplefilter('ignore')
         warnings.warn('Some warning')
-    assert_warn_len_equal(my_mod, 1, py37=0)
+    assert_warn_len_equal(my_mod, 0)
+
+    # Manually adding two warnings to the registry:
+    my_mod.__warningregistry__ = {'warning1': 1,
+                                  'warning2': 2}
+
     # Confirm that specifying module keeps old warning, does not add new
     with clear_and_catch_warnings(modules=[my_mod]):
         warnings.simplefilter('ignore')
         warnings.warn('Another warning')
-    assert_warn_len_equal(my_mod, 1, py37=0)
-    # Another warning, no module spec does add to warnings dict, except on
-    # Python 3.4 (see comments in `assert_warn_len_equal`)
-    # Python 3.7 catch_warnings doesn't make an entry for 'ignore'.
+    assert_warn_len_equal(my_mod, 2)
+
+    # Another warning, no module spec it clears up registry
     with clear_and_catch_warnings():
         warnings.simplefilter('ignore')
         warnings.warn('Another warning')
-    assert_warn_len_equal(my_mod, 2, py34=1, py37=0)
+    assert_warn_len_equal(my_mod, 0)
 
 
 def test_suppress_warnings_module():
@@ -1344,7 +1395,7 @@ def warn(arr):
     # got filtered)
     assert_equal(len(sup.log), 1)
     assert_equal(sup.log[0].message.args[0], "Some warning")
-    assert_warn_len_equal(my_mod, 0, py37=0)
+    assert_warn_len_equal(my_mod, 0)
     sup = suppress_warnings()
     # Will have to be changed if apply_along_axis is moved:
     sup.filter(module=my_mod)
@@ -1357,12 +1408,12 @@ def warn(arr):
         warnings.warn('Some warning')
     assert_warn_len_equal(my_mod, 0)
 
-    # Without specified modules, don't clear warnings during context
-    # Python 3.7 does not add ignored warnings.
+    # Without specified modules
     with suppress_warnings():
         warnings.simplefilter('ignore')
         warnings.warn('Some warning')
-    assert_warn_len_equal(my_mod, 1, py37=0)
+    assert_warn_len_equal(my_mod, 0)
+
 
 def test_suppress_warnings_type():
     # Initial state of module, no warnings
@@ -1385,12 +1436,11 @@ def test_suppress_warnings_type():
         warnings.warn('Some warning')
     assert_warn_len_equal(my_mod, 0)
 
-    # Without specified modules, don't clear warnings during context
-    # Python 3.7 does not add ignored warnings.
+    # Without specified modules
     with suppress_warnings():
         warnings.simplefilter('ignore')
         warnings.warn('Some warning')
-    assert_warn_len_equal(my_mod, 1, py37=0)
+    assert_warn_len_equal(my_mod, 0)
 
 
 def test_suppress_warnings_decorate_no_record():
diff --git a/numpy/tests/test_lazyloading.py b/numpy/tests/test_lazyloading.py
new file mode 100644
index 000000000000..f31a4eab79d0
--- /dev/null
+++ b/numpy/tests/test_lazyloading.py
@@ -0,0 +1,38 @@
+import sys
+import importlib
+from importlib.util import LazyLoader, find_spec, module_from_spec
+import pytest
+
+
+# Warning raised by _reload_guard() in numpy/__init__.py
+@pytest.mark.filterwarnings("ignore:The NumPy module was reloaded")
+def test_lazy_load():
+    # gh-22045. lazyload doesn't import submodule names into the namespace
+    # muck with sys.modules to test the importing system
+    old_numpy = sys.modules.pop("numpy")
+
+    numpy_modules = {}
+    for mod_name, mod in list(sys.modules.items()):
+        if mod_name[:6] == "numpy.":
+            numpy_modules[mod_name] = mod
+            sys.modules.pop(mod_name)
+
+    try:
+        # create lazy load of numpy as np
+        spec = find_spec("numpy")
+        module = module_from_spec(spec)
+        sys.modules["numpy"] = module
+        loader = LazyLoader(spec.loader)
+        loader.exec_module(module)
+        np = module
+
+        # test a subpackage import
+        from numpy.lib import recfunctions
+
+        # test triggering the import of the package
+        np.ndarray
+
+    finally:
+        if old_numpy:
+            sys.modules["numpy"] = old_numpy
+            sys.modules.update(numpy_modules)
diff --git a/numpy/tests/test_public_api.py b/numpy/tests/test_public_api.py
index 0754df402d5a..36a21d1c5f73 100644
--- a/numpy/tests/test_public_api.py
+++ b/numpy/tests/test_public_api.py
@@ -9,6 +9,7 @@
 import numpy as np
 import numpy
 import pytest
+from numpy.testing import IS_WASM
 
 try:
     import ctypes
@@ -43,7 +44,7 @@ def test_numpy_namespace():
         'deprecate': 'numpy.lib.utils.deprecate',
         'deprecate_with_doc': 'numpy.lib.utils.deprecate_with_doc',
         'disp': 'numpy.lib.function_base.disp',
-        'fastCopyAndTranspose': 'numpy.core._multiarray_umath._fastCopyAndTranspose',
+        'fastCopyAndTranspose': 'numpy.core._multiarray_umath.fastCopyAndTranspose',
         'get_array_wrap': 'numpy.lib.shape_base.get_array_wrap',
         'get_include': 'numpy.lib.utils.get_include',
         'recfromcsv': 'numpy.lib.npyio.recfromcsv',
@@ -51,6 +52,7 @@ def test_numpy_namespace():
         'safe_eval': 'numpy.lib.utils.safe_eval',
         'set_string_function': 'numpy.core.arrayprint.set_string_function',
         'show_config': 'numpy.__config__.show',
+        'show_runtime': 'numpy.lib.utils.show_runtime',
         'who': 'numpy.lib.utils.who',
     }
     # We override dir to not show these members
@@ -61,6 +63,7 @@ def test_numpy_namespace():
     assert bad_results == allowlist
 
 
+@pytest.mark.skipif(IS_WASM, reason="can't start subprocess")
 @pytest.mark.parametrize('name', ['testing', 'Tester'])
 def test_import_lazy_import(name):
     """Make sure we can actually use the modules we lazy load.
@@ -189,6 +192,7 @@ def test_NPY_NO_EXPORT():
     "core.shape_base",
     "core.umath",
     "core.umath_tests",
+    "distutils.armccompiler",
     "distutils.ccompiler",
     'distutils.ccompiler_opt',
     "distutils.command",
@@ -214,6 +218,7 @@ def test_NPY_NO_EXPORT():
     "distutils.extension",
     "distutils.fcompiler",
     "distutils.fcompiler.absoft",
+    "distutils.fcompiler.arm",
     "distutils.fcompiler.compaq",
     "distutils.fcompiler.environment",
     "distutils.fcompiler.g95",
@@ -250,7 +255,6 @@ def test_NPY_NO_EXPORT():
     "f2py.crackfortran",
     "f2py.diagnose",
     "f2py.f2py2e",
-    "f2py.f2py_testing",
     "f2py.f90mod_rules",
     "f2py.func2subr",
     "f2py.rules",
@@ -315,6 +319,7 @@ def is_unexpected(name):
     "numpy.core.code_generators.generate_numpy_api",
     "numpy.core.code_generators.generate_ufunc_api",
     "numpy.core.code_generators.numpy_api",
+    "numpy.core.code_generators.generate_umath_doc",
     "numpy.core.cversions",
     "numpy.core.generate_numpy_api",
     "numpy.distutils.msvc9compiler",
@@ -346,6 +351,8 @@ def test_all_modules_are_expected():
 SKIP_LIST_2 = [
     'numpy.math',
     'numpy.distutils.log.sys',
+    'numpy.distutils.log.logging',
+    'numpy.distutils.log.warnings',
     'numpy.doc.constants.re',
     'numpy.doc.constants.textwrap',
     'numpy.lib.emath',
diff --git a/numpy/tests/test_reloading.py b/numpy/tests/test_reloading.py
index 8d8c8aa34be8..a1f360089a54 100644
--- a/numpy/tests/test_reloading.py
+++ b/numpy/tests/test_reloading.py
@@ -1,6 +1,13 @@
-from numpy.testing import assert_raises, assert_warns, assert_, assert_equal
+from numpy.testing import (
+    assert_raises,
+    assert_warns,
+    assert_,
+    assert_equal,
+    IS_WASM,
+)
 from numpy.compat import pickle
 
+import pytest
 import sys
 import subprocess
 import textwrap
@@ -37,6 +44,7 @@ def test_novalue():
                                           protocol=proto)) is np._NoValue)
 
 
+@pytest.mark.skipif(IS_WASM, reason="can't start subprocess")
 def test_full_reimport():
     """At the time of writing this, it is *not* truly supported, but
     apparently enough users rely on it, for it to be an annoying change
diff --git a/numpy/tests/test_scripts.py b/numpy/tests/test_scripts.py
index e67a829471dc..892c04eef0be 100644
--- a/numpy/tests/test_scripts.py
+++ b/numpy/tests/test_scripts.py
@@ -9,7 +9,7 @@
 import subprocess
 
 import numpy as np
-from numpy.testing import assert_equal
+from numpy.testing import assert_equal, IS_WASM
 
 is_inplace = isfile(pathjoin(dirname(np.__file__),  '..', 'setup.py'))
 
@@ -24,8 +24,8 @@ def find_f2py_commands():
     else:
         # Three scripts are installed in Unix-like systems:
         # 'f2py', 'f2py{major}', and 'f2py{major.minor}'. For example,
-        # if installed with python3.7 the scripts would be named
-        # 'f2py', 'f2py3', and 'f2py3.7'.
+        # if installed with python3.9 the scripts would be named
+        # 'f2py', 'f2py3', and 'f2py3.9'.
         version = sys.version_info
         major = str(version.major)
         minor = str(version.minor)
@@ -41,6 +41,7 @@ def test_f2py(f2py_cmd):
     assert_equal(stdout.strip(), np.__version__.encode('ascii'))
 
 
+@pytest.mark.skipif(IS_WASM, reason="Cannot start subprocess")
 def test_pep338():
     stdout = subprocess.check_output([sys.executable, '-mnumpy.f2py', '-v'])
     assert_equal(stdout.strip(), np.__version__.encode('ascii'))
diff --git a/numpy/typing/__init__.py b/numpy/typing/__init__.py
index d5cfbf5acc45..5cf02fe868b0 100644
--- a/numpy/typing/__init__.py
+++ b/numpy/typing/__init__.py
@@ -5,7 +5,7 @@
 
 .. versionadded:: 1.20
 
-Large parts of the NumPy API have PEP-484-style type annotations. In
+Large parts of the NumPy API have :pep:`484`-style type annotations. In
 addition a number of type aliases are available to users, most prominently
 the two below:
 
@@ -155,236 +155,17 @@
 # NOTE: The API section will be appended with additional entries
 # further down in this file
 
-from __future__ import annotations
-
-from numpy import ufunc
-from typing import TYPE_CHECKING, final
-
-if not TYPE_CHECKING:
-    __all__ = ["ArrayLike", "DTypeLike", "NBitBase", "NDArray"]
-else:
-    # Ensure that all objects within this module are accessible while
-    # static type checking. This includes private ones, as we need them
-    # for internal use.
-    #
-    # Declare to mypy that `__all__` is a list of strings without assigning
-    # an explicit value
-    __all__: list[str]
-    __path__: list[str]
-
-
-@final  # Disallow the creation of arbitrary `NBitBase` subclasses
-class NBitBase:
-    """
-    A type representing `numpy.number` precision during static type checking.
-
-    Used exclusively for the purpose static type checking, `NBitBase`
-    represents the base of a hierarchical set of subclasses.
-    Each subsequent subclass is herein used for representing a lower level
-    of precision, *e.g.* ``64Bit > 32Bit > 16Bit``.
-
-    .. versionadded:: 1.20
-
-    Examples
-    --------
-    Below is a typical usage example: `NBitBase` is herein used for annotating
-    a function that takes a float and integer of arbitrary precision
-    as arguments and returns a new float of whichever precision is largest
-    (*e.g.* ``np.float16 + np.int64 -> np.float64``).
-
-    .. code-block:: python
-
-        >>> from __future__ import annotations
-        >>> from typing import TypeVar, TYPE_CHECKING
-        >>> import numpy as np
-        >>> import numpy.typing as npt
-
-        >>> T1 = TypeVar("T1", bound=npt.NBitBase)
-        >>> T2 = TypeVar("T2", bound=npt.NBitBase)
-
-        >>> def add(a: np.floating[T1], b: np.integer[T2]) -> np.floating[T1 | T2]:
-        ...     return a + b
-
-        >>> a = np.float16()
-        >>> b = np.int64()
-        >>> out = add(a, b)
-
-        >>> if TYPE_CHECKING:
-        ...     reveal_locals()
-        ...     # note: Revealed local types are:
-        ...     # note:     a: numpy.floating[numpy.typing._16Bit*]
-        ...     # note:     b: numpy.signedinteger[numpy.typing._64Bit*]
-        ...     # note:     out: numpy.floating[numpy.typing._64Bit*]
-
-    """
-
-    def __init_subclass__(cls) -> None:
-        allowed_names = {
-            "NBitBase", "_256Bit", "_128Bit", "_96Bit", "_80Bit",
-            "_64Bit", "_32Bit", "_16Bit", "_8Bit",
-        }
-        if cls.__name__ not in allowed_names:
-            raise TypeError('cannot inherit from final class "NBitBase"')
-        super().__init_subclass__()
-
-
-# Silence errors about subclassing a `@final`-decorated class
-class _256Bit(NBitBase):  # type: ignore[misc]
-    pass
-
-class _128Bit(_256Bit):  # type: ignore[misc]
-    pass
-
-class _96Bit(_128Bit):  # type: ignore[misc]
-    pass
-
-class _80Bit(_96Bit):  # type: ignore[misc]
-    pass
-
-class _64Bit(_80Bit):  # type: ignore[misc]
-    pass
-
-class _32Bit(_64Bit):  # type: ignore[misc]
-    pass
-
-class _16Bit(_32Bit):  # type: ignore[misc]
-    pass
-
-class _8Bit(_16Bit):  # type: ignore[misc]
-    pass
-
-
-from ._nested_sequence import _NestedSequence
-from ._nbit import (
-    _NBitByte,
-    _NBitShort,
-    _NBitIntC,
-    _NBitIntP,
-    _NBitInt,
-    _NBitLongLong,
-    _NBitHalf,
-    _NBitSingle,
-    _NBitDouble,
-    _NBitLongDouble,
-)
-from ._char_codes import (
-    _BoolCodes,
-    _UInt8Codes,
-    _UInt16Codes,
-    _UInt32Codes,
-    _UInt64Codes,
-    _Int8Codes,
-    _Int16Codes,
-    _Int32Codes,
-    _Int64Codes,
-    _Float16Codes,
-    _Float32Codes,
-    _Float64Codes,
-    _Complex64Codes,
-    _Complex128Codes,
-    _ByteCodes,
-    _ShortCodes,
-    _IntCCodes,
-    _IntPCodes,
-    _IntCodes,
-    _LongLongCodes,
-    _UByteCodes,
-    _UShortCodes,
-    _UIntCCodes,
-    _UIntPCodes,
-    _UIntCodes,
-    _ULongLongCodes,
-    _HalfCodes,
-    _SingleCodes,
-    _DoubleCodes,
-    _LongDoubleCodes,
-    _CSingleCodes,
-    _CDoubleCodes,
-    _CLongDoubleCodes,
-    _DT64Codes,
-    _TD64Codes,
-    _StrCodes,
-    _BytesCodes,
-    _VoidCodes,
-    _ObjectCodes,
-)
-from ._scalars import (
-    _CharLike_co,
-    _BoolLike_co,
-    _UIntLike_co,
-    _IntLike_co,
-    _FloatLike_co,
-    _ComplexLike_co,
-    _TD64Like_co,
-    _NumberLike_co,
-    _ScalarLike_co,
-    _VoidLike_co,
-)
-from ._shape import _Shape, _ShapeLike
-from ._dtype_like import (
-    DTypeLike as DTypeLike,
-    _SupportsDType,
-    _VoidDTypeLike,
-    _DTypeLikeBool,
-    _DTypeLikeUInt,
-    _DTypeLikeInt,
-    _DTypeLikeFloat,
-    _DTypeLikeComplex,
-    _DTypeLikeTD64,
-    _DTypeLikeDT64,
-    _DTypeLikeObject,
-    _DTypeLikeVoid,
-    _DTypeLikeStr,
-    _DTypeLikeBytes,
-    _DTypeLikeComplex_co,
-)
-from ._array_like import (
-    ArrayLike as ArrayLike,
-    _ArrayLike,
-    _FiniteNestedSequence,
-    _SupportsArray,
-    _ArrayLikeInt,
-    _ArrayLikeBool_co,
-    _ArrayLikeUInt_co,
-    _ArrayLikeInt_co,
-    _ArrayLikeFloat_co,
-    _ArrayLikeComplex_co,
-    _ArrayLikeNumber_co,
-    _ArrayLikeTD64_co,
-    _ArrayLikeDT64_co,
-    _ArrayLikeObject_co,
-    _ArrayLikeVoid_co,
-    _ArrayLikeStr_co,
-    _ArrayLikeBytes_co,
-)
-from ._generic_alias import (
-    NDArray as NDArray,
-    _DType,
-    _GenericAlias,
+from numpy._typing import (
+    ArrayLike,
+    DTypeLike,
+    NBitBase,
+    NDArray,
 )
 
-if TYPE_CHECKING:
-    from ._ufunc import (
-        _UFunc_Nin1_Nout1,
-        _UFunc_Nin2_Nout1,
-        _UFunc_Nin1_Nout2,
-        _UFunc_Nin2_Nout2,
-        _GUFunc_Nin2_Nout1,
-    )
-else:
-    # Declare the (type-check-only) ufunc subclasses as ufunc aliases during
-    # runtime; this helps autocompletion tools such as Jedi (numpy/numpy#19834)
-    _UFunc_Nin1_Nout1 = ufunc
-    _UFunc_Nin2_Nout1 = ufunc
-    _UFunc_Nin1_Nout2 = ufunc
-    _UFunc_Nin2_Nout2 = ufunc
-    _GUFunc_Nin2_Nout1 = ufunc
-
-# Clean up the namespace
-del TYPE_CHECKING, final, ufunc
+__all__ = ["ArrayLike", "DTypeLike", "NBitBase", "NDArray"]
 
 if __doc__ is not None:
-    from ._add_docstring import _docstrings
+    from numpy._typing._add_docstring import _docstrings
     __doc__ += _docstrings
     __doc__ += '\n.. autoclass:: numpy.typing.NBitBase\n'
     del _docstrings
diff --git a/numpy/typing/mypy_plugin.py b/numpy/typing/mypy_plugin.py
index 5ac75f94da93..1ffe74fa97b1 100644
--- a/numpy/typing/mypy_plugin.py
+++ b/numpy/typing/mypy_plugin.py
@@ -70,7 +70,7 @@ def _get_precision_dict() -> dict[str, str]:
     ret = {}
     for name, typ in names:
         n: int = 8 * typ().dtype.itemsize
-        ret[f'numpy.typing._nbit.{name}'] = f"numpy._{n}Bit"
+        ret[f'numpy._typing._nbit.{name}'] = f"numpy._{n}Bit"
     return ret
 
 
@@ -106,7 +106,7 @@ def _get_c_intp_name() -> str:
         return "c_long"
 
 
-#: A dictionary mapping type-aliases in `numpy.typing._nbit` to
+#: A dictionary mapping type-aliases in `numpy._typing._nbit` to
 #: concrete `numpy.typing.NBitBase` subclasses.
 _PRECISION_DICT: Final = _get_precision_dict()
 
@@ -121,7 +121,7 @@ def _hook(ctx: AnalyzeTypeContext) -> Type:
     """Replace a type-alias with a concrete ``NBitBase`` subclass."""
     typ, _, api = ctx
     name = typ.name.split(".")[-1]
-    name_new = _PRECISION_DICT[f"numpy.typing._nbit.{name}"]
+    name_new = _PRECISION_DICT[f"numpy._typing._nbit.{name}"]
     return api.named_type(name_new)
 
 
@@ -177,7 +177,7 @@ def get_additional_deps(
 
             if file.fullname == "numpy":
                 _override_imports(
-                    file, "numpy.typing._extended_precision",
+                    file, "numpy._typing._extended_precision",
                     imports=[(v, v) for v in _EXTENDED_PRECISION_LIST],
                 )
             elif file.fullname == "numpy.ctypeslib":
diff --git a/numpy/typing/setup.py b/numpy/typing/setup.py
index 694a756dc5ab..c444e769fb6d 100644
--- a/numpy/typing/setup.py
+++ b/numpy/typing/setup.py
@@ -3,7 +3,6 @@ def configuration(parent_package='', top_path=None):
     config = Configuration('typing', parent_package, top_path)
     config.add_subpackage('tests')
     config.add_data_dir('tests/data')
-    config.add_data_files('*.pyi')
     return config
 
 
diff --git a/numpy/typing/tests/data/fail/arithmetic.pyi b/numpy/typing/tests/data/fail/arithmetic.pyi
index b99b24c1f6b4..3bbc101cfd23 100644
--- a/numpy/typing/tests/data/fail/arithmetic.pyi
+++ b/numpy/typing/tests/data/fail/arithmetic.pyi
@@ -1,4 +1,4 @@
-from typing import List, Any
+from typing import Any
 import numpy as np
 
 b_ = np.bool_()
@@ -15,13 +15,13 @@ AR_M: np.ndarray[Any, np.dtype[np.datetime64]]
 
 ANY: Any
 
-AR_LIKE_b: List[bool]
-AR_LIKE_u: List[np.uint32]
-AR_LIKE_i: List[int]
-AR_LIKE_f: List[float]
-AR_LIKE_c: List[complex]
-AR_LIKE_m: List[np.timedelta64]
-AR_LIKE_M: List[np.datetime64]
+AR_LIKE_b: list[bool]
+AR_LIKE_u: list[np.uint32]
+AR_LIKE_i: list[int]
+AR_LIKE_f: list[float]
+AR_LIKE_c: list[complex]
+AR_LIKE_m: list[np.timedelta64]
+AR_LIKE_M: list[np.datetime64]
 
 # Array subtraction
 
diff --git a/numpy/typing/tests/data/fail/array_constructors.pyi b/numpy/typing/tests/data/fail/array_constructors.pyi
index 4f0a60b5ba93..278894631f93 100644
--- a/numpy/typing/tests/data/fail/array_constructors.pyi
+++ b/numpy/typing/tests/data/fail/array_constructors.pyi
@@ -21,11 +21,13 @@ np.linspace(0, 2, retstep=b'False')  # E: No overload variant
 np.linspace(0, 2, dtype=0)  # E: No overload variant
 np.linspace(0, 2, axis=None)  # E: No overload variant
 
-np.logspace(None, 'bob')  # E: Argument 1
-np.logspace(0, 2, base=None)  # E: Argument "base"
+np.logspace(None, 'bob')  # E: No overload variant
+np.logspace(0, 2, base=None)  # E: No overload variant
 
-np.geomspace(None, 'bob')  # E: Argument 1
+np.geomspace(None, 'bob')  # E: No overload variant
 
 np.stack(generator)  # E: No overload variant
 np.hstack({1, 2})  # E: No overload variant
 np.vstack(1)  # E: No overload variant
+
+np.array([1], like=1)  # E: No overload variant
diff --git a/numpy/typing/tests/data/fail/array_like.pyi b/numpy/typing/tests/data/fail/array_like.pyi
index 3bbd2906150f..133b5fd49700 100644
--- a/numpy/typing/tests/data/fail/array_like.pyi
+++ b/numpy/typing/tests/data/fail/array_like.pyi
@@ -1,5 +1,5 @@
 import numpy as np
-from numpy.typing import ArrayLike
+from numpy._typing import ArrayLike
 
 
 class A:
diff --git a/numpy/typing/tests/data/fail/arrayprint.pyi b/numpy/typing/tests/data/fail/arrayprint.pyi
index 86297a0b24a4..71b921e3a5a3 100644
--- a/numpy/typing/tests/data/fail/arrayprint.pyi
+++ b/numpy/typing/tests/data/fail/arrayprint.pyi
@@ -1,4 +1,5 @@
-from typing import Callable, Any
+from collections.abc import Callable
+from typing import Any
 import numpy as np
 
 AR: np.ndarray
diff --git a/numpy/typing/tests/data/fail/einsumfunc.pyi b/numpy/typing/tests/data/fail/einsumfunc.pyi
index 33722f861199..f0e3f1e95711 100644
--- a/numpy/typing/tests/data/fail/einsumfunc.pyi
+++ b/numpy/typing/tests/data/fail/einsumfunc.pyi
@@ -1,4 +1,4 @@
-from typing import List, Any
+from typing import Any
 import numpy as np
 
 AR_i: np.ndarray[Any, np.dtype[np.int64]]
diff --git a/numpy/typing/tests/data/fail/false_positives.pyi b/numpy/typing/tests/data/fail/false_positives.pyi
new file mode 100644
index 000000000000..7e79230663c2
--- /dev/null
+++ b/numpy/typing/tests/data/fail/false_positives.pyi
@@ -0,0 +1,11 @@
+import numpy as np
+import numpy.typing as npt
+
+AR_f8: npt.NDArray[np.float64]
+
+# NOTE: Mypy bug presumably due to the special-casing of heterogeneous tuples;
+# xref numpy/numpy#20901
+#
+# The expected output should be no different than, e.g., when using a
+# list instead of a tuple
+np.concatenate(([1], AR_f8))  # E: Argument 1 to "concatenate" has incompatible type
diff --git a/numpy/typing/tests/data/fail/flatiter.pyi b/numpy/typing/tests/data/fail/flatiter.pyi
index 544ffbe4a7db..b4ce10ba566d 100644
--- a/numpy/typing/tests/data/fail/flatiter.pyi
+++ b/numpy/typing/tests/data/fail/flatiter.pyi
@@ -1,7 +1,7 @@
 from typing import Any
 
 import numpy as np
-from numpy.typing import _SupportsArray
+from numpy._typing import _SupportsArray
 
 
 class Index:
diff --git a/numpy/typing/tests/data/fail/fromnumeric.pyi b/numpy/typing/tests/data/fail/fromnumeric.pyi
index 8fafed1b7705..b679703c7dd6 100644
--- a/numpy/typing/tests/data/fail/fromnumeric.pyi
+++ b/numpy/typing/tests/data/fail/fromnumeric.pyi
@@ -1,38 +1,40 @@
 """Tests for :mod:`numpy.core.fromnumeric`."""
 
 import numpy as np
+import numpy.typing as npt
 
 A = np.array(True, ndmin=2, dtype=bool)
 A.setflags(write=False)
+AR_U: npt.NDArray[np.str_]
 
 a = np.bool_(True)
 
-np.take(a, None)  # E: incompatible type
-np.take(a, axis=1.0)  # E: incompatible type
-np.take(A, out=1)  # E: incompatible type
-np.take(A, mode="bob")  # E: incompatible type
+np.take(a, None)  # E: No overload variant
+np.take(a, axis=1.0)  # E: No overload variant
+np.take(A, out=1)  # E: No overload variant
+np.take(A, mode="bob")  # E: No overload variant
 
-np.reshape(a, None)  # E: Argument 2 to "reshape" has incompatible type
-np.reshape(A, 1, order="bob")  # E: Argument "order" to "reshape" has incompatible type
+np.reshape(a, None)  # E: No overload variant
+np.reshape(A, 1, order="bob")  # E: No overload variant
 
-np.choose(a, None)  # E: incompatible type
-np.choose(a, out=1.0)  # E: incompatible type
-np.choose(A, mode="bob")  # E: incompatible type
+np.choose(a, None)  # E: No overload variant
+np.choose(a, out=1.0)  # E: No overload variant
+np.choose(A, mode="bob")  # E: No overload variant
 
-np.repeat(a, None)  # E: Argument 2 to "repeat" has incompatible type
-np.repeat(A, 1, axis=1.0)  # E: Argument "axis" to "repeat" has incompatible type
+np.repeat(a, None)  # E: No overload variant
+np.repeat(A, 1, axis=1.0)  # E: No overload variant
 
-np.swapaxes(A, None, 1)  # E: Argument 2 to "swapaxes" has incompatible type
-np.swapaxes(A, 1, [0])  # E: Argument 3 to "swapaxes" has incompatible type
+np.swapaxes(A, None, 1)  # E: No overload variant
+np.swapaxes(A, 1, [0])  # E: No overload variant
 
-np.transpose(A, axes=1.0)  # E: Argument "axes" to "transpose" has incompatible type
+np.transpose(A, axes=1.0)  # E: No overload variant
 
-np.partition(a, None)  # E: Argument 2 to "partition" has incompatible type
-np.partition(
-    a, 0, axis="bob"  # E: Argument "axis" to "partition" has incompatible type
+np.partition(a, None)  # E: No overload variant
+np.partition(  # E: No overload variant
+    a, 0, axis="bob"
 )
-np.partition(
-    A, 0, kind="bob"  # E: Argument "kind" to "partition" has incompatible type
+np.partition(  # E: No overload variant
+    A, 0, kind="bob"
 )
 np.partition(
     A, 0, order=range(5)  # E: Argument "order" to "partition" has incompatible type
@@ -51,8 +53,8 @@ np.argpartition(
     A, 0, order=range(5)  # E: Argument "order" to "argpartition" has incompatible type
 )
 
-np.sort(A, axis="bob")  # E: Argument "axis" to "sort" has incompatible type
-np.sort(A, kind="bob")  # E: Argument "kind" to "sort" has incompatible type
+np.sort(A, axis="bob")  # E: No overload variant
+np.sort(A, kind="bob")  # E: No overload variant
 np.sort(A, order=range(5))  # E: Argument "order" to "sort" has incompatible type
 
 np.argsort(A, axis="bob")  # E: Argument "axis" to "argsort" has incompatible type
@@ -72,30 +74,29 @@ np.searchsorted(  # E: No overload variant of "searchsorted" matches argument ty
     A[0], 0, sorter=1.0
 )
 
-np.resize(A, 1.0)  # E: Argument 2 to "resize" has incompatible type
+np.resize(A, 1.0)  # E: No overload variant
 
 np.squeeze(A, 1.0)  # E: No overload variant of "squeeze" matches argument type
 
-np.diagonal(A, offset=None)  # E: Argument "offset" to "diagonal" has incompatible type
-np.diagonal(A, axis1="bob")  # E: Argument "axis1" to "diagonal" has incompatible type
-np.diagonal(A, axis2=[])  # E: Argument "axis2" to "diagonal" has incompatible type
+np.diagonal(A, offset=None)  # E: No overload variant
+np.diagonal(A, axis1="bob")  # E: No overload variant
+np.diagonal(A, axis2=[])  # E: No overload variant
 
-np.trace(A, offset=None)  # E: Argument "offset" to "trace" has incompatible type
-np.trace(A, axis1="bob")  # E: Argument "axis1" to "trace" has incompatible type
-np.trace(A, axis2=[])  # E: Argument "axis2" to "trace" has incompatible type
+np.trace(A, offset=None)  # E: No overload variant
+np.trace(A, axis1="bob")  # E: No overload variant
+np.trace(A, axis2=[])  # E: No overload variant
 
-np.ravel(a, order="bob")  # E: Argument "order" to "ravel" has incompatible type
+np.ravel(a, order="bob")  # E: No overload variant
 
-np.compress(
-    [True], A, axis=1.0  # E: Argument "axis" to "compress" has incompatible type
+np.compress(  # E: No overload variant
+    [True], A, axis=1.0
 )
 
 np.clip(a, 1, 2, out=1)  # E: No overload variant of "clip" matches argument type
-np.clip(1, None, None)  # E: No overload variant of "clip" matches argument type
 
-np.sum(a, axis=1.0)  # E: incompatible type
-np.sum(a, keepdims=1.0)  # E: incompatible type
-np.sum(a, initial=[1])  # E: incompatible type
+np.sum(a, axis=1.0)  # E: No overload variant
+np.sum(a, keepdims=1.0)  # E: No overload variant
+np.sum(a, initial=[1])  # E: No overload variant
 
 np.all(a, axis=1.0)  # E: No overload variant
 np.all(a, keepdims=1.0)  # E: No overload variant
@@ -105,50 +106,56 @@ np.any(a, axis=1.0)  # E: No overload variant
 np.any(a, keepdims=1.0)  # E: No overload variant
 np.any(a, out=1.0)  # E: No overload variant
 
-np.cumsum(a, axis=1.0)  # E: incompatible type
-np.cumsum(a, dtype=1.0)  # E: incompatible type
-np.cumsum(a, out=1.0)  # E: incompatible type
+np.cumsum(a, axis=1.0)  # E: No overload variant
+np.cumsum(a, dtype=1.0)  # E: No overload variant
+np.cumsum(a, out=1.0)  # E: No overload variant
 
-np.ptp(a, axis=1.0)  # E: incompatible type
-np.ptp(a, keepdims=1.0)  # E: incompatible type
-np.ptp(a, out=1.0)  # E: incompatible type
+np.ptp(a, axis=1.0)  # E: No overload variant
+np.ptp(a, keepdims=1.0)  # E: No overload variant
+np.ptp(a, out=1.0)  # E: No overload variant
 
-np.amax(a, axis=1.0)  # E: incompatible type
-np.amax(a, keepdims=1.0)  # E: incompatible type
-np.amax(a, out=1.0)  # E: incompatible type
-np.amax(a, initial=[1.0])  # E: incompatible type
+np.amax(a, axis=1.0)  # E: No overload variant
+np.amax(a, keepdims=1.0)  # E: No overload variant
+np.amax(a, out=1.0)  # E: No overload variant
+np.amax(a, initial=[1.0])  # E: No overload variant
 np.amax(a, where=[1.0])  # E: incompatible type
 
-np.amin(a, axis=1.0)  # E: incompatible type
-np.amin(a, keepdims=1.0)  # E: incompatible type
-np.amin(a, out=1.0)  # E: incompatible type
-np.amin(a, initial=[1.0])  # E: incompatible type
+np.amin(a, axis=1.0)  # E: No overload variant
+np.amin(a, keepdims=1.0)  # E: No overload variant
+np.amin(a, out=1.0)  # E: No overload variant
+np.amin(a, initial=[1.0])  # E: No overload variant
 np.amin(a, where=[1.0])  # E: incompatible type
 
-np.prod(a, axis=1.0)  # E: incompatible type
-np.prod(a, out=False)  # E: incompatible type
-np.prod(a, keepdims=1.0)  # E: incompatible type
-np.prod(a, initial=int)  # E: incompatible type
-np.prod(a, where=1.0)  # E: incompatible type
+np.prod(a, axis=1.0)  # E: No overload variant
+np.prod(a, out=False)  # E: No overload variant
+np.prod(a, keepdims=1.0)  # E: No overload variant
+np.prod(a, initial=int)  # E: No overload variant
+np.prod(a, where=1.0)  # E: No overload variant
+np.prod(AR_U)  # E: incompatible type
 
-np.cumprod(a, axis=1.0)  # E: Argument "axis" to "cumprod" has incompatible type
-np.cumprod(a, out=False)  # E: Argument "out" to "cumprod" has incompatible type
+np.cumprod(a, axis=1.0)  # E: No overload variant
+np.cumprod(a, out=False)  # E: No overload variant
+np.cumprod(AR_U)  # E: incompatible type
 
 np.size(a, axis=1.0)  # E: Argument "axis" to "size" has incompatible type
 
-np.around(a, decimals=1.0)  # E: incompatible type
-np.around(a, out=type)  # E: incompatible type
-
-np.mean(a, axis=1.0)  # E: incompatible type
-np.mean(a, out=False)  # E: incompatible type
-np.mean(a, keepdims=1.0)  # E: incompatible type
-
-np.std(a, axis=1.0)  # E: incompatible type
-np.std(a, out=False)  # E: incompatible type
-np.std(a, ddof='test')  # E: incompatible type
-np.std(a, keepdims=1.0)  # E: incompatible type
-
-np.var(a, axis=1.0)  # E: incompatible type
-np.var(a, out=False)  # E: incompatible type
-np.var(a, ddof='test')  # E: incompatible type
-np.var(a, keepdims=1.0)  # E: incompatible type
+np.around(a, decimals=1.0)  # E: No overload variant
+np.around(a, out=type)  # E: No overload variant
+np.around(AR_U)  # E: incompatible type
+
+np.mean(a, axis=1.0)  # E: No overload variant
+np.mean(a, out=False)  # E: No overload variant
+np.mean(a, keepdims=1.0)  # E: No overload variant
+np.mean(AR_U)  # E: incompatible type
+
+np.std(a, axis=1.0)  # E: No overload variant
+np.std(a, out=False)  # E: No overload variant
+np.std(a, ddof='test')  # E: No overload variant
+np.std(a, keepdims=1.0)  # E: No overload variant
+np.std(AR_U)  # E: incompatible type
+
+np.var(a, axis=1.0)  # E: No overload variant
+np.var(a, out=False)  # E: No overload variant
+np.var(a, ddof='test')  # E: No overload variant
+np.var(a, keepdims=1.0)  # E: No overload variant
+np.var(AR_U)  # E: incompatible type
diff --git a/numpy/typing/tests/data/fail/histograms.pyi b/numpy/typing/tests/data/fail/histograms.pyi
index ad151488dd2e..22499d39175a 100644
--- a/numpy/typing/tests/data/fail/histograms.pyi
+++ b/numpy/typing/tests/data/fail/histograms.pyi
@@ -7,7 +7,6 @@ AR_f8: npt.NDArray[np.float64]
 np.histogram_bin_edges(AR_i8, range=(0, 1, 2))  # E: incompatible type
 
 np.histogram(AR_i8, range=(0, 1, 2))  # E: incompatible type
-np.histogram(AR_i8, normed=True)  # E: incompatible type
 
 np.histogramdd(AR_i8, range=(0, 1))  # E: incompatible type
 np.histogramdd(AR_i8, range=[(0, 1, 2)])  # E: incompatible type
diff --git a/numpy/typing/tests/data/fail/index_tricks.pyi b/numpy/typing/tests/data/fail/index_tricks.pyi
index c508bf3aeae6..22f6f4a61e8e 100644
--- a/numpy/typing/tests/data/fail/index_tricks.pyi
+++ b/numpy/typing/tests/data/fail/index_tricks.pyi
@@ -1,9 +1,9 @@
-from typing import List
 import numpy as np
 
-AR_LIKE_i: List[int]
-AR_LIKE_f: List[float]
+AR_LIKE_i: list[int]
+AR_LIKE_f: list[float]
 
+np.ndindex([1, 2, 3])  # E: No overload variant
 np.unravel_index(AR_LIKE_f, (1, 2, 3))  # E: incompatible type
 np.ravel_multi_index(AR_LIKE_i, (1, 2, 3), mode="bob")  # E: No overload variant
 np.mgrid[1]  # E: Invalid index type
diff --git a/numpy/typing/tests/data/fail/multiarray.pyi b/numpy/typing/tests/data/fail/multiarray.pyi
index 22bcf8c92c90..425ec3d0fb4f 100644
--- a/numpy/typing/tests/data/fail/multiarray.pyi
+++ b/numpy/typing/tests/data/fail/multiarray.pyi
@@ -1,4 +1,3 @@
-from typing import List
 import numpy as np
 import numpy.typing as npt
 
@@ -12,7 +11,7 @@ AR_M: npt.NDArray[np.datetime64]
 
 M: np.datetime64
 
-AR_LIKE_f: List[float]
+AR_LIKE_f: list[float]
 
 def func(a: int) -> None: ...
 
@@ -40,7 +39,7 @@ np.arange(stop=10)  # E: No overload variant
 
 np.datetime_data(int)  # E: incompatible type
 
-np.busday_offset("2012", 10)  # E: incompatible type
+np.busday_offset("2012", 10)  # E: No overload variant
 
 np.datetime_as_string("2012")  # E: No overload variant
 
diff --git a/numpy/typing/tests/data/fail/ndarray_misc.pyi b/numpy/typing/tests/data/fail/ndarray_misc.pyi
index 8320a44f3caa..77bd9a44e890 100644
--- a/numpy/typing/tests/data/fail/ndarray_misc.pyi
+++ b/numpy/typing/tests/data/fail/ndarray_misc.pyi
@@ -39,3 +39,5 @@ AR_b.__index__()  # E: Invalid self argument
 AR_f8[1.5]  # E: No overload variant
 AR_f8["field_a"]  # E: No overload variant
 AR_f8[["field_a", "field_b"]]  # E: Invalid index type
+
+AR_f8.__array_finalize__(object())  # E: incompatible type
diff --git a/numpy/typing/tests/data/fail/nested_sequence.pyi b/numpy/typing/tests/data/fail/nested_sequence.pyi
index e28661a058e9..6301e51769fe 100644
--- a/numpy/typing/tests/data/fail/nested_sequence.pyi
+++ b/numpy/typing/tests/data/fail/nested_sequence.pyi
@@ -1,13 +1,13 @@
-from typing import Sequence, Tuple, List
-import numpy.typing as npt
+from collections.abc import Sequence
+from numpy._typing import _NestedSequence
 
 a: Sequence[float]
-b: List[complex]
-c: Tuple[str, ...]
+b: list[complex]
+c: tuple[str, ...]
 d: int
 e: str
 
-def func(a: npt._NestedSequence[int]) -> None:
+def func(a: _NestedSequence[int]) -> None:
     ...
 
 reveal_type(func(a))  # E: incompatible type
diff --git a/numpy/typing/tests/data/fail/random.pyi b/numpy/typing/tests/data/fail/random.pyi
index c4d1e3e3e802..f0e682019281 100644
--- a/numpy/typing/tests/data/fail/random.pyi
+++ b/numpy/typing/tests/data/fail/random.pyi
@@ -1,9 +1,9 @@
 import numpy as np
-from typing import Any, List
+from typing import Any
 
 SEED_FLOAT: float = 457.3
 SEED_ARR_FLOAT: np.ndarray[Any, np.dtype[np.float64]] = np.array([1.0, 2, 3, 4])
-SEED_ARRLIKE_FLOAT: List[float] = [1.0, 2.0, 3.0, 4.0]
+SEED_ARRLIKE_FLOAT: list[float] = [1.0, 2.0, 3.0, 4.0]
 SEED_SEED_SEQ: np.random.SeedSequence = np.random.SeedSequence(0)
 SEED_STR: str = "String seeding not allowed"
 # default rng
diff --git a/numpy/typing/tests/data/fail/scalars.pyi b/numpy/typing/tests/data/fail/scalars.pyi
index 94fe3f71e646..2a6c2c7addfc 100644
--- a/numpy/typing/tests/data/fail/scalars.pyi
+++ b/numpy/typing/tests/data/fail/scalars.pyi
@@ -31,7 +31,7 @@ np.complex64([])  # E: incompatible type
 np.complex64(1, 2)  # E: Too many arguments
 # TODO: protocols (can't check for non-existent protocols w/ __getattr__)
 
-np.datetime64(0)  # E: non-matching overload
+np.datetime64(0)  # E: No overload variant
 
 class A:
     def __float__(self):
@@ -47,7 +47,8 @@ np.uint16(A())  # E: incompatible type
 np.uint32(A())  # E: incompatible type
 np.uint64(A())  # E: incompatible type
 
-np.void("test")  # E: incompatible type
+np.void("test")  # E: No overload variant
+np.void("test", dtype=None)  # E: No overload variant
 
 np.generic(1)  # E: Cannot instantiate abstract class
 np.number(1)  # E: Cannot instantiate abstract class
@@ -62,7 +63,7 @@ np.uint64(value=0)  # E: Unexpected keyword argument
 np.complex128(value=0.0j)  # E: Unexpected keyword argument
 np.str_(value='bob')  # E: No overload variant
 np.bytes_(value=b'test')  # E: No overload variant
-np.void(value=b'test')  # E: Unexpected keyword argument
+np.void(value=b'test')  # E: No overload variant
 np.bool_(value=True)  # E: Unexpected keyword argument
 np.datetime64(value="2019")  # E: No overload variant
 np.timedelta64(value=0)  # E: Unexpected keyword argument
@@ -70,8 +71,6 @@ np.timedelta64(value=0)  # E: Unexpected keyword argument
 np.bytes_(b"hello", encoding='utf-8')  # E: No overload variant
 np.str_("hello", encoding='utf-8')  # E: No overload variant
 
-complex(np.bytes_("1"))  # E: No overload variant
-
 f8.item(1)  # E: incompatible type
 f8.item((0, 1))  # E: incompatible type
 f8.squeeze(axis=1)  # E: incompatible type
diff --git a/numpy/typing/tests/data/fail/shape_base.pyi b/numpy/typing/tests/data/fail/shape_base.pyi
new file mode 100644
index 000000000000..e709741b7935
--- /dev/null
+++ b/numpy/typing/tests/data/fail/shape_base.pyi
@@ -0,0 +1,8 @@
+import numpy as np
+
+class DTypeLike:
+    dtype: np.dtype[np.int_]
+
+dtype_like: DTypeLike
+
+np.expand_dims(dtype_like, (5, 10))  # E: No overload variant
diff --git a/numpy/typing/tests/data/fail/testing.pyi b/numpy/typing/tests/data/fail/testing.pyi
index e753a9810ab3..803870e2fead 100644
--- a/numpy/typing/tests/data/fail/testing.pyi
+++ b/numpy/typing/tests/data/fail/testing.pyi
@@ -22,5 +22,7 @@ np.testing.assert_array_max_ulp(AR_U, AR_U)  # E: incompatible type
 
 np.testing.assert_warns(warning_class=RuntimeWarning, func=func)  # E: No overload variant
 np.testing.assert_no_warnings(func=func)  # E: No overload variant
+np.testing.assert_no_warnings(func, None)  # E: Too many arguments
+np.testing.assert_no_warnings(func, test=None)  # E: Unexpected keyword argument
 
 np.testing.assert_no_gc_cycles(func=func)  # E: No overload variant
diff --git a/numpy/typing/tests/data/fail/twodim_base.pyi b/numpy/typing/tests/data/fail/twodim_base.pyi
index ab34a374ccf5..faa430095a5f 100644
--- a/numpy/typing/tests/data/fail/twodim_base.pyi
+++ b/numpy/typing/tests/data/fail/twodim_base.pyi
@@ -1,4 +1,4 @@
-from typing import Any, List, TypeVar
+from typing import Any, TypeVar
 
 import numpy as np
 import numpy.typing as npt
@@ -15,7 +15,7 @@ def func2(ar: npt.NDArray[Any], a: float) -> float:
 AR_b: npt.NDArray[np.bool_]
 AR_m: npt.NDArray[np.timedelta64]
 
-AR_LIKE_b: List[bool]
+AR_LIKE_b: list[bool]
 
 np.eye(10, M=20.0)  # E: No overload variant
 np.eye(10, k=2.5, dtype=int)  # E: No overload variant
diff --git a/numpy/typing/tests/data/fail/ufunclike.pyi b/numpy/typing/tests/data/fail/ufunclike.pyi
index 82a5f3a1d091..2f9fd14c8cf2 100644
--- a/numpy/typing/tests/data/fail/ufunclike.pyi
+++ b/numpy/typing/tests/data/fail/ufunclike.pyi
@@ -1,4 +1,4 @@
-from typing import List, Any
+from typing import Any
 import numpy as np
 
 AR_c: np.ndarray[Any, np.dtype[np.complex128]]
diff --git a/numpy/typing/tests/data/mypy.ini b/numpy/typing/tests/data/mypy.ini
index 548f762612fc..baad759bbdc3 100644
--- a/numpy/typing/tests/data/mypy.ini
+++ b/numpy/typing/tests/data/mypy.ini
@@ -1,6 +1,7 @@
 [mypy]
 plugins = numpy.typing.mypy_plugin
 show_absolute_path = True
+implicit_reexport = False
 
 [mypy-numpy]
 ignore_errors = True
diff --git a/numpy/typing/tests/data/pass/arithmetic.py b/numpy/typing/tests/data/pass/arithmetic.py
index fe1612906e01..07a99012735d 100644
--- a/numpy/typing/tests/data/pass/arithmetic.py
+++ b/numpy/typing/tests/data/pass/arithmetic.py
@@ -2,6 +2,7 @@
 
 from typing import Any
 import numpy as np
+import pytest
 
 c16 = np.complex128(1)
 f8 = np.float64(1)
@@ -185,6 +186,10 @@ def __rpow__(self, value: Any) -> Object:
 AR_LIKE_c - AR_O
 AR_LIKE_O - AR_O
 
+AR_u += AR_b
+AR_u += AR_u
+AR_u += 1  # Allowed during runtime as long as the object is 0D and >=0
+
 # Array floor division
 
 AR_b // AR_LIKE_b
@@ -326,8 +331,9 @@ def __rpow__(self, value: Any) -> Object:
 -f4
 -i8
 -i4
--u8
--u4
+with pytest.warns(RuntimeWarning):
+    -u8
+    -u4
 -td
 -AR_f
 
diff --git a/numpy/typing/tests/data/pass/array_constructors.py b/numpy/typing/tests/data/pass/array_constructors.py
index 2763d9c9272a..e035a73c6fe9 100644
--- a/numpy/typing/tests/data/pass/array_constructors.py
+++ b/numpy/typing/tests/data/pass/array_constructors.py
@@ -23,9 +23,8 @@ def func(i: int, j: int, **kwargs: Any) -> SubClass:
 B_stack = np.array([[1], [1]]).view(SubClass)
 C = [1]
 
-if sys.version_info >= (3, 8):
-    np.ndarray(Index())
-    np.ndarray([Index()])
+np.ndarray(Index())
+np.ndarray([Index()])
 
 np.array(1, dtype=float)
 np.array(1, copy=False)
diff --git a/numpy/typing/tests/data/pass/array_like.py b/numpy/typing/tests/data/pass/array_like.py
index 5bd2fda20e5c..da2520e961e7 100644
--- a/numpy/typing/tests/data/pass/array_like.py
+++ b/numpy/typing/tests/data/pass/array_like.py
@@ -1,7 +1,9 @@
-from typing import Any, Optional
+from __future__ import annotations
+
+from typing import Any
 
 import numpy as np
-from numpy.typing import ArrayLike, _SupportsArray
+from numpy._typing import ArrayLike, _SupportsArray
 
 x1: ArrayLike = True
 x2: ArrayLike = 5
@@ -18,7 +20,7 @@
 
 
 class A:
-    def __array__(self, dtype: Optional[np.dtype] = None) -> np.ndarray:
+    def __array__(self, dtype: None | np.dtype[Any] = None) -> np.ndarray:
         return np.array([1, 2, 3])
 
 
diff --git a/numpy/typing/tests/data/pass/literal.py b/numpy/typing/tests/data/pass/literal.py
index 8eaeb6afb2ad..d06431eed4da 100644
--- a/numpy/typing/tests/data/pass/literal.py
+++ b/numpy/typing/tests/data/pass/literal.py
@@ -1,5 +1,7 @@
+from __future__ import annotations
+
 from functools import partial
-from typing import Callable, List, Tuple
+from collections.abc import Callable
 
 import pytest  # type: ignore
 import numpy as np
@@ -11,7 +13,7 @@
 ACF = frozenset({None, "A", "C", "F"})
 CF = frozenset({None, "C", "F"})
 
-order_list: List[Tuple[frozenset, Callable]] = [
+order_list: list[tuple[frozenset, Callable]] = [
     (KACF, partial(np.ndarray, 1)),
     (KACF, AR.tobytes),
     (KACF, partial(AR.astype, int)),
diff --git a/numpy/typing/tests/data/pass/ndarray_misc.py b/numpy/typing/tests/data/pass/ndarray_misc.py
index 62024603c949..19a1af9e292c 100644
--- a/numpy/typing/tests/data/pass/ndarray_misc.py
+++ b/numpy/typing/tests/data/pass/ndarray_misc.py
@@ -21,7 +21,7 @@ class SubClass(np.ndarray): ...
 B1 = np.empty((1,), dtype=np.int32).view(SubClass)
 B2 = np.empty((1, 1), dtype=np.int32).view(SubClass)
 C: np.ndarray[Any, np.dtype[np.int32]] = np.array([0, 1, 2], dtype=np.int32)
-D = np.empty(3).view(SubClass)
+D = np.ones(3).view(SubClass)
 
 i4.all()
 A.all()
diff --git a/numpy/typing/tests/data/pass/numeric.py b/numpy/typing/tests/data/pass/numeric.py
index 34fef7270443..c4a73c1e9b7c 100644
--- a/numpy/typing/tests/data/pass/numeric.py
+++ b/numpy/typing/tests/data/pass/numeric.py
@@ -5,7 +5,8 @@
 
 """
 
-from typing import List
+from __future__ import annotations
+
 import numpy as np
 
 class SubClass(np.ndarray):
@@ -14,7 +15,7 @@ class SubClass(np.ndarray):
 i8 = np.int64(1)
 
 A = np.arange(27).reshape(3, 3, 3)
-B: List[List[List[int]]] = A.tolist()
+B: list[list[list[int]]] = A.tolist()
 C = np.empty((27, 27)).view(SubClass)
 
 np.count_nonzero(i8)
diff --git a/numpy/typing/tests/data/pass/numerictypes.py b/numpy/typing/tests/data/pass/numerictypes.py
index 5af0d171ca04..7f1dd0945438 100644
--- a/numpy/typing/tests/data/pass/numerictypes.py
+++ b/numpy/typing/tests/data/pass/numerictypes.py
@@ -38,9 +38,9 @@
 
 np.ScalarType
 np.ScalarType[0]
-np.ScalarType[4]
-np.ScalarType[9]
-np.ScalarType[11]
+np.ScalarType[3]
+np.ScalarType[8]
+np.ScalarType[10]
 
 np.typecodes["Character"]
 np.typecodes["Complex"]
diff --git a/numpy/typing/tests/data/pass/random.py b/numpy/typing/tests/data/pass/random.py
index 05bd62112ff2..6a4d99f12b13 100644
--- a/numpy/typing/tests/data/pass/random.py
+++ b/numpy/typing/tests/data/pass/random.py
@@ -1,13 +1,12 @@
 from __future__ import annotations
 
-from typing import Any, List, Dict
-
+from typing import Any
 import numpy as np
 
 SEED_NONE = None
 SEED_INT = 4579435749574957634658964293569
 SEED_ARR: np.ndarray[Any, np.dtype[np.int64]] = np.array([1, 2, 3, 4], dtype=np.int64)
-SEED_ARRLIKE: List[int] = [1, 2, 3, 4]
+SEED_ARRLIKE: list[int] = [1, 2, 3, 4]
 SEED_SEED_SEQ: np.random.SeedSequence = np.random.SeedSequence(0)
 SEED_MT19937: np.random.MT19937 = np.random.MT19937(0)
 SEED_PCG64: np.random.PCG64 = np.random.PCG64(0)
@@ -76,13 +75,13 @@
 D_arr_1p5: np.ndarray[Any, np.dtype[np.float64]] = np.array([1.5])
 I_arr_10: np.ndarray[Any, np.dtype[np.int_]] = np.array([10], dtype=np.int_)
 I_arr_20: np.ndarray[Any, np.dtype[np.int_]] = np.array([20], dtype=np.int_)
-D_arr_like_0p1: List[float] = [0.1]
-D_arr_like_0p5: List[float] = [0.5]
-D_arr_like_0p9: List[float] = [0.9]
-D_arr_like_1p5: List[float] = [1.5]
-I_arr_like_10: List[int] = [10]
-I_arr_like_20: List[int] = [20]
-D_2D_like: List[List[float]] = [[1, 2], [2, 3], [3, 4], [4, 5.1]]
+D_arr_like_0p1: list[float] = [0.1]
+D_arr_like_0p5: list[float] = [0.5]
+D_arr_like_0p9: list[float] = [0.9]
+D_arr_like_1p5: list[float] = [1.5]
+I_arr_like_10: list[int] = [10]
+I_arr_like_20: list[int] = [20]
+D_2D_like: list[list[float]] = [[1, 2], [2, 3], [3, 4], [4, 5.1]]
 D_2D: np.ndarray[Any, np.dtype[np.float64]] = np.array(D_2D_like)
 
 S_out: np.ndarray[Any, np.dtype[np.float32]] = np.empty(1, dtype=np.float32)
@@ -499,7 +498,7 @@
 def_gen.integers(0, [100])
 
 I_bool_low: np.ndarray[Any, np.dtype[np.bool_]] = np.array([0], dtype=np.bool_)
-I_bool_low_like: List[int] = [0]
+I_bool_low_like: list[int] = [0]
 I_bool_high_open: np.ndarray[Any, np.dtype[np.bool_]] = np.array([1], dtype=np.bool_)
 I_bool_high_closed: np.ndarray[Any, np.dtype[np.bool_]] = np.array([1], dtype=np.bool_)
 
@@ -528,7 +527,7 @@
 def_gen.integers(0, I_bool_high_closed, dtype=np.bool_, endpoint=True)
 
 I_u1_low: np.ndarray[Any, np.dtype[np.uint8]] = np.array([0], dtype=np.uint8)
-I_u1_low_like: List[int] = [0]
+I_u1_low_like: list[int] = [0]
 I_u1_high_open: np.ndarray[Any, np.dtype[np.uint8]] = np.array([255], dtype=np.uint8)
 I_u1_high_closed: np.ndarray[Any, np.dtype[np.uint8]] = np.array([255], dtype=np.uint8)
 
@@ -569,7 +568,7 @@
 def_gen.integers(0, I_u1_high_closed, dtype=np.uint8, endpoint=True)
 
 I_u2_low: np.ndarray[Any, np.dtype[np.uint16]] = np.array([0], dtype=np.uint16)
-I_u2_low_like: List[int] = [0]
+I_u2_low_like: list[int] = [0]
 I_u2_high_open: np.ndarray[Any, np.dtype[np.uint16]] = np.array([65535], dtype=np.uint16)
 I_u2_high_closed: np.ndarray[Any, np.dtype[np.uint16]] = np.array([65535], dtype=np.uint16)
 
@@ -610,7 +609,7 @@
 def_gen.integers(0, I_u2_high_closed, dtype=np.uint16, endpoint=True)
 
 I_u4_low: np.ndarray[Any, np.dtype[np.uint32]] = np.array([0], dtype=np.uint32)
-I_u4_low_like: List[int] = [0]
+I_u4_low_like: list[int] = [0]
 I_u4_high_open: np.ndarray[Any, np.dtype[np.uint32]] = np.array([4294967295], dtype=np.uint32)
 I_u4_high_closed: np.ndarray[Any, np.dtype[np.uint32]] = np.array([4294967295], dtype=np.uint32)
 
@@ -651,7 +650,7 @@
 def_gen.integers(0, I_u4_high_closed, dtype=np.uint32, endpoint=True)
 
 I_u8_low: np.ndarray[Any, np.dtype[np.uint64]] = np.array([0], dtype=np.uint64)
-I_u8_low_like: List[int] = [0]
+I_u8_low_like: list[int] = [0]
 I_u8_high_open: np.ndarray[Any, np.dtype[np.uint64]] = np.array([18446744073709551615], dtype=np.uint64)
 I_u8_high_closed: np.ndarray[Any, np.dtype[np.uint64]] = np.array([18446744073709551615], dtype=np.uint64)
 
@@ -692,7 +691,7 @@
 def_gen.integers(0, I_u8_high_closed, dtype=np.uint64, endpoint=True)
 
 I_i1_low: np.ndarray[Any, np.dtype[np.int8]] = np.array([-128], dtype=np.int8)
-I_i1_low_like: List[int] = [-128]
+I_i1_low_like: list[int] = [-128]
 I_i1_high_open: np.ndarray[Any, np.dtype[np.int8]] = np.array([127], dtype=np.int8)
 I_i1_high_closed: np.ndarray[Any, np.dtype[np.int8]] = np.array([127], dtype=np.int8)
 
@@ -733,7 +732,7 @@
 def_gen.integers(-128, I_i1_high_closed, dtype=np.int8, endpoint=True)
 
 I_i2_low: np.ndarray[Any, np.dtype[np.int16]] = np.array([-32768], dtype=np.int16)
-I_i2_low_like: List[int] = [-32768]
+I_i2_low_like: list[int] = [-32768]
 I_i2_high_open: np.ndarray[Any, np.dtype[np.int16]] = np.array([32767], dtype=np.int16)
 I_i2_high_closed: np.ndarray[Any, np.dtype[np.int16]] = np.array([32767], dtype=np.int16)
 
@@ -774,7 +773,7 @@
 def_gen.integers(-32768, I_i2_high_closed, dtype=np.int16, endpoint=True)
 
 I_i4_low: np.ndarray[Any, np.dtype[np.int32]] = np.array([-2147483648], dtype=np.int32)
-I_i4_low_like: List[int] = [-2147483648]
+I_i4_low_like: list[int] = [-2147483648]
 I_i4_high_open: np.ndarray[Any, np.dtype[np.int32]] = np.array([2147483647], dtype=np.int32)
 I_i4_high_closed: np.ndarray[Any, np.dtype[np.int32]] = np.array([2147483647], dtype=np.int32)
 
@@ -815,7 +814,7 @@
 def_gen.integers(-2147483648, I_i4_high_closed, dtype=np.int32, endpoint=True)
 
 I_i8_low: np.ndarray[Any, np.dtype[np.int64]] = np.array([-9223372036854775808], dtype=np.int64)
-I_i8_low_like: List[int] = [-9223372036854775808]
+I_i8_low_like: list[int] = [-9223372036854775808]
 I_i8_high_open: np.ndarray[Any, np.dtype[np.int64]] = np.array([9223372036854775807], dtype=np.int64)
 I_i8_high_closed: np.ndarray[Any, np.dtype[np.int64]] = np.array([9223372036854775807], dtype=np.int64)
 
@@ -912,7 +911,7 @@
 
 def_gen.__str__()
 def_gen.__repr__()
-def_gen_state: Dict[str, Any]
+def_gen_state: dict[str, Any]
 def_gen_state = def_gen.__getstate__()
 def_gen.__setstate__(def_gen_state)
 
@@ -1495,3 +1494,6 @@
 random_st.tomaxint()
 random_st.tomaxint(1)
 random_st.tomaxint((1,))
+
+np.random.set_bit_generator(SEED_PCG64)
+np.random.get_bit_generator()
diff --git a/numpy/typing/tests/data/pass/scalars.py b/numpy/typing/tests/data/pass/scalars.py
index b258db49fd7c..a5c6f96e9fa2 100644
--- a/numpy/typing/tests/data/pass/scalars.py
+++ b/numpy/typing/tests/data/pass/scalars.py
@@ -59,10 +59,9 @@ def __float__(self) -> float:
 np.float32("1")
 np.float16(b"2.5")
 
-if sys.version_info >= (3, 8):
-    np.uint64(D())
-    np.float32(D())
-    np.complex64(D())
+np.uint64(D())
+np.float32(D())
+np.complex64(D())
 
 np.bytes_(b"hello")
 np.bytes_("hello", 'utf-8')
@@ -114,6 +113,8 @@ def __float__(self) -> float:
 np.void(np.bool_(True))
 np.void(b"test")
 np.void(np.bytes_("test"))
+np.void(object(), [("a", "O"), ("b", "O")])
+np.void(object(), dtype=[("a", "O"), ("b", "O")])
 
 # Protocols
 i8 = np.int64()
@@ -174,18 +175,12 @@ def __float__(self) -> float:
 c16.transpose()
 
 # Aliases
-np.str0()
-np.bool8()
-np.bytes0()
 np.string_()
-np.object0()
-np.void0(0)
 
 np.byte()
 np.short()
 np.intc()
 np.intp()
-np.int0()
 np.int_()
 np.longlong()
 
@@ -193,7 +188,6 @@ def __float__(self) -> float:
 np.ushort()
 np.uintc()
 np.uintp()
-np.uint0()
 np.uint()
 np.ulonglong()
 
diff --git a/numpy/typing/tests/data/pass/simple.py b/numpy/typing/tests/data/pass/simple.py
index 85965e0de707..03ca3e83f74b 100644
--- a/numpy/typing/tests/data/pass/simple.py
+++ b/numpy/typing/tests/data/pass/simple.py
@@ -2,7 +2,7 @@
 import operator
 
 import numpy as np
-from typing import Iterable  # noqa: F401
+from collections.abc import Iterable
 
 # Basic checks
 array = np.array([1, 2])
diff --git a/numpy/typing/tests/data/reveal/arithmetic.pyi b/numpy/typing/tests/data/reveal/arithmetic.pyi
index c5b46746980d..0ca5e9772958 100644
--- a/numpy/typing/tests/data/reveal/arithmetic.pyi
+++ b/numpy/typing/tests/data/reveal/arithmetic.pyi
@@ -1,9 +1,10 @@
-from typing import Any, List
+from typing import Any
+
 import numpy as np
-import numpy.typing as npt
+from numpy._typing import NDArray, _128Bit
 
 # Can't directly import `np.float128` as it is not available on all platforms
-f16: np.floating[npt._128Bit]
+f16: np.floating[_128Bit]
 
 c16 = np.complex128()
 f8 = np.float64()
@@ -33,18 +34,21 @@ AR_c: np.ndarray[Any, np.dtype[np.complex128]]
 AR_m: np.ndarray[Any, np.dtype[np.timedelta64]]
 AR_M: np.ndarray[Any, np.dtype[np.datetime64]]
 AR_O: np.ndarray[Any, np.dtype[np.object_]]
+AR_number: NDArray[np.number[Any]]
 
-AR_LIKE_b: List[bool]
-AR_LIKE_u: List[np.uint32]
-AR_LIKE_i: List[int]
-AR_LIKE_f: List[float]
-AR_LIKE_c: List[complex]
-AR_LIKE_m: List[np.timedelta64]
-AR_LIKE_M: List[np.datetime64]
-AR_LIKE_O: List[np.object_]
+AR_LIKE_b: list[bool]
+AR_LIKE_u: list[np.uint32]
+AR_LIKE_i: list[int]
+AR_LIKE_f: list[float]
+AR_LIKE_c: list[complex]
+AR_LIKE_m: list[np.timedelta64]
+AR_LIKE_M: list[np.datetime64]
+AR_LIKE_O: list[np.object_]
 
 # Array subtraction
 
+reveal_type(AR_number - AR_number)  # E: ndarray[Any, dtype[number[Any]]]
+
 reveal_type(AR_b - AR_LIKE_u)  # E: ndarray[Any, dtype[unsignedinteger[Any]]]
 reveal_type(AR_b - AR_LIKE_i)  # E: ndarray[Any, dtype[signedinteger[Any]]]
 reveal_type(AR_b - AR_LIKE_f)  # E: ndarray[Any, dtype[floating[Any]]]
diff --git a/numpy/typing/tests/data/reveal/array_constructors.pyi b/numpy/typing/tests/data/reveal/array_constructors.pyi
index 233988e63750..2ff20e9aeeca 100644
--- a/numpy/typing/tests/data/reveal/array_constructors.pyi
+++ b/numpy/typing/tests/data/reveal/array_constructors.pyi
@@ -1,4 +1,4 @@
-from typing import List, Any, TypeVar
+from typing import Any, TypeVar
 from pathlib import Path
 
 import numpy as np
@@ -12,7 +12,7 @@ i8: np.int64
 
 A: npt.NDArray[np.float64]
 B: SubClass[np.float64]
-C: List[int]
+C: list[int]
 
 def func(i: int, j: int, **kwargs: Any) -> SubClass[np.float64]: ...
 
@@ -28,6 +28,7 @@ reveal_type(np.array(B, subok=True))  # E: SubClass[{float64}]
 reveal_type(np.array([1, 1.0]))  # E: ndarray[Any, dtype[Any]]
 reveal_type(np.array(A, dtype=np.int64))  # E: ndarray[Any, dtype[{int64}]]
 reveal_type(np.array(A, dtype='c16'))  # E: ndarray[Any, dtype[Any]]
+reveal_type(np.array(A, like=A))  # E: ndarray[Any, dtype[{float64}]]
 
 reveal_type(np.zeros([1, 5, 6]))  # E: ndarray[Any, dtype[{float64}]]
 reveal_type(np.zeros([1, 5, 6], dtype=np.int64))  # E: ndarray[Any, dtype[{int64}]]
@@ -38,6 +39,11 @@ reveal_type(np.empty([1, 5, 6], dtype=np.int64))  # E: ndarray[Any, dtype[{int64
 reveal_type(np.empty([1, 5, 6], dtype='c16'))  # E: ndarray[Any, dtype[Any]]
 
 reveal_type(np.concatenate(A))  # E: ndarray[Any, dtype[{float64}]]
+reveal_type(np.concatenate([A, A]))  # E: Any
+reveal_type(np.concatenate([[1], A]))  # E: ndarray[Any, dtype[Any]]
+reveal_type(np.concatenate([[1], [1]]))  # E: ndarray[Any, dtype[Any]]
+reveal_type(np.concatenate((A, A)))  # E: ndarray[Any, dtype[{float64}]]
+reveal_type(np.concatenate(([1], [1])))  # E: ndarray[Any, dtype[Any]]
 reveal_type(np.concatenate([1, 1.0]))  # E: ndarray[Any, dtype[Any]]
 reveal_type(np.concatenate(A, dtype=np.int64))  # E: ndarray[Any, dtype[{int64}]]
 reveal_type(np.concatenate(A, dtype='c16'))  # E: ndarray[Any, dtype[Any]]
@@ -114,10 +120,24 @@ reveal_type(np.require(B, requirements="W"))  # E: SubClass[{float64}]
 reveal_type(np.require(B, requirements="A"))  # E: SubClass[{float64}]
 reveal_type(np.require(C))  # E: ndarray[Any, Any]
 
-reveal_type(np.linspace(0, 10))  # E: ndarray[Any, Any]
-reveal_type(np.linspace(0, 10, retstep=True))  # E: Tuple[ndarray[Any, Any], Any]
-reveal_type(np.logspace(0, 10))  # E: ndarray[Any, Any]
-reveal_type(np.geomspace(1, 10))  # E: ndarray[Any, Any]
+reveal_type(np.linspace(0, 10))  # E: ndarray[Any, dtype[floating[Any]]]
+reveal_type(np.linspace(0, 10j))  # E: ndarray[Any, dtype[complexfloating[Any, Any]]]
+reveal_type(np.linspace(0, 10, dtype=np.int64))  # E: ndarray[Any, dtype[{int64}]]
+reveal_type(np.linspace(0, 10, dtype=int))  # E: ndarray[Any, dtype[Any]]
+reveal_type(np.linspace(0, 10, retstep=True))  # E: Tuple[ndarray[Any, dtype[floating[Any]]], floating[Any]]
+reveal_type(np.linspace(0j, 10, retstep=True))  # E: Tuple[ndarray[Any, dtype[complexfloating[Any, Any]]], complexfloating[Any, Any]]
+reveal_type(np.linspace(0, 10, retstep=True, dtype=np.int64))  # E: Tuple[ndarray[Any, dtype[{int64}]], {int64}]
+reveal_type(np.linspace(0j, 10, retstep=True, dtype=int))  # E: Tuple[ndarray[Any, dtype[Any]], Any]
+
+reveal_type(np.logspace(0, 10))  # E: ndarray[Any, dtype[floating[Any]]]
+reveal_type(np.logspace(0, 10j))  # E: ndarray[Any, dtype[complexfloating[Any, Any]]]
+reveal_type(np.logspace(0, 10, dtype=np.int64))  # E: ndarray[Any, dtype[{int64}]]
+reveal_type(np.logspace(0, 10, dtype=int))  # E: ndarray[Any, dtype[Any]]
+
+reveal_type(np.geomspace(0, 10))  # E: ndarray[Any, dtype[floating[Any]]]
+reveal_type(np.geomspace(0, 10j))  # E: ndarray[Any, dtype[complexfloating[Any, Any]]]
+reveal_type(np.geomspace(0, 10, dtype=np.int64))  # E: ndarray[Any, dtype[{int64}]]
+reveal_type(np.geomspace(0, 10, dtype=int))  # E: ndarray[Any, dtype[Any]]
 
 reveal_type(np.zeros_like(A))  # E: ndarray[Any, dtype[{float64}]]
 reveal_type(np.zeros_like(C))  # E: ndarray[Any, dtype[Any]]
@@ -148,7 +168,7 @@ reveal_type(np.full(1, i8, dtype=np.float64))  # E: ndarray[Any, dtype[{float64}
 reveal_type(np.full(1, i8, dtype=float))  # E: ndarray[Any, dtype[Any]]
 
 reveal_type(np.indices([1, 2, 3]))  # E: ndarray[Any, dtype[{int_}]]
-reveal_type(np.indices([1, 2, 3], sparse=True))  # E: tuple[ndarray[Any, dtype[{int_}]]]
+reveal_type(np.indices([1, 2, 3], sparse=True))  # E: tuple[ndarray[Any, dtype[{int_}]], ...]
 
 reveal_type(np.fromfunction(func, (3, 5)))  # E: SubClass[{float64}]
 
@@ -166,17 +186,20 @@ reveal_type(np.atleast_2d(A))  # E: ndarray[Any, dtype[{float64}]]
 
 reveal_type(np.atleast_3d(A))  # E: ndarray[Any, dtype[{float64}]]
 
-reveal_type(np.vstack([A, A]))  # E: ndarray[Any, dtype[{float64}]]
+reveal_type(np.vstack([A, A]))  # E: ndarray[Any, Any]
+reveal_type(np.vstack([A, A], dtype=np.float64))  # E: ndarray[Any, dtype[{float64}]]
 reveal_type(np.vstack([A, C]))  # E: ndarray[Any, dtype[Any]]
 reveal_type(np.vstack([C, C]))  # E: ndarray[Any, dtype[Any]]
 
-reveal_type(np.hstack([A, A]))  # E: ndarray[Any, dtype[{float64}]]
+reveal_type(np.hstack([A, A]))  # E: ndarray[Any, Any]
+reveal_type(np.hstack([A, A], dtype=np.float64))  # E: ndarray[Any, dtype[{float64}]]
 
-reveal_type(np.stack([A, A]))  # E: ndarray[Any, dtype[{float64}]]
+reveal_type(np.stack([A, A]))  # E: Any
+reveal_type(np.stack([A, A], dtype=np.float64))  # E: ndarray[Any, dtype[{float64}]]
 reveal_type(np.stack([A, C]))  # E: ndarray[Any, dtype[Any]]
 reveal_type(np.stack([C, C]))  # E: ndarray[Any, dtype[Any]]
-reveal_type(np.stack([A, A], axis=0))  # E: ndarray[Any, dtype[{float64}]]
+reveal_type(np.stack([A, A], axis=0))  # E: Any
 reveal_type(np.stack([A, A], out=B))  # E: SubClass[{float64}]
 
-reveal_type(np.block([[A, A], [A, A]]))  # E: ndarray[Any, dtype[{float64}]]
+reveal_type(np.block([[A, A], [A, A]]))  # E: ndarray[Any, dtype[Any]]
 reveal_type(np.block(C))  # E: ndarray[Any, dtype[Any]]
diff --git a/numpy/typing/tests/data/reveal/arraypad.pyi b/numpy/typing/tests/data/reveal/arraypad.pyi
index 995f82b579e6..a05d44034644 100644
--- a/numpy/typing/tests/data/reveal/arraypad.pyi
+++ b/numpy/typing/tests/data/reveal/arraypad.pyi
@@ -1,18 +1,19 @@
-from typing import List, Any, Mapping, Tuple, SupportsIndex
+from collections.abc import Mapping
+from typing import Any, SupportsIndex
 
 import numpy as np
 import numpy.typing as npt
 
 def mode_func(
     ar: npt.NDArray[np.number[Any]],
-    width: Tuple[int, int],
+    width: tuple[int, int],
     iaxis: SupportsIndex,
     kwargs: Mapping[str, Any],
 ) -> None: ...
 
 AR_i8: npt.NDArray[np.int64]
 AR_f8: npt.NDArray[np.float64]
-AR_LIKE: List[int]
+AR_LIKE: list[int]
 
 reveal_type(np.pad(AR_i8, (2, 3), "constant"))  # E: ndarray[Any, dtype[{int64}]]
 reveal_type(np.pad(AR_LIKE, (2, 3), "constant"))  # E: ndarray[Any, dtype[Any]]
diff --git a/numpy/typing/tests/data/reveal/arrayprint.pyi b/numpy/typing/tests/data/reveal/arrayprint.pyi
index e797097ebb94..6e65a8d8ad24 100644
--- a/numpy/typing/tests/data/reveal/arrayprint.pyi
+++ b/numpy/typing/tests/data/reveal/arrayprint.pyi
@@ -1,4 +1,5 @@
-from typing import Any, Callable
+from collections.abc import Callable
+from typing import Any
 import numpy as np
 
 AR: np.ndarray[Any, Any]
diff --git a/numpy/typing/tests/data/reveal/arrayterator.pyi b/numpy/typing/tests/data/reveal/arrayterator.pyi
index 2dab9d08c7fa..b6c26ddb70e1 100644
--- a/numpy/typing/tests/data/reveal/arrayterator.pyi
+++ b/numpy/typing/tests/data/reveal/arrayterator.pyi
@@ -9,7 +9,7 @@ reveal_type(ar_iter.buf_size)  # E: Union[None, builtins.int]
 reveal_type(ar_iter.start)  # E: builtins.list[builtins.int]
 reveal_type(ar_iter.stop)  # E: builtins.list[builtins.int]
 reveal_type(ar_iter.step)  # E: builtins.list[builtins.int]
-reveal_type(ar_iter.shape)  # E: builtins.tuple[builtins.int]
+reveal_type(ar_iter.shape)  # E: builtins.tuple[builtins.int, ...]
 reveal_type(ar_iter.flat)  # E: typing.Generator[{int64}, None, None]
 
 reveal_type(ar_iter.__array__())  # E: ndarray[Any, dtype[{int64}]]
diff --git a/numpy/typing/tests/data/reveal/char.pyi b/numpy/typing/tests/data/reveal/char.pyi
index ce8c1b2690a9..0563b34727e4 100644
--- a/numpy/typing/tests/data/reveal/char.pyi
+++ b/numpy/typing/tests/data/reveal/char.pyi
@@ -1,6 +1,6 @@
 import numpy as np
 import numpy.typing as npt
-from typing import Sequence
+from collections.abc import Sequence
 
 AR_U: npt.NDArray[np.str_]
 AR_S: npt.NDArray[np.bytes_]
diff --git a/numpy/typing/tests/data/reveal/chararray.pyi b/numpy/typing/tests/data/reveal/chararray.pyi
index 3da2e15993fe..61906c860675 100644
--- a/numpy/typing/tests/data/reveal/chararray.pyi
+++ b/numpy/typing/tests/data/reveal/chararray.pyi
@@ -127,3 +127,6 @@ reveal_type(AR_S.istitle())  # E: ndarray[Any, dtype[bool_]]
 
 reveal_type(AR_U.isupper())  # E: ndarray[Any, dtype[bool_]]
 reveal_type(AR_S.isupper())  # E: ndarray[Any, dtype[bool_]]
+
+reveal_type(AR_U.__array_finalize__(object()))  # E: None
+reveal_type(AR_S.__array_finalize__(object()))  # E: None
diff --git a/numpy/typing/tests/data/reveal/comparisons.pyi b/numpy/typing/tests/data/reveal/comparisons.pyi
index ecd8ea6908e4..9b32f40576b3 100644
--- a/numpy/typing/tests/data/reveal/comparisons.pyi
+++ b/numpy/typing/tests/data/reveal/comparisons.pyi
@@ -1,4 +1,6 @@
 import numpy as np
+import fractions
+import decimal
 
 c16 = np.complex128()
 f8 = np.float64()
@@ -25,6 +27,13 @@ AR.setflags(write=False)
 
 SEQ = (0, 1, 2, 3, 4)
 
+# object-like comparisons
+
+reveal_type(i8 > fractions.Fraction(1, 5))  # E: Any
+reveal_type(i8 > [fractions.Fraction(1, 5)])  # E: Any
+reveal_type(i8 > decimal.Decimal("1.5"))  # E: Any
+reveal_type(i8 > [decimal.Decimal("1.5")])  # E: Any
+
 # Time structures
 
 reveal_type(dt > dt)  # E: bool_
diff --git a/numpy/typing/tests/data/reveal/ctypeslib.pyi b/numpy/typing/tests/data/reveal/ctypeslib.pyi
index ccbdfe36e72b..2d30de3d15fe 100644
--- a/numpy/typing/tests/data/reveal/ctypeslib.pyi
+++ b/numpy/typing/tests/data/reveal/ctypeslib.pyi
@@ -20,7 +20,7 @@ AR_double: npt.NDArray[np.double]
 AR_longdouble: npt.NDArray[np.longdouble]
 AR_void: npt.NDArray[np.void]
 
-pointer: ctypes.pointer[Any]
+pointer: ctypes._Pointer[Any]
 
 reveal_type(np.ctypeslib.c_intp())  # E: {c_intp}
 
diff --git a/numpy/typing/tests/data/reveal/dtype.pyi b/numpy/typing/tests/data/reveal/dtype.pyi
index 934d7da5efe2..7a658511a019 100644
--- a/numpy/typing/tests/data/reveal/dtype.pyi
+++ b/numpy/typing/tests/data/reveal/dtype.pyi
@@ -48,11 +48,11 @@ reveal_type(np.dtype(("U", 10)))  # E: dtype[void]
 
 # Methods and attributes
 reveal_type(dtype_U.base)  # E: dtype[Any]
-reveal_type(dtype_U.subdtype)  # E: Union[None, Tuple[dtype[Any], builtins.tuple[builtins.int]]]
+reveal_type(dtype_U.subdtype)  # E: Union[None, Tuple[dtype[Any], builtins.tuple[builtins.int, ...]]]
 reveal_type(dtype_U.newbyteorder())  # E: dtype[str_]
 reveal_type(dtype_U.type)  # E: Type[str_]
 reveal_type(dtype_U.name)  # E: str
-reveal_type(dtype_U.names)  # E: Union[None, builtins.tuple[builtins.str]]
+reveal_type(dtype_U.names)  # E: Union[None, builtins.tuple[builtins.str, ...]]
 
 reveal_type(dtype_U * 0)  # E: dtype[str_]
 reveal_type(dtype_U * 1)  # E: dtype[str_]
diff --git a/numpy/typing/tests/data/reveal/einsumfunc.pyi b/numpy/typing/tests/data/reveal/einsumfunc.pyi
index 5b07e6d3c803..d5f9301494f7 100644
--- a/numpy/typing/tests/data/reveal/einsumfunc.pyi
+++ b/numpy/typing/tests/data/reveal/einsumfunc.pyi
@@ -1,12 +1,12 @@
-from typing import List, Any
+from typing import Any
 import numpy as np
 
-AR_LIKE_b: List[bool]
-AR_LIKE_u: List[np.uint32]
-AR_LIKE_i: List[int]
-AR_LIKE_f: List[float]
-AR_LIKE_c: List[complex]
-AR_LIKE_U: List[str]
+AR_LIKE_b: list[bool]
+AR_LIKE_u: list[np.uint32]
+AR_LIKE_i: list[int]
+AR_LIKE_f: list[float]
+AR_LIKE_c: list[complex]
+AR_LIKE_U: list[str]
 
 OUT_f: np.ndarray[Any, np.dtype[np.float64]]
 
@@ -30,3 +30,6 @@ reveal_type(np.einsum_path("i,i->i", AR_LIKE_f, AR_LIKE_f))  # E: Tuple[builtins
 reveal_type(np.einsum_path("i,i->i", AR_LIKE_c, AR_LIKE_c))  # E: Tuple[builtins.list[Any], builtins.str]
 reveal_type(np.einsum_path("i,i->i", AR_LIKE_b, AR_LIKE_i))  # E: Tuple[builtins.list[Any], builtins.str]
 reveal_type(np.einsum_path("i,i,i,i->i", AR_LIKE_b, AR_LIKE_u, AR_LIKE_i, AR_LIKE_c))  # E: Tuple[builtins.list[Any], builtins.str]
+
+reveal_type(np.einsum([[1, 1], [1, 1]], AR_LIKE_i, AR_LIKE_i))  # E: Any
+reveal_type(np.einsum_path([[1, 1], [1, 1]], AR_LIKE_i, AR_LIKE_i))  # E: Tuple[builtins.list[Any], builtins.str]
diff --git a/numpy/typing/tests/data/reveal/emath.pyi b/numpy/typing/tests/data/reveal/emath.pyi
new file mode 100644
index 000000000000..9ab2d72d2be2
--- /dev/null
+++ b/numpy/typing/tests/data/reveal/emath.pyi
@@ -0,0 +1,52 @@
+import numpy as np
+import numpy.typing as npt
+
+AR_f8: npt.NDArray[np.float64]
+AR_c16: npt.NDArray[np.complex128]
+f8: np.float64
+c16: np.complex128
+
+reveal_type(np.emath.sqrt(f8))  # E: Any
+reveal_type(np.emath.sqrt(AR_f8))  # E: ndarray[Any, dtype[Any]]
+reveal_type(np.emath.sqrt(c16))  # E: complexfloating[Any, Any]
+reveal_type(np.emath.sqrt(AR_c16))  # E: ndarray[Any, dtype[complexfloating[Any, Any]]]
+
+reveal_type(np.emath.log(f8))  # E: Any
+reveal_type(np.emath.log(AR_f8))  # E: ndarray[Any, dtype[Any]]
+reveal_type(np.emath.log(c16))  # E: complexfloating[Any, Any]
+reveal_type(np.emath.log(AR_c16))  # E: ndarray[Any, dtype[complexfloating[Any, Any]]]
+
+reveal_type(np.emath.log10(f8))  # E: Any
+reveal_type(np.emath.log10(AR_f8))  # E: ndarray[Any, dtype[Any]]
+reveal_type(np.emath.log10(c16))  # E: complexfloating[Any, Any]
+reveal_type(np.emath.log10(AR_c16))  # E: ndarray[Any, dtype[complexfloating[Any, Any]]]
+
+reveal_type(np.emath.log2(f8))  # E: Any
+reveal_type(np.emath.log2(AR_f8))  # E: ndarray[Any, dtype[Any]]
+reveal_type(np.emath.log2(c16))  # E: complexfloating[Any, Any]
+reveal_type(np.emath.log2(AR_c16))  # E: ndarray[Any, dtype[complexfloating[Any, Any]]]
+
+reveal_type(np.emath.logn(f8, 2))  # E: Any
+reveal_type(np.emath.logn(AR_f8, 4))  # E: ndarray[Any, dtype[Any]]
+reveal_type(np.emath.logn(f8, 1j))  # E: complexfloating[Any, Any]
+reveal_type(np.emath.logn(AR_c16, 1.5))  # E: ndarray[Any, dtype[complexfloating[Any, Any]]]
+
+reveal_type(np.emath.power(f8, 2))  # E: Any
+reveal_type(np.emath.power(AR_f8, 4))  # E: ndarray[Any, dtype[Any]]
+reveal_type(np.emath.power(f8, 2j))  # E: complexfloating[Any, Any]
+reveal_type(np.emath.power(AR_c16, 1.5))  # E: ndarray[Any, dtype[complexfloating[Any, Any]]]
+
+reveal_type(np.emath.arccos(f8))  # E: Any
+reveal_type(np.emath.arccos(AR_f8))  # E: ndarray[Any, dtype[Any]]
+reveal_type(np.emath.arccos(c16))  # E: complexfloating[Any, Any]
+reveal_type(np.emath.arccos(AR_c16))  # E: ndarray[Any, dtype[complexfloating[Any, Any]]]
+
+reveal_type(np.emath.arcsin(f8))  # E: Any
+reveal_type(np.emath.arcsin(AR_f8))  # E: ndarray[Any, dtype[Any]]
+reveal_type(np.emath.arcsin(c16))  # E: complexfloating[Any, Any]
+reveal_type(np.emath.arcsin(AR_c16))  # E: ndarray[Any, dtype[complexfloating[Any, Any]]]
+
+reveal_type(np.emath.arctanh(f8))  # E: Any
+reveal_type(np.emath.arctanh(AR_f8))  # E: ndarray[Any, dtype[Any]]
+reveal_type(np.emath.arctanh(c16))  # E: complexfloating[Any, Any]
+reveal_type(np.emath.arctanh(AR_c16))  # E: ndarray[Any, dtype[complexfloating[Any, Any]]]
diff --git a/numpy/typing/tests/data/reveal/false_positives.pyi b/numpy/typing/tests/data/reveal/false_positives.pyi
new file mode 100644
index 000000000000..2d7156642ec2
--- /dev/null
+++ b/numpy/typing/tests/data/reveal/false_positives.pyi
@@ -0,0 +1,10 @@
+from typing import Any
+import numpy.typing as npt
+
+AR_Any: npt.NDArray[Any]
+
+# Mypy bug where overload ambiguity is ignored for `Any`-parametrized types;
+# xref numpy/numpy#20099 and python/mypy#11347
+#
+# The expected output would be something akin to `ndarray[Any, dtype[Any]]`
+reveal_type(AR_Any + 2)  # E: ndarray[Any, dtype[signedinteger[Any]]]
diff --git a/numpy/typing/tests/data/reveal/flatiter.pyi b/numpy/typing/tests/data/reveal/flatiter.pyi
index ef89acb58a2a..8d3e80632821 100644
--- a/numpy/typing/tests/data/reveal/flatiter.pyi
+++ b/numpy/typing/tests/data/reveal/flatiter.pyi
@@ -5,13 +5,19 @@ a: np.flatiter[np.ndarray[Any, np.dtype[np.str_]]]
 
 reveal_type(a.base)  # E: ndarray[Any, dtype[str_]]
 reveal_type(a.copy())  # E: ndarray[Any, dtype[str_]]
-reveal_type(a.coords)  # E: tuple[builtins.int]
+reveal_type(a.coords)  # E: tuple[builtins.int, ...]
 reveal_type(a.index)  # E: int
-reveal_type(iter(a))  # E: Iterator[str_]
+reveal_type(iter(a))  # E: Any
 reveal_type(next(a))  # E: str_
 reveal_type(a[0])  # E: str_
 reveal_type(a[[0, 1, 2]])  # E: ndarray[Any, dtype[str_]]
 reveal_type(a[...])  # E: ndarray[Any, dtype[str_]]
 reveal_type(a[:])  # E: ndarray[Any, dtype[str_]]
+reveal_type(a[(...,)])  # E: ndarray[Any, dtype[str_]]
+reveal_type(a[(0,)])  # E: str_
 reveal_type(a.__array__())  # E: ndarray[Any, dtype[str_]]
 reveal_type(a.__array__(np.dtype(np.float64)))  # E: ndarray[Any, dtype[{float64}]]
+a[0] = "a"
+a[:5] = "a"
+a[...] = "a"
+a[(...,)] = "a"
diff --git a/numpy/typing/tests/data/reveal/fromnumeric.pyi b/numpy/typing/tests/data/reveal/fromnumeric.pyi
index 2ee1952cf7bf..e769abcf5e52 100644
--- a/numpy/typing/tests/data/reveal/fromnumeric.pyi
+++ b/numpy/typing/tests/data/reveal/fromnumeric.pyi
@@ -1,264 +1,297 @@
 """Tests for :mod:`core.fromnumeric`."""
 
 import numpy as np
+import numpy.typing as npt
+
+class NDArraySubclass(npt.NDArray[np.complex128]):
+    ...
+
+AR_b: npt.NDArray[np.bool_]
+AR_f4: npt.NDArray[np.float32]
+AR_c16: npt.NDArray[np.complex128]
+AR_u8: npt.NDArray[np.uint64]
+AR_i8: npt.NDArray[np.int64]
+AR_O: npt.NDArray[np.object_]
+AR_subclass: NDArraySubclass
+
+b: np.bool_
+f4: np.float32
+i8: np.int64
+f: float
+
+reveal_type(np.take(b, 0))  # E: bool_
+reveal_type(np.take(f4, 0))  # E: {float32}
+reveal_type(np.take(f, 0))  # E: Any
+reveal_type(np.take(AR_b, 0))  # E: bool_
+reveal_type(np.take(AR_f4, 0))  # E: {float32}
+reveal_type(np.take(AR_b, [0]))  # E: ndarray[Any, dtype[bool_]]
+reveal_type(np.take(AR_f4, [0]))  # E: ndarray[Any, dtype[{float32}]]
+reveal_type(np.take([1], [0]))  # E: ndarray[Any, dtype[Any]]
+reveal_type(np.take(AR_f4, [0], out=AR_subclass))  # E: NDArraySubclass
+
+reveal_type(np.reshape(b, 1))  # E: ndarray[Any, dtype[bool_]]
+reveal_type(np.reshape(f4, 1))  # E: ndarray[Any, dtype[{float32}]]
+reveal_type(np.reshape(f, 1))  # E: ndarray[Any, dtype[Any]]
+reveal_type(np.reshape(AR_b, 1))  # E: ndarray[Any, dtype[bool_]]
+reveal_type(np.reshape(AR_f4, 1))  # E: ndarray[Any, dtype[{float32}]]
+
+reveal_type(np.choose(1, [True, True]))  # E: Any
+reveal_type(np.choose([1], [True, True]))  # E: ndarray[Any, dtype[Any]]
+reveal_type(np.choose([1], AR_b))  # E: ndarray[Any, dtype[bool_]]
+reveal_type(np.choose([1], AR_b, out=AR_f4))  # E: ndarray[Any, dtype[{float32}]]
+
+reveal_type(np.repeat(b, 1))  # E: ndarray[Any, dtype[bool_]]
+reveal_type(np.repeat(f4, 1))  # E: ndarray[Any, dtype[{float32}]]
+reveal_type(np.repeat(f, 1))  # E: ndarray[Any, dtype[Any]]
+reveal_type(np.repeat(AR_b, 1))  # E: ndarray[Any, dtype[bool_]]
+reveal_type(np.repeat(AR_f4, 1))  # E: ndarray[Any, dtype[{float32}]]
+
+# TODO: array_bdd tests for np.put()
+
+reveal_type(np.swapaxes([[0, 1]], 0, 0))  # E: ndarray[Any, dtype[Any]]
+reveal_type(np.swapaxes(AR_b, 0, 0))  # E: ndarray[Any, dtype[bool_]]
+reveal_type(np.swapaxes(AR_f4, 0, 0))  # E: ndarray[Any, dtype[{float32}]]
+
+reveal_type(np.transpose(b))  # E: ndarray[Any, dtype[bool_]]
+reveal_type(np.transpose(f4))  # E: ndarray[Any, dtype[{float32}]]
+reveal_type(np.transpose(f))  # E: ndarray[Any, dtype[Any]]
+reveal_type(np.transpose(AR_b))  # E: ndarray[Any, dtype[bool_]]
+reveal_type(np.transpose(AR_f4))  # E: ndarray[Any, dtype[{float32}]]
+
+reveal_type(np.partition(b, 0, axis=None))  # E: ndarray[Any, dtype[bool_]]
+reveal_type(np.partition(f4, 0, axis=None))  # E: ndarray[Any, dtype[{float32}]]
+reveal_type(np.partition(f, 0, axis=None))  # E: ndarray[Any, dtype[Any]]
+reveal_type(np.partition(AR_b, 0))  # E: ndarray[Any, dtype[bool_]]
+reveal_type(np.partition(AR_f4, 0))  # E: ndarray[Any, dtype[{float32}]]
+
+reveal_type(np.argpartition(b, 0))  # E: ndarray[Any, dtype[{intp}]]
+reveal_type(np.argpartition(f4, 0))  # E: ndarray[Any, dtype[{intp}]]
+reveal_type(np.argpartition(f, 0))  # E: ndarray[Any, dtype[{intp}]]
+reveal_type(np.argpartition(AR_b, 0))  # E: ndarray[Any, dtype[{intp}]]
+reveal_type(np.argpartition(AR_f4, 0))  # E: ndarray[Any, dtype[{intp}]]
+
+reveal_type(np.sort([2, 1], 0))  # E: ndarray[Any, dtype[Any]]
+reveal_type(np.sort(AR_b, 0))  # E: ndarray[Any, dtype[bool_]]
+reveal_type(np.sort(AR_f4, 0))  # E: ndarray[Any, dtype[{float32}]]
+
+reveal_type(np.argsort(AR_b, 0))  # E: ndarray[Any, dtype[{intp}]]
+reveal_type(np.argsort(AR_f4, 0))  # E: ndarray[Any, dtype[{intp}]]
+
+reveal_type(np.argmax(AR_b))  # E: {intp}
+reveal_type(np.argmax(AR_f4))  # E: {intp}
+reveal_type(np.argmax(AR_b, axis=0))  # E: Any
+reveal_type(np.argmax(AR_f4, axis=0))  # E: Any
+reveal_type(np.argmax(AR_f4, out=AR_subclass))  # E: NDArraySubclass
+
+reveal_type(np.argmin(AR_b))  # E: {intp}
+reveal_type(np.argmin(AR_f4))  # E: {intp}
+reveal_type(np.argmin(AR_b, axis=0))  # E: Any
+reveal_type(np.argmin(AR_f4, axis=0))  # E: Any
+reveal_type(np.argmin(AR_f4, out=AR_subclass))  # E: NDArraySubclass
+
+reveal_type(np.searchsorted(AR_b[0], 0))  # E: {intp}
+reveal_type(np.searchsorted(AR_f4[0], 0))  # E: {intp}
+reveal_type(np.searchsorted(AR_b[0], [0]))  # E: ndarray[Any, dtype[{intp}]]
+reveal_type(np.searchsorted(AR_f4[0], [0]))  # E: ndarray[Any, dtype[{intp}]]
+
+reveal_type(np.resize(b, (5, 5)))  # E: ndarray[Any, dtype[bool_]]
+reveal_type(np.resize(f4, (5, 5)))  # E: ndarray[Any, dtype[{float32}]]
+reveal_type(np.resize(f, (5, 5)))  # E: ndarray[Any, dtype[Any]]
+reveal_type(np.resize(AR_b, (5, 5)))  # E: ndarray[Any, dtype[bool_]]
+reveal_type(np.resize(AR_f4, (5, 5)))  # E: ndarray[Any, dtype[{float32}]]
+
+reveal_type(np.squeeze(b))  # E: bool_
+reveal_type(np.squeeze(f4))  # E: {float32}
+reveal_type(np.squeeze(f))  # E: ndarray[Any, dtype[Any]]
+reveal_type(np.squeeze(AR_b))  # E: ndarray[Any, dtype[bool_]]
+reveal_type(np.squeeze(AR_f4))  # E: ndarray[Any, dtype[{float32}]]
+
+reveal_type(np.diagonal(AR_b))  # E: ndarray[Any, dtype[bool_]]
+reveal_type(np.diagonal(AR_f4))  # E: ndarray[Any, dtype[{float32}]]
+
+reveal_type(np.trace(AR_b))  # E: Any
+reveal_type(np.trace(AR_f4))  # E: Any
+reveal_type(np.trace(AR_f4, out=AR_subclass))  # E: NDArraySubclass
+
+reveal_type(np.ravel(b))  # E: ndarray[Any, dtype[bool_]]
+reveal_type(np.ravel(f4))  # E: ndarray[Any, dtype[{float32}]]
+reveal_type(np.ravel(f))  # E: ndarray[Any, dtype[Any]]
+reveal_type(np.ravel(AR_b))  # E: ndarray[Any, dtype[bool_]]
+reveal_type(np.ravel(AR_f4))  # E: ndarray[Any, dtype[{float32}]]
+
+reveal_type(np.nonzero(b))  # E: tuple[ndarray[Any, dtype[{intp}]], ...]
+reveal_type(np.nonzero(f4))  # E: tuple[ndarray[Any, dtype[{intp}]], ...]
+reveal_type(np.nonzero(f))  # E: tuple[ndarray[Any, dtype[{intp}]], ...]
+reveal_type(np.nonzero(AR_b))  # E: tuple[ndarray[Any, dtype[{intp}]], ...]
+reveal_type(np.nonzero(AR_f4))  # E: tuple[ndarray[Any, dtype[{intp}]], ...]
+
+reveal_type(np.shape(b))  # E: tuple[builtins.int, ...]
+reveal_type(np.shape(f4))  # E: tuple[builtins.int, ...]
+reveal_type(np.shape(f))  # E: tuple[builtins.int, ...]
+reveal_type(np.shape(AR_b))  # E: tuple[builtins.int, ...]
+reveal_type(np.shape(AR_f4))  # E: tuple[builtins.int, ...]
+
+reveal_type(np.compress([True], b))  # E: ndarray[Any, dtype[bool_]]
+reveal_type(np.compress([True], f4))  # E: ndarray[Any, dtype[{float32}]]
+reveal_type(np.compress([True], f))  # E: ndarray[Any, dtype[Any]]
+reveal_type(np.compress([True], AR_b))  # E: ndarray[Any, dtype[bool_]]
+reveal_type(np.compress([True], AR_f4))  # E: ndarray[Any, dtype[{float32}]]
+
+reveal_type(np.clip(b, 0, 1.0))  # E: bool_
+reveal_type(np.clip(f4, -1, 1))  # E: {float32}
+reveal_type(np.clip(f, 0, 1))  # E: Any
+reveal_type(np.clip(AR_b, 0, 1))  # E: ndarray[Any, dtype[bool_]]
+reveal_type(np.clip(AR_f4, 0, 1))  # E: ndarray[Any, dtype[{float32}]]
+reveal_type(np.clip([0], 0, 1))  # E: ndarray[Any, dtype[Any]]
+reveal_type(np.clip(AR_b, 0, 1, out=AR_subclass))  # E: NDArraySubclass
+
+reveal_type(np.sum(b))  # E: bool_
+reveal_type(np.sum(f4))  # E: {float32}
+reveal_type(np.sum(f))  # E: Any
+reveal_type(np.sum(AR_b))  # E: bool_
+reveal_type(np.sum(AR_f4))  # E: {float32}
+reveal_type(np.sum(AR_b, axis=0))  # E: Any
+reveal_type(np.sum(AR_f4, axis=0))  # E: Any
+reveal_type(np.sum(AR_f4, out=AR_subclass))  # E: NDArraySubclass
 
-A = np.array(True, ndmin=2, dtype=bool)
-B = np.array(1.0, ndmin=2, dtype=np.float32)
-A.setflags(write=False)
-B.setflags(write=False)
-
-a = np.bool_(True)
-b = np.float32(1.0)
-c = 1.0
-d = np.array(1.0, dtype=np.float32)  # writeable
-
-reveal_type(np.take(a, 0))  # E: Any
-reveal_type(np.take(b, 0))  # E: Any
-reveal_type(np.take(c, 0))  # E: Any
-reveal_type(np.take(A, 0))  # E: Any
-reveal_type(np.take(B, 0))  # E: Any
-reveal_type(np.take(A, [0]))  # E: Any
-reveal_type(np.take(B, [0]))  # E: Any
-
-reveal_type(np.reshape(a, 1))  # E: ndarray[Any, Any]
-reveal_type(np.reshape(b, 1))  # E: ndarray[Any, Any]
-reveal_type(np.reshape(c, 1))  # E: ndarray[Any, Any]
-reveal_type(np.reshape(A, 1))  # E: ndarray[Any, Any]
-reveal_type(np.reshape(B, 1))  # E: ndarray[Any, Any]
-
-reveal_type(np.choose(a, [True, True]))  # E: Any
-reveal_type(np.choose(A, [True, True]))  # E: Any
-
-reveal_type(np.repeat(a, 1))  # E: ndarray[Any, Any]
-reveal_type(np.repeat(b, 1))  # E: ndarray[Any, Any]
-reveal_type(np.repeat(c, 1))  # E: ndarray[Any, Any]
-reveal_type(np.repeat(A, 1))  # E: ndarray[Any, Any]
-reveal_type(np.repeat(B, 1))  # E: ndarray[Any, Any]
-
-# TODO: Add tests for np.put()
-
-reveal_type(np.swapaxes(A, 0, 0))  # E: ndarray[Any, Any]
-reveal_type(np.swapaxes(B, 0, 0))  # E: ndarray[Any, Any]
-
-reveal_type(np.transpose(a))  # E: ndarray[Any, Any]
-reveal_type(np.transpose(b))  # E: ndarray[Any, Any]
-reveal_type(np.transpose(c))  # E: ndarray[Any, Any]
-reveal_type(np.transpose(A))  # E: ndarray[Any, Any]
-reveal_type(np.transpose(B))  # E: ndarray[Any, Any]
-
-reveal_type(np.partition(a, 0, axis=None))  # E: ndarray[Any, Any]
-reveal_type(np.partition(b, 0, axis=None))  # E: ndarray[Any, Any]
-reveal_type(np.partition(c, 0, axis=None))  # E: ndarray[Any, Any]
-reveal_type(np.partition(A, 0))  # E: ndarray[Any, Any]
-reveal_type(np.partition(B, 0))  # E: ndarray[Any, Any]
-
-reveal_type(np.argpartition(a, 0))  # E: Any
-reveal_type(np.argpartition(b, 0))  # E: Any
-reveal_type(np.argpartition(c, 0))  # E: Any
-reveal_type(np.argpartition(A, 0))  # E: Any
-reveal_type(np.argpartition(B, 0))  # E: Any
-
-reveal_type(np.sort(A, 0))  # E: ndarray[Any, Any]
-reveal_type(np.sort(B, 0))  # E: ndarray[Any, Any]
-
-reveal_type(np.argsort(A, 0))  # E: ndarray[Any, Any]
-reveal_type(np.argsort(B, 0))  # E: ndarray[Any, Any]
-
-reveal_type(np.argmax(A))  # E: {intp}
-reveal_type(np.argmax(B))  # E: {intp}
-reveal_type(np.argmax(A, axis=0))  # E: Any
-reveal_type(np.argmax(B, axis=0))  # E: Any
-
-reveal_type(np.argmin(A))  # E: {intp}
-reveal_type(np.argmin(B))  # E: {intp}
-reveal_type(np.argmin(A, axis=0))  # E: Any
-reveal_type(np.argmin(B, axis=0))  # E: Any
-
-reveal_type(np.searchsorted(A[0], 0))  # E: {intp}
-reveal_type(np.searchsorted(B[0], 0))  # E: {intp}
-reveal_type(np.searchsorted(A[0], [0]))  # E: ndarray[Any, Any]
-reveal_type(np.searchsorted(B[0], [0]))  # E: ndarray[Any, Any]
-
-reveal_type(np.resize(a, (5, 5)))  # E: ndarray[Any, Any]
-reveal_type(np.resize(b, (5, 5)))  # E: ndarray[Any, Any]
-reveal_type(np.resize(c, (5, 5)))  # E: ndarray[Any, Any]
-reveal_type(np.resize(A, (5, 5)))  # E: ndarray[Any, Any]
-reveal_type(np.resize(B, (5, 5)))  # E: ndarray[Any, Any]
-
-reveal_type(np.squeeze(a))  # E: bool_
-reveal_type(np.squeeze(b))  # E: {float32}
-reveal_type(np.squeeze(c))  # E: ndarray[Any, Any]
-reveal_type(np.squeeze(A))  # E: ndarray[Any, Any]
-reveal_type(np.squeeze(B))  # E: ndarray[Any, Any]
-
-reveal_type(np.diagonal(A))  # E: ndarray[Any, Any]
-reveal_type(np.diagonal(B))  # E: ndarray[Any, Any]
-
-reveal_type(np.trace(A))  # E: Any
-reveal_type(np.trace(B))  # E: Any
-
-reveal_type(np.ravel(a))  # E: ndarray[Any, Any]
-reveal_type(np.ravel(b))  # E: ndarray[Any, Any]
-reveal_type(np.ravel(c))  # E: ndarray[Any, Any]
-reveal_type(np.ravel(A))  # E: ndarray[Any, Any]
-reveal_type(np.ravel(B))  # E: ndarray[Any, Any]
-
-reveal_type(np.nonzero(a))  # E: tuple[ndarray[Any, Any]]
-reveal_type(np.nonzero(b))  # E: tuple[ndarray[Any, Any]]
-reveal_type(np.nonzero(c))  # E: tuple[ndarray[Any, Any]]
-reveal_type(np.nonzero(A))  # E: tuple[ndarray[Any, Any]]
-reveal_type(np.nonzero(B))  # E: tuple[ndarray[Any, Any]]
-
-reveal_type(np.shape(a))  # E: tuple[builtins.int]
-reveal_type(np.shape(b))  # E: tuple[builtins.int]
-reveal_type(np.shape(c))  # E: tuple[builtins.int]
-reveal_type(np.shape(A))  # E: tuple[builtins.int]
-reveal_type(np.shape(B))  # E: tuple[builtins.int]
-
-reveal_type(np.compress([True], a))  # E: ndarray[Any, Any]
-reveal_type(np.compress([True], b))  # E: ndarray[Any, Any]
-reveal_type(np.compress([True], c))  # E: ndarray[Any, Any]
-reveal_type(np.compress([True], A))  # E: ndarray[Any, Any]
-reveal_type(np.compress([True], B))  # E: ndarray[Any, Any]
-
-reveal_type(np.clip(a, 0, 1.0))  # E: Any
-reveal_type(np.clip(b, -1, 1))  # E: Any
-reveal_type(np.clip(c, 0, 1))  # E: Any
-reveal_type(np.clip(A, 0, 1))  # E: Any
-reveal_type(np.clip(B, 0, 1))  # E: Any
-
-reveal_type(np.sum(a))  # E: Any
-reveal_type(np.sum(b))  # E: Any
-reveal_type(np.sum(c))  # E: Any
-reveal_type(np.sum(A))  # E: Any
-reveal_type(np.sum(B))  # E: Any
-reveal_type(np.sum(A, axis=0))  # E: Any
-reveal_type(np.sum(B, axis=0))  # E: Any
-
-reveal_type(np.all(a))  # E: bool_
 reveal_type(np.all(b))  # E: bool_
-reveal_type(np.all(c))  # E: bool_
-reveal_type(np.all(A))  # E: bool_
-reveal_type(np.all(B))  # E: bool_
-reveal_type(np.all(A, axis=0))  # E: Any
-reveal_type(np.all(B, axis=0))  # E: Any
-reveal_type(np.all(A, keepdims=True))  # E: Any
-reveal_type(np.all(B, keepdims=True))  # E: Any
-
-reveal_type(np.any(a))  # E: bool_
+reveal_type(np.all(f4))  # E: bool_
+reveal_type(np.all(f))  # E: bool_
+reveal_type(np.all(AR_b))  # E: bool_
+reveal_type(np.all(AR_f4))  # E: bool_
+reveal_type(np.all(AR_b, axis=0))  # E: Any
+reveal_type(np.all(AR_f4, axis=0))  # E: Any
+reveal_type(np.all(AR_b, keepdims=True))  # E: Any
+reveal_type(np.all(AR_f4, keepdims=True))  # E: Any
+reveal_type(np.all(AR_f4, out=AR_subclass))  # E: NDArraySubclass
+
 reveal_type(np.any(b))  # E: bool_
-reveal_type(np.any(c))  # E: bool_
-reveal_type(np.any(A))  # E: bool_
-reveal_type(np.any(B))  # E: bool_
-reveal_type(np.any(A, axis=0))  # E: Any
-reveal_type(np.any(B, axis=0))  # E: Any
-reveal_type(np.any(A, keepdims=True))  # E: Any
-reveal_type(np.any(B, keepdims=True))  # E: Any
-
-reveal_type(np.cumsum(a))  # E: ndarray[Any, Any]
-reveal_type(np.cumsum(b))  # E: ndarray[Any, Any]
-reveal_type(np.cumsum(c))  # E: ndarray[Any, Any]
-reveal_type(np.cumsum(A))  # E: ndarray[Any, Any]
-reveal_type(np.cumsum(B))  # E: ndarray[Any, Any]
-
-reveal_type(np.ptp(a))  # E: Any
-reveal_type(np.ptp(b))  # E: Any
-reveal_type(np.ptp(c))  # E: Any
-reveal_type(np.ptp(A))  # E: Any
-reveal_type(np.ptp(B))  # E: Any
-reveal_type(np.ptp(A, axis=0))  # E: Any
-reveal_type(np.ptp(B, axis=0))  # E: Any
-reveal_type(np.ptp(A, keepdims=True))  # E: Any
-reveal_type(np.ptp(B, keepdims=True))  # E: Any
-
-reveal_type(np.amax(a))  # E: Any
-reveal_type(np.amax(b))  # E: Any
-reveal_type(np.amax(c))  # E: Any
-reveal_type(np.amax(A))  # E: Any
-reveal_type(np.amax(B))  # E: Any
-reveal_type(np.amax(A, axis=0))  # E: Any
-reveal_type(np.amax(B, axis=0))  # E: Any
-reveal_type(np.amax(A, keepdims=True))  # E: Any
-reveal_type(np.amax(B, keepdims=True))  # E: Any
-
-reveal_type(np.amin(a))  # E: Any
-reveal_type(np.amin(b))  # E: Any
-reveal_type(np.amin(c))  # E: Any
-reveal_type(np.amin(A))  # E: Any
-reveal_type(np.amin(B))  # E: Any
-reveal_type(np.amin(A, axis=0))  # E: Any
-reveal_type(np.amin(B, axis=0))  # E: Any
-reveal_type(np.amin(A, keepdims=True))  # E: Any
-reveal_type(np.amin(B, keepdims=True))  # E: Any
-
-reveal_type(np.prod(a))  # E: Any
-reveal_type(np.prod(b))  # E: Any
-reveal_type(np.prod(c))  # E: Any
-reveal_type(np.prod(A))  # E: Any
-reveal_type(np.prod(B))  # E: Any
-reveal_type(np.prod(A, axis=0))  # E: Any
-reveal_type(np.prod(B, axis=0))  # E: Any
-reveal_type(np.prod(A, keepdims=True))  # E: Any
-reveal_type(np.prod(B, keepdims=True))  # E: Any
-reveal_type(np.prod(b, out=d))  # E: Any
-reveal_type(np.prod(B, out=d))  # E: Any
-
-reveal_type(np.cumprod(a))  # E: ndarray[Any, Any]
-reveal_type(np.cumprod(b))  # E: ndarray[Any, Any]
-reveal_type(np.cumprod(c))  # E: ndarray[Any, Any]
-reveal_type(np.cumprod(A))  # E: ndarray[Any, Any]
-reveal_type(np.cumprod(B))  # E: ndarray[Any, Any]
-
-reveal_type(np.ndim(a))  # E: int
+reveal_type(np.any(f4))  # E: bool_
+reveal_type(np.any(f))  # E: bool_
+reveal_type(np.any(AR_b))  # E: bool_
+reveal_type(np.any(AR_f4))  # E: bool_
+reveal_type(np.any(AR_b, axis=0))  # E: Any
+reveal_type(np.any(AR_f4, axis=0))  # E: Any
+reveal_type(np.any(AR_b, keepdims=True))  # E: Any
+reveal_type(np.any(AR_f4, keepdims=True))  # E: Any
+reveal_type(np.any(AR_f4, out=AR_subclass))  # E: NDArraySubclass
+
+reveal_type(np.cumsum(b))  # E: ndarray[Any, dtype[bool_]]
+reveal_type(np.cumsum(f4))  # E: ndarray[Any, dtype[{float32}]]
+reveal_type(np.cumsum(f))  # E: ndarray[Any, dtype[Any]]
+reveal_type(np.cumsum(AR_b))  # E: ndarray[Any, dtype[bool_]]
+reveal_type(np.cumsum(AR_f4))  # E: ndarray[Any, dtype[{float32}]]
+reveal_type(np.cumsum(f, dtype=float))  # E: ndarray[Any, dtype[Any]]
+reveal_type(np.cumsum(f, dtype=np.float64))  # E: ndarray[Any, dtype[{float64}]]
+reveal_type(np.cumsum(AR_f4, out=AR_subclass))  # E: NDArraySubclass
+
+reveal_type(np.ptp(b))  # E: bool_
+reveal_type(np.ptp(f4))  # E: {float32}
+reveal_type(np.ptp(f))  # E: Any
+reveal_type(np.ptp(AR_b))  # E: bool_
+reveal_type(np.ptp(AR_f4))  # E: {float32}
+reveal_type(np.ptp(AR_b, axis=0))  # E: Any
+reveal_type(np.ptp(AR_f4, axis=0))  # E: Any
+reveal_type(np.ptp(AR_b, keepdims=True))  # E: Any
+reveal_type(np.ptp(AR_f4, keepdims=True))  # E: Any
+reveal_type(np.ptp(AR_f4, out=AR_subclass))  # E: NDArraySubclass
+
+reveal_type(np.amax(b))  # E: bool_
+reveal_type(np.amax(f4))  # E: {float32}
+reveal_type(np.amax(f))  # E: Any
+reveal_type(np.amax(AR_b))  # E: bool_
+reveal_type(np.amax(AR_f4))  # E: {float32}
+reveal_type(np.amax(AR_b, axis=0))  # E: Any
+reveal_type(np.amax(AR_f4, axis=0))  # E: Any
+reveal_type(np.amax(AR_b, keepdims=True))  # E: Any
+reveal_type(np.amax(AR_f4, keepdims=True))  # E: Any
+reveal_type(np.amax(AR_f4, out=AR_subclass))  # E: NDArraySubclass
+
+reveal_type(np.amin(b))  # E: bool_
+reveal_type(np.amin(f4))  # E: {float32}
+reveal_type(np.amin(f))  # E: Any
+reveal_type(np.amin(AR_b))  # E: bool_
+reveal_type(np.amin(AR_f4))  # E: {float32}
+reveal_type(np.amin(AR_b, axis=0))  # E: Any
+reveal_type(np.amin(AR_f4, axis=0))  # E: Any
+reveal_type(np.amin(AR_b, keepdims=True))  # E: Any
+reveal_type(np.amin(AR_f4, keepdims=True))  # E: Any
+reveal_type(np.amin(AR_f4, out=AR_subclass))  # E: NDArraySubclass
+
+reveal_type(np.prod(AR_b))  # E: {int_}
+reveal_type(np.prod(AR_u8))  # E: {uint64}
+reveal_type(np.prod(AR_i8))  # E: {int64}
+reveal_type(np.prod(AR_f4))  # E: floating[Any]
+reveal_type(np.prod(AR_c16))  # E: complexfloating[Any, Any]
+reveal_type(np.prod(AR_O))  # E: Any
+reveal_type(np.prod(AR_f4, axis=0))  # E: Any
+reveal_type(np.prod(AR_f4, keepdims=True))  # E: Any
+reveal_type(np.prod(AR_f4, dtype=np.float64))  # E: {float64}
+reveal_type(np.prod(AR_f4, dtype=float))  # E: Any
+reveal_type(np.prod(AR_f4, out=AR_subclass))  # E: NDArraySubclass
+
+reveal_type(np.cumprod(AR_b))  # E: ndarray[Any, dtype[{int_}]]
+reveal_type(np.cumprod(AR_u8))  # E: ndarray[Any, dtype[{uint64}]]
+reveal_type(np.cumprod(AR_i8))  # E: ndarray[Any, dtype[{int64}]]
+reveal_type(np.cumprod(AR_f4))  # E: ndarray[Any, dtype[floating[Any]]]
+reveal_type(np.cumprod(AR_c16))  # E: ndarray[Any, dtype[complexfloating[Any, Any]]]
+reveal_type(np.cumprod(AR_O))  # E: ndarray[Any, dtype[object_]]
+reveal_type(np.cumprod(AR_f4, axis=0))  # E: ndarray[Any, dtype[floating[Any]]]
+reveal_type(np.cumprod(AR_f4, dtype=np.float64))  # E: ndarray[Any, dtype[{float64}]]
+reveal_type(np.cumprod(AR_f4, dtype=float))  # E: ndarray[Any, dtype[Any]]
+reveal_type(np.cumprod(AR_f4, out=AR_subclass))  # E: NDArraySubclass
+
 reveal_type(np.ndim(b))  # E: int
-reveal_type(np.ndim(c))  # E: int
-reveal_type(np.ndim(A))  # E: int
-reveal_type(np.ndim(B))  # E: int
+reveal_type(np.ndim(f4))  # E: int
+reveal_type(np.ndim(f))  # E: int
+reveal_type(np.ndim(AR_b))  # E: int
+reveal_type(np.ndim(AR_f4))  # E: int
 
-reveal_type(np.size(a))  # E: int
 reveal_type(np.size(b))  # E: int
-reveal_type(np.size(c))  # E: int
-reveal_type(np.size(A))  # E: int
-reveal_type(np.size(B))  # E: int
-
-reveal_type(np.around(a))  # E: Any
-reveal_type(np.around(b))  # E: Any
-reveal_type(np.around(c))  # E: Any
-reveal_type(np.around(A))  # E: Any
-reveal_type(np.around(B))  # E: Any
-
-reveal_type(np.mean(a))  # E: Any
-reveal_type(np.mean(b))  # E: Any
-reveal_type(np.mean(c))  # E: Any
-reveal_type(np.mean(A))  # E: Any
-reveal_type(np.mean(B))  # E: Any
-reveal_type(np.mean(A, axis=0))  # E: Any
-reveal_type(np.mean(B, axis=0))  # E: Any
-reveal_type(np.mean(A, keepdims=True))  # E: Any
-reveal_type(np.mean(B, keepdims=True))  # E: Any
-reveal_type(np.mean(b, out=d))  # E: Any
-reveal_type(np.mean(B, out=d))  # E: Any
-
-reveal_type(np.std(a))  # E: Any
-reveal_type(np.std(b))  # E: Any
-reveal_type(np.std(c))  # E: Any
-reveal_type(np.std(A))  # E: Any
-reveal_type(np.std(B))  # E: Any
-reveal_type(np.std(A, axis=0))  # E: Any
-reveal_type(np.std(B, axis=0))  # E: Any
-reveal_type(np.std(A, keepdims=True))  # E: Any
-reveal_type(np.std(B, keepdims=True))  # E: Any
-reveal_type(np.std(b, out=d))  # E: Any
-reveal_type(np.std(B, out=d))  # E: Any
-
-reveal_type(np.var(a))  # E: Any
-reveal_type(np.var(b))  # E: Any
-reveal_type(np.var(c))  # E: Any
-reveal_type(np.var(A))  # E: Any
-reveal_type(np.var(B))  # E: Any
-reveal_type(np.var(A, axis=0))  # E: Any
-reveal_type(np.var(B, axis=0))  # E: Any
-reveal_type(np.var(A, keepdims=True))  # E: Any
-reveal_type(np.var(B, keepdims=True))  # E: Any
-reveal_type(np.var(b, out=d))  # E: Any
-reveal_type(np.var(B, out=d))  # E: Any
+reveal_type(np.size(f4))  # E: int
+reveal_type(np.size(f))  # E: int
+reveal_type(np.size(AR_b))  # E: int
+reveal_type(np.size(AR_f4))  # E: int
+
+reveal_type(np.around(b))  # E: {float16}
+reveal_type(np.around(f))  # E: Any
+reveal_type(np.around(i8))  # E: {int64}
+reveal_type(np.around(f4))  # E: {float32}
+reveal_type(np.around(AR_b))  # E: ndarray[Any, dtype[{float16}]]
+reveal_type(np.around(AR_i8))  # E: ndarray[Any, dtype[{int64}]]
+reveal_type(np.around(AR_f4))  # E: ndarray[Any, dtype[{float32}]]
+reveal_type(np.around([1.5]))  # E: ndarray[Any, dtype[Any]]
+reveal_type(np.around(AR_f4, out=AR_subclass))  # E: NDArraySubclass
+
+reveal_type(np.mean(AR_b))  # E: floating[Any]
+reveal_type(np.mean(AR_i8))  # E: floating[Any]
+reveal_type(np.mean(AR_f4))  # E: floating[Any]
+reveal_type(np.mean(AR_c16))  # E: complexfloating[Any, Any]
+reveal_type(np.mean(AR_O))  # E: Any
+reveal_type(np.mean(AR_f4, axis=0))  # E: Any
+reveal_type(np.mean(AR_f4, keepdims=True))  # E: Any
+reveal_type(np.mean(AR_f4, dtype=float))  # E: Any
+reveal_type(np.mean(AR_f4, dtype=np.float64))  # E: {float64}
+reveal_type(np.mean(AR_f4, out=AR_subclass))  # E: NDArraySubclass
+
+reveal_type(np.std(AR_b))  # E: floating[Any]
+reveal_type(np.std(AR_i8))  # E: floating[Any]
+reveal_type(np.std(AR_f4))  # E: floating[Any]
+reveal_type(np.std(AR_c16))  # E: floating[Any]
+reveal_type(np.std(AR_O))  # E: Any
+reveal_type(np.std(AR_f4, axis=0))  # E: Any
+reveal_type(np.std(AR_f4, keepdims=True))  # E: Any
+reveal_type(np.std(AR_f4, dtype=float))  # E: Any
+reveal_type(np.std(AR_f4, dtype=np.float64))  # E: {float64}
+reveal_type(np.std(AR_f4, out=AR_subclass))  # E: NDArraySubclass
+
+reveal_type(np.var(AR_b))  # E: floating[Any]
+reveal_type(np.var(AR_i8))  # E: floating[Any]
+reveal_type(np.var(AR_f4))  # E: floating[Any]
+reveal_type(np.var(AR_c16))  # E: floating[Any]
+reveal_type(np.var(AR_O))  # E: Any
+reveal_type(np.var(AR_f4, axis=0))  # E: Any
+reveal_type(np.var(AR_f4, keepdims=True))  # E: Any
+reveal_type(np.var(AR_f4, dtype=float))  # E: Any
+reveal_type(np.var(AR_f4, dtype=np.float64))  # E: {float64}
+reveal_type(np.var(AR_f4, out=AR_subclass))  # E: NDArraySubclass
diff --git a/numpy/typing/tests/data/reveal/index_tricks.pyi b/numpy/typing/tests/data/reveal/index_tricks.pyi
index cee4d8c3e7e6..707d6f3d42f9 100644
--- a/numpy/typing/tests/data/reveal/index_tricks.pyi
+++ b/numpy/typing/tests/data/reveal/index_tricks.pyi
@@ -1,10 +1,10 @@
-from typing import Any, List
+from typing import Any
 import numpy as np
 
-AR_LIKE_b: List[bool]
-AR_LIKE_i: List[int]
-AR_LIKE_f: List[float]
-AR_LIKE_U: List[str]
+AR_LIKE_b: list[bool]
+AR_LIKE_i: list[int]
+AR_LIKE_f: list[float]
+AR_LIKE_U: list[str]
 
 AR_i8: np.ndarray[Any, np.dtype[np.int64]]
 
@@ -16,20 +16,22 @@ reveal_type(np.ndenumerate(AR_i8).iter)  # E: flatiter[ndarray[Any, dtype[{int64
 reveal_type(np.ndenumerate(AR_LIKE_f).iter)  # E: flatiter[ndarray[Any, dtype[{double}]]]
 reveal_type(np.ndenumerate(AR_LIKE_U).iter)  # E: flatiter[ndarray[Any, dtype[str_]]]
 
-reveal_type(next(np.ndenumerate(AR_i8)))  # E: Tuple[builtins.tuple[builtins.int], {int64}]
-reveal_type(next(np.ndenumerate(AR_LIKE_f)))  # E: Tuple[builtins.tuple[builtins.int], {double}]
-reveal_type(next(np.ndenumerate(AR_LIKE_U)))  # E: Tuple[builtins.tuple[builtins.int], str_]
+reveal_type(next(np.ndenumerate(AR_i8)))  # E: Tuple[builtins.tuple[builtins.int, ...], {int64}]
+reveal_type(next(np.ndenumerate(AR_LIKE_f)))  # E: Tuple[builtins.tuple[builtins.int, ...], {double}]
+reveal_type(next(np.ndenumerate(AR_LIKE_U)))  # E: Tuple[builtins.tuple[builtins.int, ...], str_]
 
-reveal_type(iter(np.ndenumerate(AR_i8)))  # E: Iterator[Tuple[builtins.tuple[builtins.int], {int64}]]
-reveal_type(iter(np.ndenumerate(AR_LIKE_f)))  # E: Iterator[Tuple[builtins.tuple[builtins.int], {double}]]
-reveal_type(iter(np.ndenumerate(AR_LIKE_U)))  # E: Iterator[Tuple[builtins.tuple[builtins.int], str_]]
+reveal_type(iter(np.ndenumerate(AR_i8)))  # E: ndenumerate[{int64}]
+reveal_type(iter(np.ndenumerate(AR_LIKE_f)))  # E: ndenumerate[{double}]
+reveal_type(iter(np.ndenumerate(AR_LIKE_U)))  # E: ndenumerate[str_]
 
-reveal_type(iter(np.ndindex(1, 2, 3)))  # E: Iterator[builtins.tuple[builtins.int]]
-reveal_type(next(np.ndindex(1, 2, 3)))  # E: builtins.tuple[builtins.int]
+reveal_type(np.ndindex(1, 2, 3))  # E: numpy.ndindex
+reveal_type(np.ndindex((1, 2, 3)))  # E: numpy.ndindex
+reveal_type(iter(np.ndindex(1, 2, 3)))  # E: ndindex
+reveal_type(next(np.ndindex(1, 2, 3)))  # E: builtins.tuple[builtins.int, ...]
 
-reveal_type(np.unravel_index([22, 41, 37], (7, 6)))  # E: tuple[ndarray[Any, dtype[{intp}]]]
-reveal_type(np.unravel_index([31, 41, 13], (7, 6), order="F"))  # E: tuple[ndarray[Any, dtype[{intp}]]]
-reveal_type(np.unravel_index(1621, (6, 7, 8, 9)))  # E: tuple[{intp}]
+reveal_type(np.unravel_index([22, 41, 37], (7, 6)))  # E: tuple[ndarray[Any, dtype[{intp}]], ...]
+reveal_type(np.unravel_index([31, 41, 13], (7, 6), order="F"))  # E: tuple[ndarray[Any, dtype[{intp}]], ...]
+reveal_type(np.unravel_index(1621, (6, 7, 8, 9)))  # E: tuple[{intp}, ...]
 
 reveal_type(np.ravel_multi_index([[1]], (7, 6)))  # E: ndarray[Any, dtype[{intp}]]
 reveal_type(np.ravel_multi_index(AR_LIKE_i, (7, 6)))  # E: {intp}
@@ -52,13 +54,13 @@ reveal_type(np.s_[0:1])  # E: builtins.slice
 reveal_type(np.s_[0:1, None:3])  # E: Tuple[builtins.slice, builtins.slice]
 reveal_type(np.s_[0, 0:1, ..., [0, 1, 3]])  # E: Tuple[Literal[0]?, builtins.slice, builtins.ellipsis, builtins.list[builtins.int]]
 
-reveal_type(np.ix_(AR_LIKE_b))  # E: tuple[ndarray[Any, dtype[bool_]]]
-reveal_type(np.ix_(AR_LIKE_i, AR_LIKE_f))  # E: tuple[ndarray[Any, dtype[{double}]]]
-reveal_type(np.ix_(AR_i8))  # E: tuple[ndarray[Any, dtype[{int64}]]]
+reveal_type(np.ix_(AR_LIKE_b))  # E: tuple[ndarray[Any, dtype[bool_]], ...]
+reveal_type(np.ix_(AR_LIKE_i, AR_LIKE_f))  # E: tuple[ndarray[Any, dtype[{double}]], ...]
+reveal_type(np.ix_(AR_i8))  # E: tuple[ndarray[Any, dtype[{int64}]], ...]
 
 reveal_type(np.fill_diagonal(AR_i8, 5))  # E: None
 
-reveal_type(np.diag_indices(4))  # E: tuple[ndarray[Any, dtype[{int_}]]]
-reveal_type(np.diag_indices(2, 3))  # E: tuple[ndarray[Any, dtype[{int_}]]]
+reveal_type(np.diag_indices(4))  # E: tuple[ndarray[Any, dtype[{int_}]], ...]
+reveal_type(np.diag_indices(2, 3))  # E: tuple[ndarray[Any, dtype[{int_}]], ...]
 
-reveal_type(np.diag_indices_from(AR_i8))  # E: tuple[ndarray[Any, dtype[{int_}]]]
+reveal_type(np.diag_indices_from(AR_i8))  # E: tuple[ndarray[Any, dtype[{int_}]], ...]
diff --git a/numpy/typing/tests/data/reveal/lib_function_base.pyi b/numpy/typing/tests/data/reveal/lib_function_base.pyi
index c559eb295893..a8b9b01ac934 100644
--- a/numpy/typing/tests/data/reveal/lib_function_base.pyi
+++ b/numpy/typing/tests/data/reveal/lib_function_base.pyi
@@ -26,7 +26,7 @@ reveal_type(vectorized_func.signature)  # E: Union[None, builtins.str]
 reveal_type(vectorized_func.otypes)  # E: Union[None, builtins.str]
 reveal_type(vectorized_func.excluded)  # E: set[Union[builtins.int, builtins.str]]
 reveal_type(vectorized_func.__doc__)  # E: Union[None, builtins.str]
-reveal_type(vectorized_func([1]))  # E: ndarray[Any, dtype[Any]]
+reveal_type(vectorized_func([1]))  # E: Any
 reveal_type(np.vectorize(int))  # E: vectorize
 reveal_type(np.vectorize(  # E: vectorize
     int, otypes="i", doc="doc", excluded=(), cache=True, signature=None
@@ -79,9 +79,10 @@ reveal_type(np.diff("bob", n=0))  # E: str
 reveal_type(np.diff(AR_f8, axis=0))  # E: ndarray[Any, dtype[Any]]
 reveal_type(np.diff(AR_LIKE_f8, prepend=1.5))  # E: ndarray[Any, dtype[Any]]
 
-reveal_type(np.angle(AR_f8))  # E: floating[Any]
-reveal_type(np.angle(AR_c16, deg=True))  # E: complexfloating[Any, Any]
-reveal_type(np.angle(AR_O))  # E: Any
+reveal_type(np.angle(f8))  # E: floating[Any]
+reveal_type(np.angle(AR_f8))  # E: ndarray[Any, dtype[floating[Any]]]
+reveal_type(np.angle(AR_c16, deg=True))  # E: ndarray[Any, dtype[floating[Any]]]
+reveal_type(np.angle(AR_O))  # E: ndarray[Any, dtype[object_]]
 
 reveal_type(np.unwrap(AR_f8))  # E: ndarray[Any, dtype[floating[Any]]]
 reveal_type(np.unwrap(AR_O))  # E: ndarray[Any, dtype[object_]]
@@ -122,10 +123,6 @@ reveal_type(np.sinc(1j))  # E: complexfloating[Any, Any]
 reveal_type(np.sinc(AR_f8))  # E: ndarray[Any, dtype[floating[Any]]]
 reveal_type(np.sinc(AR_c16))  # E: ndarray[Any, dtype[complexfloating[Any, Any]]]
 
-reveal_type(np.msort(CHAR_AR_U))  # E: Any
-reveal_type(np.msort(AR_U))  # E: ndarray[Any, dtype[str_]]
-reveal_type(np.msort(AR_LIKE_f8))  # E: ndarray[Any, dtype[Any]]
-
 reveal_type(np.median(AR_f8, keepdims=False))  # E: floating[Any]
 reveal_type(np.median(AR_c16, overwrite_input=True))  # E: complexfloating[Any, Any]
 reveal_type(np.median(AR_m))  # E: timedelta64
diff --git a/numpy/typing/tests/data/reveal/lib_utils.pyi b/numpy/typing/tests/data/reveal/lib_utils.pyi
index d820127078a3..9b1bf4123da7 100644
--- a/numpy/typing/tests/data/reveal/lib_utils.pyi
+++ b/numpy/typing/tests/data/reveal/lib_utils.pyi
@@ -1,10 +1,10 @@
 from io import StringIO
-from typing import Any, Dict
+from typing import Any
 
 import numpy as np
 
 AR: np.ndarray[Any, np.dtype[np.float64]]
-AR_DICT: Dict[str, np.ndarray[Any, np.dtype[np.float64]]]
+AR_DICT: dict[str, np.ndarray[Any, np.dtype[np.float64]]]
 FILE: StringIO
 
 def func(a: int) -> bool: ...
diff --git a/numpy/typing/tests/data/reveal/memmap.pyi b/numpy/typing/tests/data/reveal/memmap.pyi
index 86de8eb08e28..af730749920b 100644
--- a/numpy/typing/tests/data/reveal/memmap.pyi
+++ b/numpy/typing/tests/data/reveal/memmap.pyi
@@ -14,3 +14,5 @@ reveal_type(np.memmap("file.txt", offset=5))  # E: memmap[Any, dtype[{uint8}]]
 reveal_type(np.memmap(b"file.txt", dtype=np.float64, shape=(10, 3)))  # E: memmap[Any, dtype[{float64}]]
 with open("file.txt", "rb") as f:
     reveal_type(np.memmap(f, dtype=float, order="K"))  # E: memmap[Any, dtype[Any]]
+
+reveal_type(memmap_obj.__array_finalize__(object()))  # E: None
diff --git a/numpy/typing/tests/data/reveal/multiarray.pyi b/numpy/typing/tests/data/reveal/multiarray.pyi
index 0e91a7afdc52..27a54f50d6e7 100644
--- a/numpy/typing/tests/data/reveal/multiarray.pyi
+++ b/numpy/typing/tests/data/reveal/multiarray.pyi
@@ -1,4 +1,5 @@
-from typing import Any, List, TypeVar
+import datetime as dt
+from typing import Any, TypeVar
 from pathlib import Path
 
 import numpy as np
@@ -16,8 +17,8 @@ AR_u1: npt.NDArray[np.uint8]
 AR_m: npt.NDArray[np.timedelta64]
 AR_M: npt.NDArray[np.datetime64]
 
-AR_LIKE_f: List[float]
-AR_LIKE_i: List[int]
+AR_LIKE_f: list[float]
+AR_LIKE_i: list[int]
 
 m: np.timedelta64
 M: np.datetime64
@@ -27,31 +28,35 @@ b_i8_f8_f8 = np.broadcast(AR_i8, AR_f8, AR_f8)
 
 nditer_obj: np.nditer
 
+date_scalar: dt.date
+date_seq: list[dt.date]
+timedelta_seq: list[dt.timedelta]
+
 def func(a: int) -> bool: ...
 
-reveal_type(next(b_f8))  # E: tuple[Any]
+reveal_type(next(b_f8))  # E: tuple[Any, ...]
 reveal_type(b_f8.reset())  # E: None
 reveal_type(b_f8.index)  # E: int
-reveal_type(b_f8.iters)  # E: tuple[flatiter[Any]]
+reveal_type(b_f8.iters)  # E: tuple[flatiter[Any], ...]
 reveal_type(b_f8.nd)  # E: int
 reveal_type(b_f8.ndim)  # E: int
 reveal_type(b_f8.numiter)  # E: int
-reveal_type(b_f8.shape)  # E: tuple[builtins.int]
+reveal_type(b_f8.shape)  # E: tuple[builtins.int, ...]
 reveal_type(b_f8.size)  # E: int
 
-reveal_type(next(b_i8_f8_f8))  # E: tuple[Any]
+reveal_type(next(b_i8_f8_f8))  # E: tuple[Any, ...]
 reveal_type(b_i8_f8_f8.reset())  # E: None
 reveal_type(b_i8_f8_f8.index)  # E: int
-reveal_type(b_i8_f8_f8.iters)  # E: tuple[flatiter[Any]]
+reveal_type(b_i8_f8_f8.iters)  # E: tuple[flatiter[Any], ...]
 reveal_type(b_i8_f8_f8.nd)  # E: int
 reveal_type(b_i8_f8_f8.ndim)  # E: int
 reveal_type(b_i8_f8_f8.numiter)  # E: int
-reveal_type(b_i8_f8_f8.shape)  # E: tuple[builtins.int]
+reveal_type(b_i8_f8_f8.shape)  # E: tuple[builtins.int, ...]
 reveal_type(b_i8_f8_f8.size)  # E: int
 
 reveal_type(np.inner(AR_f8, AR_i8))  # E: Any
 
-reveal_type(np.where([True, True, False]))  # E: tuple[ndarray[Any, dtype[{intp}]]]
+reveal_type(np.where([True, True, False]))  # E: tuple[ndarray[Any, dtype[{intp}]], ...]
 reveal_type(np.where([True, True, False], 1, 0))  # E: ndarray[Any, dtype[Any]]
 
 reveal_type(np.lexsort([0, 1, 2]))  # E: Any
@@ -108,25 +113,32 @@ reveal_type(np.datetime_data(np.dtype(np.timedelta64)))  # E: Tuple[builtins.str
 
 reveal_type(np.busday_count("2011-01", "2011-02"))  # E: {int_}
 reveal_type(np.busday_count(["2011-01"], "2011-02"))  # E: ndarray[Any, dtype[{int_}]]
+reveal_type(np.busday_count(["2011-01"], date_scalar))  # E: ndarray[Any, dtype[{int_}]]
 
 reveal_type(np.busday_offset(M, m))  # E: datetime64
+reveal_type(np.busday_offset(date_scalar, m))  # E: datetime64
 reveal_type(np.busday_offset(M, 5))  # E: datetime64
 reveal_type(np.busday_offset(AR_M, m))  # E: ndarray[Any, dtype[datetime64]]
+reveal_type(np.busday_offset(M, timedelta_seq))  # E: ndarray[Any, dtype[datetime64]]
 reveal_type(np.busday_offset("2011-01", "2011-02", roll="forward"))  # E: datetime64
 reveal_type(np.busday_offset(["2011-01"], "2011-02", roll="forward"))  # E: ndarray[Any, dtype[datetime64]]
 
 reveal_type(np.is_busday("2012"))  # E: bool_
+reveal_type(np.is_busday(date_scalar))  # E: bool_
 reveal_type(np.is_busday(["2012"]))  # E: ndarray[Any, dtype[bool_]]
 
 reveal_type(np.datetime_as_string(M))  # E: str_
 reveal_type(np.datetime_as_string(AR_M))  # E: ndarray[Any, dtype[str_]]
 
+reveal_type(np.busdaycalendar(holidays=date_seq))  # E: busdaycalendar
+reveal_type(np.busdaycalendar(holidays=[M]))  # E: busdaycalendar
+
 reveal_type(np.compare_chararrays("a", "b", "!=", rstrip=False))  # E: ndarray[Any, dtype[bool_]]
 reveal_type(np.compare_chararrays(b"a", b"a", "==", True))  # E: ndarray[Any, dtype[bool_]]
 
 reveal_type(np.add_docstring(func, "test"))  # E: None
 
-reveal_type(np.nested_iters([AR_i8, AR_i8], [[0], [1]], flags=["c_index"]))  # E: tuple[nditer]
-reveal_type(np.nested_iters([AR_i8, AR_i8], [[0], [1]], op_flags=[["readonly", "readonly"]]))  # E: tuple[nditer]
-reveal_type(np.nested_iters([AR_i8, AR_i8], [[0], [1]], op_dtypes=np.int_))  # E: tuple[nditer]
-reveal_type(np.nested_iters([AR_i8, AR_i8], [[0], [1]], order="C", casting="no"))  # E: tuple[nditer]
+reveal_type(np.nested_iters([AR_i8, AR_i8], [[0], [1]], flags=["c_index"]))  # E: tuple[nditer, ...]
+reveal_type(np.nested_iters([AR_i8, AR_i8], [[0], [1]], op_flags=[["readonly", "readonly"]]))  # E: tuple[nditer, ...]
+reveal_type(np.nested_iters([AR_i8, AR_i8], [[0], [1]], op_dtypes=np.int_))  # E: tuple[nditer, ...]
+reveal_type(np.nested_iters([AR_i8, AR_i8], [[0], [1]], order="C", casting="no"))  # E: tuple[nditer, ...]
diff --git a/numpy/typing/tests/data/reveal/nbit_base_example.pyi b/numpy/typing/tests/data/reveal/nbit_base_example.pyi
index d34f6f69a31d..a7cc681947ea 100644
--- a/numpy/typing/tests/data/reveal/nbit_base_example.pyi
+++ b/numpy/typing/tests/data/reveal/nbit_base_example.pyi
@@ -1,11 +1,13 @@
-from typing import TypeVar, Union
+from __future__ import annotations
+
+from typing import TypeVar
 import numpy as np
 import numpy.typing as npt
 
 T1 = TypeVar("T1", bound=npt.NBitBase)
 T2 = TypeVar("T2", bound=npt.NBitBase)
 
-def add(a: np.floating[T1], b: np.integer[T2]) -> np.floating[Union[T1, T2]]:
+def add(a: np.floating[T1], b: np.integer[T2]) -> np.floating[T1 | T2]:
     return a + b
 
 i8: np.int64
diff --git a/numpy/typing/tests/data/reveal/ndarray_misc.pyi b/numpy/typing/tests/data/reveal/ndarray_misc.pyi
index cd1c3136f288..03fea72dc2bd 100644
--- a/numpy/typing/tests/data/reveal/ndarray_misc.pyi
+++ b/numpy/typing/tests/data/reveal/ndarray_misc.pyi
@@ -11,7 +11,7 @@ import ctypes as ct
 from typing import Any
 
 import numpy as np
-from numpy.typing import NDArray
+from numpy._typing import NDArray
 
 class SubClass(NDArray[np.object_]): ...
 
@@ -24,6 +24,9 @@ AR_V: NDArray[np.void]
 
 ctypes_obj = AR_f8.ctypes
 
+reveal_type(AR_f8.__dlpack__())  # E: Any
+reveal_type(AR_f8.__dlpack_device__())  # E: Tuple[int, Literal[0]]
+
 reveal_type(ctypes_obj.data)  # E: int
 reveal_type(ctypes_obj.shape)  # E: ctypes.Array[{c_intp}]
 reveal_type(ctypes_obj.strides)  # E: ctypes.Array[{c_intp}]
@@ -162,7 +165,7 @@ reveal_type(AR_f8.dot(1))  # E: ndarray[Any, Any]
 reveal_type(AR_f8.dot([1]))  # E: Any
 reveal_type(AR_f8.dot(1, out=B))  # E: SubClass
 
-reveal_type(AR_f8.nonzero())  # E: tuple[ndarray[Any, dtype[{intp}]]]
+reveal_type(AR_f8.nonzero())  # E: tuple[ndarray[Any, dtype[{intp}]], ...]
 
 reveal_type(AR_f8.searchsorted(1))  # E: {intp}
 reveal_type(AR_f8.searchsorted([1]))  # E: ndarray[Any, dtype[{intp}]]
@@ -197,10 +200,12 @@ reveal_type(AR_f8.__array_wrap__(B))  # E: ndarray[Any, dtype[object_]]
 
 reveal_type(AR_V[0])  # E: Any
 reveal_type(AR_V[0, 0])  # E: Any
-reveal_type(AR_V[AR_i8])  # E: Any
-reveal_type(AR_V[AR_i8, AR_i8])  # E: Any
+reveal_type(AR_V[AR_i8])  # E: ndarray[Any, dtype[void]]
+reveal_type(AR_V[AR_i8, AR_i8])  # E: ndarray[Any, dtype[void]]
 reveal_type(AR_V[AR_i8, None])  # E: ndarray[Any, dtype[void]]
 reveal_type(AR_V[0, ...])  # E: ndarray[Any, dtype[void]]
+reveal_type(AR_V[[0]])  # E: ndarray[Any, dtype[void]]
+reveal_type(AR_V[[0], [0]])  # E: ndarray[Any, dtype[void]]
 reveal_type(AR_V[:])  # E: ndarray[Any, dtype[void]]
 reveal_type(AR_V["a"])  # E: ndarray[Any, dtype[Any]]
 reveal_type(AR_V[["a", "b"]])  # E: ndarray[Any, dtype[void]]
@@ -209,3 +214,7 @@ reveal_type(AR_f8.dump("test_file"))  # E: None
 reveal_type(AR_f8.dump(b"test_file"))  # E: None
 with open("test_file", "wb") as f:
     reveal_type(AR_f8.dump(f))  # E: None
+
+reveal_type(AR_f8.__array_finalize__(None))  # E: None
+reveal_type(AR_f8.__array_finalize__(B))  # E: None
+reveal_type(AR_f8.__array_finalize__(AR_f8))  # E: None
diff --git a/numpy/typing/tests/data/reveal/nditer.pyi b/numpy/typing/tests/data/reveal/nditer.pyi
index 65861da54c16..fd8b7e1094fc 100644
--- a/numpy/typing/tests/data/reveal/nditer.pyi
+++ b/numpy/typing/tests/data/reveal/nditer.pyi
@@ -7,7 +7,7 @@ reveal_type(np.nditer([0, 1], op_flags=[["readonly", "readonly"]]))  # E: nditer
 reveal_type(np.nditer([0, 1], op_dtypes=np.int_))  # E: nditer
 reveal_type(np.nditer([0, 1], order="C", casting="no"))  # E: nditer
 
-reveal_type(nditer_obj.dtypes)  # E: tuple[dtype[Any]]
+reveal_type(nditer_obj.dtypes)  # E: tuple[dtype[Any], ...]
 reveal_type(nditer_obj.finished)  # E: bool
 reveal_type(nditer_obj.has_delayed_bufalloc)  # E: bool
 reveal_type(nditer_obj.has_index)  # E: bool
@@ -15,15 +15,15 @@ reveal_type(nditer_obj.has_multi_index)  # E: bool
 reveal_type(nditer_obj.index)  # E: int
 reveal_type(nditer_obj.iterationneedsapi)  # E: bool
 reveal_type(nditer_obj.iterindex)  # E: int
-reveal_type(nditer_obj.iterrange)  # E: tuple[builtins.int]
+reveal_type(nditer_obj.iterrange)  # E: tuple[builtins.int, ...]
 reveal_type(nditer_obj.itersize)  # E: int
-reveal_type(nditer_obj.itviews)  # E: tuple[ndarray[Any, dtype[Any]]]
-reveal_type(nditer_obj.multi_index)  # E: tuple[builtins.int]
+reveal_type(nditer_obj.itviews)  # E: tuple[ndarray[Any, dtype[Any]], ...]
+reveal_type(nditer_obj.multi_index)  # E: tuple[builtins.int, ...]
 reveal_type(nditer_obj.ndim)  # E: int
 reveal_type(nditer_obj.nop)  # E: int
-reveal_type(nditer_obj.operands)  # E: tuple[ndarray[Any, dtype[Any]]]
-reveal_type(nditer_obj.shape)  # E: tuple[builtins.int]
-reveal_type(nditer_obj.value)  # E: tuple[ndarray[Any, dtype[Any]]]
+reveal_type(nditer_obj.operands)  # E: tuple[ndarray[Any, dtype[Any]], ...]
+reveal_type(nditer_obj.shape)  # E: tuple[builtins.int, ...]
+reveal_type(nditer_obj.value)  # E: tuple[ndarray[Any, dtype[Any]], ...]
 
 reveal_type(nditer_obj.close())  # E: None
 reveal_type(nditer_obj.copy())  # E: nditer
@@ -35,12 +35,12 @@ reveal_type(nditer_obj.remove_multi_index())  # E: None
 reveal_type(nditer_obj.reset())  # E: None
 
 reveal_type(len(nditer_obj))  # E: int
-reveal_type(iter(nditer_obj))  # E: Iterator[builtins.tuple[ndarray[Any, dtype[Any]]]]
-reveal_type(next(nditer_obj))  # E: tuple[ndarray[Any, dtype[Any]]]
+reveal_type(iter(nditer_obj))  # E: nditer
+reveal_type(next(nditer_obj))  # E: tuple[ndarray[Any, dtype[Any]], ...]
 reveal_type(nditer_obj.__copy__())  # E: nditer
 with nditer_obj as f:
     reveal_type(f)  # E: nditer
 reveal_type(nditer_obj[0])  # E: ndarray[Any, dtype[Any]]
-reveal_type(nditer_obj[:])  # E: tuple[ndarray[Any, dtype[Any]]]
+reveal_type(nditer_obj[:])  # E: tuple[ndarray[Any, dtype[Any]], ...]
 nditer_obj[0] = 0
 nditer_obj[:] = [0, 1]
diff --git a/numpy/typing/tests/data/reveal/nested_sequence.pyi b/numpy/typing/tests/data/reveal/nested_sequence.pyi
index 4d3aad467efc..286f75ac5c44 100644
--- a/numpy/typing/tests/data/reveal/nested_sequence.pyi
+++ b/numpy/typing/tests/data/reveal/nested_sequence.pyi
@@ -1,16 +1,18 @@
-from typing import Sequence, Tuple, List, Any
-import numpy.typing as npt
+from collections.abc import Sequence
+from typing import Any
+
+from numpy._typing import _NestedSequence
 
 a: Sequence[int]
 b: Sequence[Sequence[int]]
 c: Sequence[Sequence[Sequence[int]]]
 d: Sequence[Sequence[Sequence[Sequence[int]]]]
 e: Sequence[bool]
-f: Tuple[int, ...]
-g: List[int]
+f: tuple[int, ...]
+g: list[int]
 h: Sequence[Any]
 
-def func(a: npt._NestedSequence[int]) -> None:
+def func(a: _NestedSequence[int]) -> None:
     ...
 
 reveal_type(func(a))  # E: None
diff --git a/numpy/typing/tests/data/reveal/npyio.pyi b/numpy/typing/tests/data/reveal/npyio.pyi
index f54fbf610161..68605cf94601 100644
--- a/numpy/typing/tests/data/reveal/npyio.pyi
+++ b/numpy/typing/tests/data/reveal/npyio.pyi
@@ -1,6 +1,6 @@
 import re
 import pathlib
-from typing import IO, List
+from typing import IO
 
 import numpy.typing as npt
 import numpy as np
@@ -14,7 +14,7 @@ bag_obj: np.lib.npyio.BagObj[int]
 npz_file: np.lib.npyio.NpzFile
 
 AR_i8: npt.NDArray[np.int64]
-AR_LIKE_f8: List[float]
+AR_LIKE_f8: list[float]
 
 class BytesWriter:
     def write(self, data: bytes) -> None: ...
@@ -64,6 +64,7 @@ reveal_type(np.loadtxt(bytes_file))  # E: ndarray[Any, dtype[{float64}]]
 reveal_type(np.loadtxt(pathlib_path, dtype=np.str_))  # E: ndarray[Any, dtype[str_]]
 reveal_type(np.loadtxt(str_path, dtype=str, skiprows=2))  # E: ndarray[Any, dtype[Any]]
 reveal_type(np.loadtxt(str_file, comments="test"))  # E: ndarray[Any, dtype[{float64}]]
+reveal_type(np.loadtxt(str_file, comments=None))  # E: ndarray[Any, dtype[{float64}]]
 reveal_type(np.loadtxt(str_path, delimiter="\n"))  # E: ndarray[Any, dtype[{float64}]]
 reveal_type(np.loadtxt(str_path, ndmin=2))  # E: ndarray[Any, dtype[{float64}]]
 reveal_type(np.loadtxt(["1", "2", "3"]))  # E: ndarray[Any, dtype[{float64}]]
@@ -76,7 +77,7 @@ reveal_type(np.fromregex(bytes_reader, "test", np.float64))  # E: ndarray[Any, d
 
 reveal_type(np.genfromtxt(bytes_file))  # E: ndarray[Any, dtype[{float64}]]
 reveal_type(np.genfromtxt(pathlib_path, dtype=np.str_))  # E: ndarray[Any, dtype[str_]]
-reveal_type(np.genfromtxt(str_path, dtype=str, skiprows=2))  # E: ndarray[Any, dtype[Any]]
+reveal_type(np.genfromtxt(str_path, dtype=str, skip_header=2))  # E: ndarray[Any, dtype[Any]]
 reveal_type(np.genfromtxt(str_file, comments="test"))  # E: ndarray[Any, dtype[{float64}]]
 reveal_type(np.genfromtxt(str_path, delimiter="\n"))  # E: ndarray[Any, dtype[{float64}]]
 reveal_type(np.genfromtxt(str_path, ndmin=2))  # E: ndarray[Any, dtype[{float64}]]
diff --git a/numpy/typing/tests/data/reveal/numeric.pyi b/numpy/typing/tests/data/reveal/numeric.pyi
index bf5653937c19..b8fe15d3a08a 100644
--- a/numpy/typing/tests/data/reveal/numeric.pyi
+++ b/numpy/typing/tests/data/reveal/numeric.pyi
@@ -5,7 +5,6 @@ Does not include tests which fall under ``array_constructors``.
 
 """
 
-from typing import List
 import numpy as np
 import numpy.typing as npt
 
@@ -22,7 +21,7 @@ AR_c16: npt.NDArray[np.complex128]
 AR_m: npt.NDArray[np.timedelta64]
 AR_O: npt.NDArray[np.object_]
 
-B: List[int]
+B: list[int]
 C: SubClass
 
 reveal_type(np.count_nonzero(i8))  # E: int
@@ -106,11 +105,11 @@ reveal_type(np.cross(AR_i8, AR_c16))  # E: ndarray[Any, dtype[complexfloating[An
 reveal_type(np.cross(AR_O, AR_O))  # E: ndarray[Any, dtype[object_]]
 
 reveal_type(np.indices([0, 1, 2]))  # E: ndarray[Any, dtype[{int_}]]
-reveal_type(np.indices([0, 1, 2], sparse=True))  # E: tuple[ndarray[Any, dtype[{int_}]]]
+reveal_type(np.indices([0, 1, 2], sparse=True))  # E: tuple[ndarray[Any, dtype[{int_}]], ...]
 reveal_type(np.indices([0, 1, 2], dtype=np.float64))  # E: ndarray[Any, dtype[{float64}]]
-reveal_type(np.indices([0, 1, 2], sparse=True, dtype=np.float64))  # E: tuple[ndarray[Any, dtype[{float64}]]]
+reveal_type(np.indices([0, 1, 2], sparse=True, dtype=np.float64))  # E: tuple[ndarray[Any, dtype[{float64}]], ...]
 reveal_type(np.indices([0, 1, 2], dtype=float))  # E: ndarray[Any, dtype[Any]]
-reveal_type(np.indices([0, 1, 2], sparse=True, dtype=float))  # E: tuple[ndarray[Any, dtype[Any]]]
+reveal_type(np.indices([0, 1, 2], sparse=True, dtype=float))  # E: tuple[ndarray[Any, dtype[Any]], ...]
 
 reveal_type(np.binary_repr(1))  # E: str
 
diff --git a/numpy/typing/tests/data/reveal/numerictypes.pyi b/numpy/typing/tests/data/reveal/numerictypes.pyi
index cc2335264113..e1857557d90a 100644
--- a/numpy/typing/tests/data/reveal/numerictypes.pyi
+++ b/numpy/typing/tests/data/reveal/numerictypes.pyi
@@ -33,9 +33,9 @@ reveal_type(np.nbytes[np.int64])  # E: int
 
 reveal_type(np.ScalarType)  # E: Tuple
 reveal_type(np.ScalarType[0])  # E: Type[builtins.int]
-reveal_type(np.ScalarType[4])  # E: Type[builtins.bool]
-reveal_type(np.ScalarType[9])  # E: Type[{csingle}]
-reveal_type(np.ScalarType[11])  # E: Type[{clongdouble}]
+reveal_type(np.ScalarType[3])  # E: Type[builtins.bool]
+reveal_type(np.ScalarType[8])  # E: Type[{csingle}]
+reveal_type(np.ScalarType[10])  # E: Type[{clongdouble}]
 
 reveal_type(np.typecodes["Character"])  # E: Literal['c']
 reveal_type(np.typecodes["Complex"])  # E: Literal['FDG']
diff --git a/numpy/typing/tests/data/reveal/random.pyi b/numpy/typing/tests/data/reveal/random.pyi
index 4e06aa7d5bd7..67a5d3e7aad8 100644
--- a/numpy/typing/tests/data/reveal/random.pyi
+++ b/numpy/typing/tests/data/reveal/random.pyi
@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, List
+from typing import Any
 
 import numpy as np
 
@@ -79,13 +79,13 @@ D_arr_0p9: np.ndarray[Any, np.dtype[np.float64]] = np.array([0.9])
 D_arr_1p5: np.ndarray[Any, np.dtype[np.float64]] = np.array([1.5])
 I_arr_10: np.ndarray[Any, np.dtype[np.int_]] = np.array([10], dtype=np.int_)
 I_arr_20: np.ndarray[Any, np.dtype[np.int_]] = np.array([20], dtype=np.int_)
-D_arr_like_0p1: List[float] = [0.1]
-D_arr_like_0p5: List[float] = [0.5]
-D_arr_like_0p9: List[float] = [0.9]
-D_arr_like_1p5: List[float] = [1.5]
-I_arr_like_10: List[int] = [10]
-I_arr_like_20: List[int] = [20]
-D_2D_like: List[List[float]] = [[1, 2], [2, 3], [3, 4], [4, 5.1]]
+D_arr_like_0p1: list[float] = [0.1]
+D_arr_like_0p5: list[float] = [0.5]
+D_arr_like_0p9: list[float] = [0.9]
+D_arr_like_1p5: list[float] = [1.5]
+I_arr_like_10: list[int] = [10]
+I_arr_like_20: list[int] = [20]
+D_2D_like: list[list[float]] = [[1, 2], [2, 3], [3, 4], [4, 5.1]]
 D_2D: np.ndarray[Any, np.dtype[np.float64]] = np.array(D_2D_like)
 S_out: np.ndarray[Any, np.dtype[np.float32]] = np.empty(1, dtype=np.float32)
 D_out: np.ndarray[Any, np.dtype[np.float64]] = np.empty(1)
@@ -501,7 +501,7 @@ reveal_type(def_gen.integers([100]))  # E: ndarray[Any, dtype[signedinteger[typi
 reveal_type(def_gen.integers(0, [100]))  # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]]
 
 I_bool_low: np.ndarray[Any, np.dtype[np.bool_]] = np.array([0], dtype=np.bool_)
-I_bool_low_like: List[int] = [0]
+I_bool_low_like: list[int] = [0]
 I_bool_high_open: np.ndarray[Any, np.dtype[np.bool_]] = np.array([1], dtype=np.bool_)
 I_bool_high_closed: np.ndarray[Any, np.dtype[np.bool_]] = np.array([1], dtype=np.bool_)
 
@@ -530,7 +530,7 @@ reveal_type(def_gen.integers(I_bool_low, I_bool_high_closed, dtype=np.bool_, end
 reveal_type(def_gen.integers(0, I_bool_high_closed, dtype=np.bool_, endpoint=True))  # E: ndarray[Any, dtype[bool_]
 
 I_u1_low: np.ndarray[Any, np.dtype[np.uint8]] = np.array([0], dtype=np.uint8)
-I_u1_low_like: List[int] = [0]
+I_u1_low_like: list[int] = [0]
 I_u1_high_open: np.ndarray[Any, np.dtype[np.uint8]] = np.array([255], dtype=np.uint8)
 I_u1_high_closed: np.ndarray[Any, np.dtype[np.uint8]] = np.array([255], dtype=np.uint8)
 
@@ -571,7 +571,7 @@ reveal_type(def_gen.integers(I_u1_low, I_u1_high_closed, dtype=np.uint8, endpoin
 reveal_type(def_gen.integers(0, I_u1_high_closed, dtype=np.uint8, endpoint=True))  # E: ndarray[Any, dtype[unsignedinteger[typing._8Bit]]]
 
 I_u2_low: np.ndarray[Any, np.dtype[np.uint16]] = np.array([0], dtype=np.uint16)
-I_u2_low_like: List[int] = [0]
+I_u2_low_like: list[int] = [0]
 I_u2_high_open: np.ndarray[Any, np.dtype[np.uint16]] = np.array([65535], dtype=np.uint16)
 I_u2_high_closed: np.ndarray[Any, np.dtype[np.uint16]] = np.array([65535], dtype=np.uint16)
 
@@ -612,7 +612,7 @@ reveal_type(def_gen.integers(I_u2_low, I_u2_high_closed, dtype=np.uint16, endpoi
 reveal_type(def_gen.integers(0, I_u2_high_closed, dtype=np.uint16, endpoint=True))  # E: ndarray[Any, dtype[unsignedinteger[typing._16Bit]]]
 
 I_u4_low: np.ndarray[Any, np.dtype[np.uint32]] = np.array([0], dtype=np.uint32)
-I_u4_low_like: List[int] = [0]
+I_u4_low_like: list[int] = [0]
 I_u4_high_open: np.ndarray[Any, np.dtype[np.uint32]] = np.array([4294967295], dtype=np.uint32)
 I_u4_high_closed: np.ndarray[Any, np.dtype[np.uint32]] = np.array([4294967295], dtype=np.uint32)
 
@@ -678,7 +678,7 @@ reveal_type(def_gen.integers(I_u4_low, I_u4_high_closed, dtype=np.uint, endpoint
 reveal_type(def_gen.integers(0, I_u4_high_closed, dtype=np.uint, endpoint=True))  # E: ndarray[Any, dtype[{uint}]]
 
 I_u8_low: np.ndarray[Any, np.dtype[np.uint64]] = np.array([0], dtype=np.uint64)
-I_u8_low_like: List[int] = [0]
+I_u8_low_like: list[int] = [0]
 I_u8_high_open: np.ndarray[Any, np.dtype[np.uint64]] = np.array([18446744073709551615], dtype=np.uint64)
 I_u8_high_closed: np.ndarray[Any, np.dtype[np.uint64]] = np.array([18446744073709551615], dtype=np.uint64)
 
@@ -719,7 +719,7 @@ reveal_type(def_gen.integers(I_u8_low, I_u8_high_closed, dtype=np.uint64, endpoi
 reveal_type(def_gen.integers(0, I_u8_high_closed, dtype=np.uint64, endpoint=True))  # E: ndarray[Any, dtype[unsignedinteger[typing._64Bit]]]
 
 I_i1_low: np.ndarray[Any, np.dtype[np.int8]] = np.array([-128], dtype=np.int8)
-I_i1_low_like: List[int] = [-128]
+I_i1_low_like: list[int] = [-128]
 I_i1_high_open: np.ndarray[Any, np.dtype[np.int8]] = np.array([127], dtype=np.int8)
 I_i1_high_closed: np.ndarray[Any, np.dtype[np.int8]] = np.array([127], dtype=np.int8)
 
@@ -760,7 +760,7 @@ reveal_type(def_gen.integers(I_i1_low, I_i1_high_closed, dtype=np.int8, endpoint
 reveal_type(def_gen.integers(-128, I_i1_high_closed, dtype=np.int8, endpoint=True))  # E: ndarray[Any, dtype[signedinteger[typing._8Bit]]]
 
 I_i2_low: np.ndarray[Any, np.dtype[np.int16]] = np.array([-32768], dtype=np.int16)
-I_i2_low_like: List[int] = [-32768]
+I_i2_low_like: list[int] = [-32768]
 I_i2_high_open: np.ndarray[Any, np.dtype[np.int16]] = np.array([32767], dtype=np.int16)
 I_i2_high_closed: np.ndarray[Any, np.dtype[np.int16]] = np.array([32767], dtype=np.int16)
 
@@ -801,7 +801,7 @@ reveal_type(def_gen.integers(I_i2_low, I_i2_high_closed, dtype=np.int16, endpoin
 reveal_type(def_gen.integers(-32768, I_i2_high_closed, dtype=np.int16, endpoint=True))  # E: ndarray[Any, dtype[signedinteger[typing._16Bit]]]
 
 I_i4_low: np.ndarray[Any, np.dtype[np.int32]] = np.array([-2147483648], dtype=np.int32)
-I_i4_low_like: List[int] = [-2147483648]
+I_i4_low_like: list[int] = [-2147483648]
 I_i4_high_open: np.ndarray[Any, np.dtype[np.int32]] = np.array([2147483647], dtype=np.int32)
 I_i4_high_closed: np.ndarray[Any, np.dtype[np.int32]] = np.array([2147483647], dtype=np.int32)
 
@@ -842,7 +842,7 @@ reveal_type(def_gen.integers(I_i4_low, I_i4_high_closed, dtype=np.int32, endpoin
 reveal_type(def_gen.integers(-2147483648, I_i4_high_closed, dtype=np.int32, endpoint=True))  # E: ndarray[Any, dtype[signedinteger[typing._32Bit]]]
 
 I_i8_low: np.ndarray[Any, np.dtype[np.int64]] = np.array([-9223372036854775808], dtype=np.int64)
-I_i8_low_like: List[int] = [-9223372036854775808]
+I_i8_low_like: list[int] = [-9223372036854775808]
 I_i8_high_open: np.ndarray[Any, np.dtype[np.int64]] = np.array([9223372036854775807], dtype=np.int64)
 I_i8_high_closed: np.ndarray[Any, np.dtype[np.int64]] = np.array([9223372036854775807], dtype=np.int64)
 
@@ -1537,3 +1537,6 @@ reveal_type(random_st.random_sample(size=(1, 2)))  # E: ndarray[Any, dtype[float
 reveal_type(random_st.tomaxint())  # E: int
 reveal_type(random_st.tomaxint(1))  # E: ndarray[Any, dtype[{int_}]]
 reveal_type(random_st.tomaxint((1,)))  # E: ndarray[Any, dtype[{int_}]]
+
+reveal_type(np.random.set_bit_generator(pcg64))  # E: None
+reveal_type(np.random.get_bit_generator())  # E: BitGenerator
diff --git a/numpy/typing/tests/data/reveal/rec.pyi b/numpy/typing/tests/data/reveal/rec.pyi
index bf51c82a36aa..8ea4a6ee8d9c 100644
--- a/numpy/typing/tests/data/reveal/rec.pyi
+++ b/numpy/typing/tests/data/reveal/rec.pyi
@@ -1,12 +1,12 @@
 import io
-from typing import Any, List
+from typing import Any
 
 import numpy as np
 import numpy.typing as npt
 
 AR_i8: npt.NDArray[np.int64]
 REC_AR_V: np.recarray[Any, np.dtype[np.record]]
-AR_LIST: List[npt.NDArray[np.int64]]
+AR_LIST: list[npt.NDArray[np.int64]]
 
 format_parser: np.format_parser
 record: np.record
@@ -33,6 +33,7 @@ reveal_type(REC_AR_V.field(0, AR_i8))  # E: None
 reveal_type(REC_AR_V.field("field_a", AR_i8))  # E: None
 reveal_type(REC_AR_V["field_a"])  # E: Any
 reveal_type(REC_AR_V.field_a)  # E: Any
+reveal_type(REC_AR_V.__array_finalize__(object()))  # E: None
 
 reveal_type(np.recarray(  # recarray[Any, dtype[record]]
     shape=(10, 5),
@@ -104,3 +105,24 @@ reveal_type(np.rec.array(  # recarray[Any, dtype[record]]
     formats=[np.int64, np.float64],
     names=["i8", "f8"]
 ))
+
+reveal_type(np.rec.array(  # recarray[Any, dtype[Any]]
+    None,
+    dtype=np.float64,
+    shape=(10, 3),
+))
+reveal_type(np.rec.array(  # recarray[Any, dtype[Any]]
+    None,
+    formats=[np.int64, np.float64],
+    names=["i8", "f8"],
+    shape=(10, 3),
+))
+reveal_type(np.rec.array(  # recarray[Any, dtype[Any]]
+    file_obj,
+    dtype=np.float64,
+))
+reveal_type(np.rec.array(  # recarray[Any, dtype[Any]]
+    file_obj,
+    formats=[np.int64, np.float64],
+    names=["i8", "f8"],
+))
diff --git a/numpy/typing/tests/data/reveal/scalars.pyi b/numpy/typing/tests/data/reveal/scalars.pyi
index 383e40ef08dc..b7fc75acce4b 100644
--- a/numpy/typing/tests/data/reveal/scalars.pyi
+++ b/numpy/typing/tests/data/reveal/scalars.pyi
@@ -35,7 +35,6 @@ reveal_type(c8.real)  # E: {float32}
 reveal_type(c16.imag)  # E: {float64}
 
 reveal_type(np.unicode_('foo'))  # E: str_
-reveal_type(np.str0('foo'))  # E: str_
 
 reveal_type(V[0])  # E: Any
 reveal_type(V["field1"])  # E: Any
@@ -44,18 +43,12 @@ V[0] = 5
 
 # Aliases
 reveal_type(np.unicode_())  # E: str_
-reveal_type(np.str0())  # E: str_
-reveal_type(np.bool8())  # E: bool_
-reveal_type(np.bytes0())  # E: bytes_
 reveal_type(np.string_())  # E: bytes_
-reveal_type(np.object0())  # E: object_
-reveal_type(np.void0(0))  # E: void
 
 reveal_type(np.byte())  # E: {byte}
 reveal_type(np.short())  # E: {short}
 reveal_type(np.intc())  # E: {intc}
 reveal_type(np.intp())  # E: {intp}
-reveal_type(np.int0())  # E: {intp}
 reveal_type(np.int_())  # E: {int_}
 reveal_type(np.longlong())  # E: {longlong}
 
@@ -63,7 +56,6 @@ reveal_type(np.ubyte())  # E: {ubyte}
 reveal_type(np.ushort())  # E: {ushort}
 reveal_type(np.uintc())  # E: {uintc}
 reveal_type(np.uintp())  # E: {uintp}
-reveal_type(np.uint0())  # E: {uintp}
 reveal_type(np.uint())  # E: {uint}
 reveal_type(np.ulonglong())  # E: {ulonglong}
 
diff --git a/numpy/typing/tests/data/reveal/shape_base.pyi b/numpy/typing/tests/data/reveal/shape_base.pyi
index f13678c3af3b..b907a4328039 100644
--- a/numpy/typing/tests/data/reveal/shape_base.pyi
+++ b/numpy/typing/tests/data/reveal/shape_base.pyi
@@ -1,6 +1,6 @@
 import numpy as np
-from numpy.typing import NDArray
-from typing import Any, List
+from numpy._typing import NDArray
+from typing import Any
 
 i8: np.int64
 f8: np.float64
@@ -9,7 +9,7 @@ AR_b: NDArray[np.bool_]
 AR_i8: NDArray[np.int64]
 AR_f8: NDArray[np.float64]
 
-AR_LIKE_f8: List[float]
+AR_LIKE_f8: list[float]
 
 reveal_type(np.take_along_axis(AR_f8, AR_i8, axis=1))  # E: ndarray[Any, dtype[{float64}]]
 reveal_type(np.take_along_axis(f8, AR_i8, axis=None))  # E: ndarray[Any, dtype[{float64}]]
diff --git a/numpy/typing/tests/data/reveal/stride_tricks.pyi b/numpy/typing/tests/data/reveal/stride_tricks.pyi
index 0d6dcd388e68..17769dc4bb39 100644
--- a/numpy/typing/tests/data/reveal/stride_tricks.pyi
+++ b/numpy/typing/tests/data/reveal/stride_tricks.pyi
@@ -1,10 +1,10 @@
-from typing import List, Dict, Any
+from typing import Any
 import numpy as np
 import numpy.typing as npt
 
 AR_f8: npt.NDArray[np.float64]
-AR_LIKE_f: List[float]
-interface_dict: Dict[str, Any]
+AR_LIKE_f: list[float]
+interface_dict: dict[str, Any]
 
 reveal_type(np.lib.stride_tricks.DummyArray(interface_dict))  # E: lib.stride_tricks.DummyArray
 
@@ -21,8 +21,8 @@ reveal_type(np.broadcast_to(AR_f8, 5))  # E: ndarray[Any, dtype[{float64}]]
 reveal_type(np.broadcast_to(AR_LIKE_f, (1, 5)))  # E: ndarray[Any, dtype[Any]]
 reveal_type(np.broadcast_to(AR_f8, [4, 6], subok=True))  # E: ndarray[Any, dtype[{float64}]]
 
-reveal_type(np.broadcast_shapes((1, 2), [3, 1], (3, 2)))  # E: tuple[builtins.int]
-reveal_type(np.broadcast_shapes((6, 7), (5, 6, 1), 7, (5, 1, 7)))  # E: tuple[builtins.int]
+reveal_type(np.broadcast_shapes((1, 2), [3, 1], (3, 2)))  # E: tuple[builtins.int, ...]
+reveal_type(np.broadcast_shapes((6, 7), (5, 6, 1), 7, (5, 1, 7)))  # E: tuple[builtins.int, ...]
 
 reveal_type(np.broadcast_arrays(AR_f8, AR_f8))  # E: list[ndarray[Any, dtype[Any]]]
 reveal_type(np.broadcast_arrays(AR_f8, AR_LIKE_f))  # E: list[ndarray[Any, dtype[Any]]]
diff --git a/numpy/typing/tests/data/reveal/testing.pyi b/numpy/typing/tests/data/reveal/testing.pyi
index 9813dc723fa3..5440af80065e 100644
--- a/numpy/typing/tests/data/reveal/testing.pyi
+++ b/numpy/typing/tests/data/reveal/testing.pyi
@@ -2,7 +2,8 @@ from __future__ import annotations
 
 import re
 import sys
-from typing import Any, Callable, TypeVar
+from collections.abc import Callable
+from typing import Any, TypeVar
 from pathlib import Path
 
 import numpy as np
@@ -29,7 +30,7 @@ reveal_type(np.testing.clear_and_catch_warnings(modules=[np.testing]))  # E: _cl
 reveal_type(np.testing.clear_and_catch_warnings(True))  # E: _clear_and_catch_warnings_with_records
 reveal_type(np.testing.clear_and_catch_warnings(False))  # E: _clear_and_catch_warnings_without_records
 reveal_type(np.testing.clear_and_catch_warnings(bool_obj))  # E: clear_and_catch_warnings
-reveal_type(np.testing.clear_and_catch_warnings.class_modules)  # E: tuple[types.ModuleType]
+reveal_type(np.testing.clear_and_catch_warnings.class_modules)  # E: tuple[types.ModuleType, ...]
 reveal_type(np.testing.clear_and_catch_warnings.modules)  # E: set[types.ModuleType]
 
 with np.testing.clear_and_catch_warnings(True) as c1:
@@ -153,8 +154,12 @@ reveal_type(np.testing.assert_array_max_ulp(AR_i8, AR_f8, dtype=np.float32))  #
 reveal_type(np.testing.assert_warns(RuntimeWarning))  # E: _GeneratorContextManager[None]
 reveal_type(np.testing.assert_warns(RuntimeWarning, func3, 5))  # E: bool
 
+def func4(a: int, b: str) -> bool: ...
+
 reveal_type(np.testing.assert_no_warnings())  # E: _GeneratorContextManager[None]
 reveal_type(np.testing.assert_no_warnings(func3, 5))  # E: bool
+reveal_type(np.testing.assert_no_warnings(func4, a=1, b="test"))  # E: bool
+reveal_type(np.testing.assert_no_warnings(func4, 1, "test"))  # E: bool
 
 reveal_type(np.testing.tempdir("test_dir"))  # E: _GeneratorContextManager[builtins.str]
 reveal_type(np.testing.tempdir(prefix=b"test"))  # E: _GeneratorContextManager[builtins.bytes]
diff --git a/numpy/typing/tests/data/reveal/twodim_base.pyi b/numpy/typing/tests/data/reveal/twodim_base.pyi
index 0318c3cf18a5..0dc58d43786c 100644
--- a/numpy/typing/tests/data/reveal/twodim_base.pyi
+++ b/numpy/typing/tests/data/reveal/twodim_base.pyi
@@ -1,4 +1,4 @@
-from typing import Any, List, TypeVar
+from typing import Any, TypeVar
 
 import numpy as np
 import numpy.typing as npt
@@ -21,7 +21,7 @@ AR_f: npt.NDArray[np.float64]
 AR_c: npt.NDArray[np.complex128]
 AR_O: npt.NDArray[np.object_]
 
-AR_LIKE_b: List[bool]
+AR_LIKE_b: list[bool]
 
 reveal_type(np.fliplr(AR_b))  # E: ndarray[Any, dtype[bool_]]
 reveal_type(np.fliplr(AR_LIKE_b))  # E: ndarray[Any, dtype[Any]]
diff --git a/numpy/typing/tests/data/reveal/type_check.pyi b/numpy/typing/tests/data/reveal/type_check.pyi
index 13d41d844128..ddd319a94adf 100644
--- a/numpy/typing/tests/data/reveal/type_check.pyi
+++ b/numpy/typing/tests/data/reveal/type_check.pyi
@@ -1,6 +1,6 @@
-from typing import List
 import numpy as np
 import numpy.typing as npt
+from numpy._typing import _128Bit
 
 f8: np.float64
 f: float
@@ -10,11 +10,11 @@ AR_i8: npt.NDArray[np.int64]
 AR_i4: npt.NDArray[np.int32]
 AR_f2: npt.NDArray[np.float16]
 AR_f8: npt.NDArray[np.float64]
-AR_f16: npt.NDArray[np.floating[npt._128Bit]]
+AR_f16: npt.NDArray[np.floating[_128Bit]]
 AR_c8: npt.NDArray[np.complex64]
 AR_c16: npt.NDArray[np.complex128]
 
-AR_LIKE_f: List[float]
+AR_LIKE_f: list[float]
 
 class RealObj:
     real: slice
diff --git a/numpy/typing/tests/data/reveal/ufunclike.pyi b/numpy/typing/tests/data/reveal/ufunclike.pyi
index 2d67c923fe8d..9f06600b6420 100644
--- a/numpy/typing/tests/data/reveal/ufunclike.pyi
+++ b/numpy/typing/tests/data/reveal/ufunclike.pyi
@@ -1,11 +1,11 @@
-from typing import List, Any
+from typing import Any
 import numpy as np
 
-AR_LIKE_b: List[bool]
-AR_LIKE_u: List[np.uint32]
-AR_LIKE_i: List[int]
-AR_LIKE_f: List[float]
-AR_LIKE_O: List[np.object_]
+AR_LIKE_b: list[bool]
+AR_LIKE_u: list[np.uint32]
+AR_LIKE_i: list[int]
+AR_LIKE_f: list[float]
+AR_LIKE_O: list[np.object_]
 
 AR_U: np.ndarray[Any, np.dtype[np.str_]]
 
diff --git a/numpy/typing/tests/data/reveal/warnings_and_errors.pyi b/numpy/typing/tests/data/reveal/warnings_and_errors.pyi
index d5c50448ae6c..19fa432f91a4 100644
--- a/numpy/typing/tests/data/reveal/warnings_and_errors.pyi
+++ b/numpy/typing/tests/data/reveal/warnings_and_errors.pyi
@@ -1,5 +1,3 @@
-from typing import Type
-
 import numpy as np
 
 reveal_type(np.ModuleDeprecationWarning())  # E: ModuleDeprecationWarning
diff --git a/numpy/typing/tests/test_generic_alias.py b/numpy/typing/tests/test_generic_alias.py
index 39343420bdc5..861babd4b3ad 100644
--- a/numpy/typing/tests/test_generic_alias.py
+++ b/numpy/typing/tests/test_generic_alias.py
@@ -5,11 +5,12 @@
 import types
 import pickle
 import weakref
-from typing import TypeVar, Any, Callable, Tuple, Type, Union
+from typing import TypeVar, Any, Union, Callable
 
 import pytest
 import numpy as np
-from numpy.typing._generic_alias import _GenericAlias
+from numpy._typing._generic_alias import _GenericAlias
+from typing_extensions import Unpack
 
 ScalarType = TypeVar("ScalarType", bound=np.generic, covariant=True)
 T1 = TypeVar("T1")
@@ -17,28 +18,32 @@
 DType = _GenericAlias(np.dtype, (ScalarType,))
 NDArray = _GenericAlias(np.ndarray, (Any, DType))
 
+# NOTE: The `npt._GenericAlias` *class* isn't quite stable on python >=3.11.
+# This is not a problem during runtime (as it's 3.8-exclusive), but we still
+# need it for the >=3.9 in order to verify its semantics match
+# `types.GenericAlias` replacement. xref numpy/numpy#21526
 if sys.version_info >= (3, 9):
     DType_ref = types.GenericAlias(np.dtype, (ScalarType,))
     NDArray_ref = types.GenericAlias(np.ndarray, (Any, DType_ref))
-    FuncType = Callable[[Union[_GenericAlias, types.GenericAlias]], Any]
+    FuncType = Callable[["_GenericAlias | types.GenericAlias"], Any]
 else:
     DType_ref = Any
     NDArray_ref = Any
-    FuncType = Callable[[_GenericAlias], Any]
+    FuncType = Callable[["_GenericAlias"], Any]
 
 GETATTR_NAMES = sorted(set(dir(np.ndarray)) - _GenericAlias._ATTR_EXCEPTIONS)
 
 BUFFER = np.array([1], dtype=np.int64)
 BUFFER.setflags(write=False)
 
-def _get_subclass_mro(base: type) -> Tuple[type, ...]:
+def _get_subclass_mro(base: type) -> tuple[type, ...]:
     class Subclass(base):  # type: ignore[misc,valid-type]
         pass
     return Subclass.__mro__[1:]
 
 
 class TestGenericAlias:
-    """Tests for `numpy.typing._generic_alias._GenericAlias`."""
+    """Tests for `numpy._typing._generic_alias._GenericAlias`."""
 
     @pytest.mark.parametrize("name,func", [
         ("__init__", lambda n: n),
@@ -51,8 +56,6 @@ class TestGenericAlias:
         ("__origin__", lambda n: n.__origin__),
         ("__args__", lambda n: n.__args__),
         ("__parameters__", lambda n: n.__parameters__),
-        ("__reduce__", lambda n: n.__reduce__()[1:]),
-        ("__reduce_ex__", lambda n: n.__reduce_ex__(1)[1:]),
         ("__mro_entries__", lambda n: n.__mro_entries__([object])),
         ("__hash__", lambda n: hash(n)),
         ("__repr__", lambda n: repr(n)),
@@ -62,7 +65,6 @@ class TestGenericAlias:
         ("__getitem__", lambda n: n[Union[T1, T2]][np.float32, np.float64]),
         ("__eq__", lambda n: n == n),
         ("__ne__", lambda n: n != np.ndarray),
-        ("__dir__", lambda n: dir(n)),
         ("__call__", lambda n: n((1,), np.int64, BUFFER)),
         ("__call__", lambda n: n(shape=(1,), dtype=np.int64, buffer=BUFFER)),
         ("subclassing", lambda n: _get_subclass_mro(n)),
@@ -96,6 +98,48 @@ def test_copy(self, name: str, func: FuncType) -> None:
             value_ref = func(NDArray_ref)
             assert value == value_ref
 
+    def test_dir(self) -> None:
+        value = dir(NDArray)
+        if sys.version_info < (3, 9):
+            return
+
+        # A number attributes only exist in `types.GenericAlias` in >= 3.11
+        if sys.version_info < (3, 11, 0, "beta", 3):
+            value.remove("__typing_unpacked_tuple_args__")
+        if sys.version_info < (3, 11, 0, "beta", 1):
+            value.remove("__unpacked__")
+        assert value == dir(NDArray_ref)
+
+    @pytest.mark.parametrize("name,func,dev_version", [
+        ("__iter__", lambda n: len(list(n)), ("beta", 1)),
+        ("__iter__", lambda n: next(iter(n)), ("beta", 1)),
+        ("__unpacked__", lambda n: n.__unpacked__, ("beta", 1)),
+        ("Unpack", lambda n: Unpack[n], ("beta", 1)),
+
+        # The right operand should now have `__unpacked__ = True`,
+        # and they are thus now longer equivalent
+        ("__ne__", lambda n: n != next(iter(n)), ("beta", 1)),
+
+        # >= beta3
+        ("__typing_unpacked_tuple_args__",
+         lambda n: n.__typing_unpacked_tuple_args__, ("beta", 3)),
+
+        # >= beta4
+        ("__class__", lambda n: n.__class__ == type(n), ("beta", 4)),
+    ])
+    def test_py311_features(
+        self,
+        name: str,
+        func: FuncType,
+        dev_version: tuple[str, int],
+    ) -> None:
+        """Test Python 3.11 features."""
+        value = func(NDArray)
+
+        if sys.version_info >= (3, 11, 0, *dev_version):
+            value_ref = func(NDArray_ref)
+            assert value == value_ref
+
     def test_weakref(self) -> None:
         """Test ``__weakref__``."""
         value = weakref.ref(NDArray)()
@@ -132,7 +176,7 @@ def test_getattr(self, name: str) -> None:
     def test_raise(
         self,
         name: str,
-        exc_type: Type[BaseException],
+        exc_type: type[BaseException],
         func: FuncType,
     ) -> None:
         """Test operations that are supposed to raise."""
diff --git a/numpy/typing/tests/test_runtime.py b/numpy/typing/tests/test_runtime.py
index 5b5df49dc571..44d069006320 100644
--- a/numpy/typing/tests/test_runtime.py
+++ b/numpy/typing/tests/test_runtime.py
@@ -3,11 +3,19 @@
 from __future__ import annotations
 
 import sys
-from typing import get_type_hints, Union, NamedTuple, get_args, get_origin
+from typing import (
+    get_type_hints,
+    Union,
+    NamedTuple,
+    get_args,
+    get_origin,
+    Any,
+)
 
 import pytest
 import numpy as np
 import numpy.typing as npt
+import numpy._typing as _npt
 
 
 class TypeTup(NamedTuple):
@@ -80,3 +88,26 @@ def test_keys() -> None:
     keys = TYPES.keys()
     ref = set(npt.__all__)
     assert keys == ref
+
+
+PROTOCOLS: dict[str, tuple[type[Any], object]] = {
+    "_SupportsDType": (_npt._SupportsDType, np.int64(1)),
+    "_SupportsArray": (_npt._SupportsArray, np.arange(10)),
+    "_SupportsArrayFunc": (_npt._SupportsArrayFunc, np.arange(10)),
+    "_NestedSequence": (_npt._NestedSequence, [1]),
+}
+
+
+@pytest.mark.parametrize("cls,obj", PROTOCOLS.values(), ids=PROTOCOLS.keys())
+class TestRuntimeProtocol:
+    def test_isinstance(self, cls: type[Any], obj: object) -> None:
+        assert isinstance(obj, cls)
+        assert not isinstance(None, cls)
+
+    def test_issubclass(self, cls: type[Any], obj: object) -> None:
+        if cls is _npt._SupportsDType:
+            pytest.xfail(
+                "Protocols with non-method members don't support issubclass()"
+            )
+        assert issubclass(type(obj), cls)
+        assert not issubclass(type(None), cls)
diff --git a/numpy/typing/tests/test_typing.py b/numpy/typing/tests/test_typing.py
index fe58a8f4c5e8..5011339b56fb 100644
--- a/numpy/typing/tests/test_typing.py
+++ b/numpy/typing/tests/test_typing.py
@@ -136,7 +136,7 @@ def test_fail(path: str) -> None:
     output_mypy = OUTPUT_MYPY
     assert path in output_mypy
     for error_line in output_mypy[path]:
-        error_line = _strip_filename(error_line)
+        error_line = _strip_filename(error_line).split("\n", 1)[0]
         match = re.match(
             r"(?P\d+): (error|note): .+$",
             error_line,
@@ -228,41 +228,41 @@ def _construct_ctypes_dict() -> dict[str, str]:
 
 
 def _construct_format_dict() -> dict[str, str]:
-    dct = {k.split(".")[-1]: v.replace("numpy", "numpy.typing") for
+    dct = {k.split(".")[-1]: v.replace("numpy", "numpy._typing") for
            k, v in _PRECISION_DICT.items()}
 
     return {
-        "uint8": "numpy.unsignedinteger[numpy.typing._8Bit]",
-        "uint16": "numpy.unsignedinteger[numpy.typing._16Bit]",
-        "uint32": "numpy.unsignedinteger[numpy.typing._32Bit]",
-        "uint64": "numpy.unsignedinteger[numpy.typing._64Bit]",
-        "uint128": "numpy.unsignedinteger[numpy.typing._128Bit]",
-        "uint256": "numpy.unsignedinteger[numpy.typing._256Bit]",
-        "int8": "numpy.signedinteger[numpy.typing._8Bit]",
-        "int16": "numpy.signedinteger[numpy.typing._16Bit]",
-        "int32": "numpy.signedinteger[numpy.typing._32Bit]",
-        "int64": "numpy.signedinteger[numpy.typing._64Bit]",
-        "int128": "numpy.signedinteger[numpy.typing._128Bit]",
-        "int256": "numpy.signedinteger[numpy.typing._256Bit]",
-        "float16": "numpy.floating[numpy.typing._16Bit]",
-        "float32": "numpy.floating[numpy.typing._32Bit]",
-        "float64": "numpy.floating[numpy.typing._64Bit]",
-        "float80": "numpy.floating[numpy.typing._80Bit]",
-        "float96": "numpy.floating[numpy.typing._96Bit]",
-        "float128": "numpy.floating[numpy.typing._128Bit]",
-        "float256": "numpy.floating[numpy.typing._256Bit]",
+        "uint8": "numpy.unsignedinteger[numpy._typing._8Bit]",
+        "uint16": "numpy.unsignedinteger[numpy._typing._16Bit]",
+        "uint32": "numpy.unsignedinteger[numpy._typing._32Bit]",
+        "uint64": "numpy.unsignedinteger[numpy._typing._64Bit]",
+        "uint128": "numpy.unsignedinteger[numpy._typing._128Bit]",
+        "uint256": "numpy.unsignedinteger[numpy._typing._256Bit]",
+        "int8": "numpy.signedinteger[numpy._typing._8Bit]",
+        "int16": "numpy.signedinteger[numpy._typing._16Bit]",
+        "int32": "numpy.signedinteger[numpy._typing._32Bit]",
+        "int64": "numpy.signedinteger[numpy._typing._64Bit]",
+        "int128": "numpy.signedinteger[numpy._typing._128Bit]",
+        "int256": "numpy.signedinteger[numpy._typing._256Bit]",
+        "float16": "numpy.floating[numpy._typing._16Bit]",
+        "float32": "numpy.floating[numpy._typing._32Bit]",
+        "float64": "numpy.floating[numpy._typing._64Bit]",
+        "float80": "numpy.floating[numpy._typing._80Bit]",
+        "float96": "numpy.floating[numpy._typing._96Bit]",
+        "float128": "numpy.floating[numpy._typing._128Bit]",
+        "float256": "numpy.floating[numpy._typing._256Bit]",
         "complex64": ("numpy.complexfloating"
-                      "[numpy.typing._32Bit, numpy.typing._32Bit]"),
+                      "[numpy._typing._32Bit, numpy._typing._32Bit]"),
         "complex128": ("numpy.complexfloating"
-                       "[numpy.typing._64Bit, numpy.typing._64Bit]"),
+                       "[numpy._typing._64Bit, numpy._typing._64Bit]"),
         "complex160": ("numpy.complexfloating"
-                       "[numpy.typing._80Bit, numpy.typing._80Bit]"),
+                       "[numpy._typing._80Bit, numpy._typing._80Bit]"),
         "complex192": ("numpy.complexfloating"
-                       "[numpy.typing._96Bit, numpy.typing._96Bit]"),
+                       "[numpy._typing._96Bit, numpy._typing._96Bit]"),
         "complex256": ("numpy.complexfloating"
-                       "[numpy.typing._128Bit, numpy.typing._128Bit]"),
+                       "[numpy._typing._128Bit, numpy._typing._128Bit]"),
         "complex512": ("numpy.complexfloating"
-                       "[numpy.typing._256Bit, numpy.typing._256Bit]"),
+                       "[numpy._typing._256Bit, numpy._typing._256Bit]"),
 
         "ubyte": f"numpy.unsignedinteger[{dct['_NBitByte']}]",
         "ushort": f"numpy.unsignedinteger[{dct['_NBitShort']}]",
@@ -310,7 +310,7 @@ def _parse_reveals(file: IO[str]) -> tuple[npt.NDArray[np.str_], list[str]]:
 
     All format keys will be substituted for their respective value
     from `FORMAT_DICT`, *e.g.* ``"{float64}"`` becomes
-    ``"numpy.floating[numpy.typing._64Bit]"``.
+    ``"numpy.floating[numpy._typing._64Bit]"``.
     """
     string = file.read().replace("*", "")
 
@@ -368,6 +368,7 @@ def test_reveal(path: str) -> None:
 Expected reveal: {!r}
 Observed reveal: {!r}
 """
+_STRIP_PATTERN = re.compile(r"(\w+\.)+(\w+)")
 
 
 def _test_reveal(
@@ -378,9 +379,8 @@ def _test_reveal(
     lineno: int,
 ) -> None:
     """Error-reporting helper function for `test_reveal`."""
-    strip_pattern = re.compile(r"(\w+\.)+(\w+)")
-    stripped_reveal = strip_pattern.sub(strip_func, reveal)
-    stripped_expected_reveal = strip_pattern.sub(strip_func, expected_reveal)
+    stripped_reveal = _STRIP_PATTERN.sub(strip_func, reveal)
+    stripped_expected_reveal = _STRIP_PATTERN.sub(strip_func, expected_reveal)
     if stripped_reveal not in stripped_expected_reveal:
         raise AssertionError(
             _REVEAL_MSG.format(lineno,
diff --git a/pavement.py b/pavement.py
index 6fdaae975c24..a3ff6665c237 100644
--- a/pavement.py
+++ b/pavement.py
@@ -38,7 +38,7 @@
 #-----------------------------------
 
 # Path to the release notes
-RELEASE_NOTES = 'doc/source/release/1.22.0-notes.rst'
+RELEASE_NOTES = 'doc/source/release/1.24.3-notes.rst'
 
 
 #-------------------------------------------------------
diff --git a/pyproject.toml b/pyproject.toml
index 941c8fa8cdcc..60e7f5826434 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,17 +1,16 @@
 [build-system]
 # Minimum requirements for the build system to execute.
 requires = [
-    "packaging==20.5; platform_machine=='arm64'",  # macos M1
-    "setuptools<49.2.0",
-    "wheel==0.36.2",
-    "Cython>=0.29.24,<3.0",  # Note: keep in sync with tools/cythonize.py
+    "setuptools==59.2.0",
+    "wheel==0.37.0",
+    "Cython>=0.29.30,<3.0",
 ]
 
 
 [tool.towncrier]
     # Do no set this since it is hard to import numpy inside the source directory
     # the name is hardcoded. Use "--version 1.18.0" to set the version
-    single_file = true
+    single_file = false
     filename = "doc/source/release/{version}-notes.rst"
     directory = "doc/release/upcoming_changes/"
     issue_format = "`gh-{issue} `__"
@@ -74,3 +73,34 @@ requires = [
         directory = "change"
         name = "Changes"
         showcontent = true
+
+
+[tool.cibuildwheel]
+skip = "cp36-* cp37-* pp37-* *-manylinux_i686 *_ppc64le *_s390x *-musllinux*"
+build-verbosity = "3"
+before-build = "bash {project}/tools/wheels/cibw_before_build.sh {project}"
+before-test = "pip install -r {project}/test_requirements.txt"
+test-command = "bash {project}/tools/wheels/cibw_test_command.sh {project}"
+
+[tool.cibuildwheel.linux]
+manylinux-x86_64-image = "manylinux2014"
+manylinux-aarch64-image = "manylinux2014"
+environment = { CFLAGS="-std=c99 -fno-strict-aliasing", LDFLAGS="-Wl,--strip-debug", OPENBLAS64_="/usr/local", NPY_USE_BLAS_ILP64="1", RUNNER_OS="Linux" }
+
+[tool.cibuildwheel.macos]
+# For universal2 wheels, we will need to fuse them manually
+# instead of going through cibuildwheel
+# This is because cibuildwheel tries to make a fat wheel
+# https://github.com/multi-build/multibuild/blame/devel/README.rst#L541-L565
+# for more info
+archs = "x86_64 arm64"
+test-skip = "*_arm64 *_universal2:arm64"
+# MACOS linker doesn't support stripping symbols
+environment = { CFLAGS="-std=c99 -fno-strict-aliasing", OPENBLAS64_="/usr/local", NPY_USE_BLAS_ILP64="1", CC="clang", CXX = "clang++" }
+
+[tool.cibuildwheel.windows]
+environment = { OPENBLAS64_="openblas", OPENBLAS="", NPY_USE_BLAS_ILP64="1", CFLAGS="", LDFLAGS="" }
+
+[[tool.cibuildwheel.overrides]]
+select = "*-win32"
+environment = { OPENBLAS64_="", OPENBLAS="openblas", NPY_USE_BLAS_ILP64="0", CFLAGS="-m32", LDFLAGS="-m32" }
diff --git a/pytest.ini b/pytest.ini
index 92ce6d6e2ccb..29ec1d1a4fce 100644
--- a/pytest.ini
+++ b/pytest.ini
@@ -11,6 +11,8 @@ filterwarnings =
     ignore:numpy.dtype size changed
     ignore:numpy.ufunc size changed
     ignore::UserWarning:cpuinfo,
+    ignore: divide by zero encountered in log
+    ignore: invalid value encountered in log
 # Matrix PendingDeprecationWarning.
     ignore:the matrix subclass is not
     ignore:Importing from numpy.matlib is
@@ -18,3 +20,10 @@ filterwarnings =
     ignore:assertions not in test modules or plugins:pytest.PytestConfigWarning
 # TODO: remove below when array_api user warning is removed
     ignore:The numpy.array_api submodule is still experimental. See NEP 47.
+# ignore matplotlib headless warning for pyplot
+    ignore:Matplotlib is currently using agg, which is a non-GUI backend, so cannot show the figure.:UserWarning
+# Ignore DeprecationWarnings from distutils
+    ignore::DeprecationWarning:.*distutils
+    ignore:\n\n  `numpy.distutils`:DeprecationWarning
+# Ignore mypy >= 0.971 DeprecationWarnings
+    ignore:path is deprecated\. Use files\(\) instead:DeprecationWarning:mypy
diff --git a/release_requirements.txt b/release_requirements.txt
index c24e39c7849d..43a677e0569f 100644
--- a/release_requirements.txt
+++ b/release_requirements.txt
@@ -14,4 +14,3 @@ twine
 
 # building and notes
 Paver
-towncrier
diff --git a/runtests.py b/runtests.py
index ac057a358dd3..fea29a10dc49 100755
--- a/runtests.py
+++ b/runtests.py
@@ -199,8 +199,9 @@ def main(argv):
                 os.environ.get('PYTHONPATH', '')
             ))
     else:
-        _temp = __import__(PROJECT_MODULE)
-        site_dir = os.path.sep.join(_temp.__file__.split(os.path.sep)[:-2])
+        if not args.bench_compare:
+            _temp = __import__(PROJECT_MODULE)
+            site_dir = os.path.sep.join(_temp.__file__.split(os.path.sep)[:-2])
 
     extra_argv = args.args[:]
     if not args.bench:
@@ -286,6 +287,8 @@ def main(argv):
     if args.refguide_check:
         cmd = [os.path.join(ROOT_DIR, 'tools', 'refguide_check.py'),
                '--doctests']
+        if args.verbose:
+            cmd += ['-' + 'v'*args.verbose]
         if args.submodule:
             cmd += [args.submodule]
         os.execv(sys.executable, [sys.executable] + cmd)
diff --git a/setup.cfg b/setup.cfg
index f36b4b624066..387fe39b531c 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -1,5 +1,6 @@
 [codespell]
-skip = *-changelog.rst,*-notes.rst,f2c_blas.c,f2c_c_lapack.c,f2c_d_lapack.c,f2c_s_lapack.c,f2c_z_lapack.c
+skip = .git,*-changelog.rst,*-notes.rst,LICENSE_win32.txt,f2c_lapack.c,f2c_blas.c,f2c_c_lapack.c,f2c_d_lapack.c,f2c_s_lapack.c,f2c_z_lapack.c
+ignore-words-list = inout,dedented,nd,nin,asign
 
 # See the docstring in versioneer.py for instructions. Note that you must
 # re-run 'versioneer.py setup' after changing this section, and commit the
diff --git a/setup.py b/setup.py
index 703fe79e1694..cd5f79340805 100755
--- a/setup.py
+++ b/setup.py
@@ -1,25 +1,11 @@
 #!/usr/bin/env python3
-""" NumPy is the fundamental package for array computing with Python.
-
-It provides:
-
-- a powerful N-dimensional array object
-- sophisticated (broadcasting) functions
-- tools for integrating C/C++ and Fortran code
-- useful linear algebra, Fourier transform, and random number capabilities
-- and much more
-
-Besides its obvious scientific uses, NumPy can also be used as an efficient
-multi-dimensional container of generic data. Arbitrary data-types can be
-defined. This allows NumPy to seamlessly and speedily integrate with a wide
-variety of databases.
-
-All NumPy wheels distributed on PyPI are BSD licensed.
-
 """
-DOCLINES = (__doc__ or '').split("\n")
+Numpy build options can be modified with a site.cfg file. 
+See site.cfg.example for a template and more information.
+"""
 
 import os
+from pathlib import Path
 import sys
 import subprocess
 import textwrap
@@ -60,8 +46,8 @@
 MAJOR, MINOR, MICRO = _V_MATCH.groups()
 VERSION = '{}.{}.{}'.format(MAJOR, MINOR, MICRO)
 
-# The first version not in the `Programming Language :: Python :: ...` classifiers above
-if sys.version_info >= (3, 11):
+# The first version not in the `Programming Language :: Python :: ...` classifiers below
+if sys.version_info >= (3, 12):
     fmt = "NumPy {} may not yet support Python {}.{}."
     warnings.warn(
         fmt.format(VERSION, *sys.version_info[:2]),
@@ -80,6 +66,17 @@
 # so that it is in sys.modules
 import numpy.distutils.command.sdist
 import setuptools
+if int(setuptools.__version__.split('.')[0]) >= 60:
+    # setuptools >= 60 switches to vendored distutils by default; this
+    # may break the numpy build, so make sure the stdlib version is used
+    try:
+        setuptools_use_distutils = os.environ['SETUPTOOLS_USE_DISTUTILS']
+    except KeyError:
+        os.environ['SETUPTOOLS_USE_DISTUTILS'] = "stdlib"
+    else:
+        if setuptools_use_distutils != "stdlib":
+            raise RuntimeError("setuptools versions >= '60.0.0' require "
+                    "SETUPTOOLS_USE_DISTUTILS=stdlib in the environment")
 
 # Initialize cmdclass from versioneer
 from numpy.distutils.core import numpy_cmdclass
@@ -96,6 +93,7 @@
 Programming Language :: Python :: 3.8
 Programming Language :: Python :: 3.9
 Programming Language :: Python :: 3.10
+Programming Language :: Python :: 3.11
 Programming Language :: Python :: 3 :: Only
 Programming Language :: Python :: Implementation :: CPython
 Topic :: Software Development
@@ -191,7 +189,7 @@ def get_build_overrides():
     """
     from numpy.distutils.command.build_clib import build_clib
     from numpy.distutils.command.build_ext import build_ext
-    from distutils.version import LooseVersion
+    from numpy.compat import _pep440
 
     def _needs_gcc_c99_flag(obj):
         if obj.compiler.compiler_type != 'unix':
@@ -202,18 +200,19 @@ def _needs_gcc_c99_flag(obj):
             return False
 
         # will print something like '4.2.1\n'
-        out = subprocess.run([cc, '-dumpversion'], stdout=subprocess.PIPE,
-                             stderr=subprocess.PIPE, universal_newlines=True)
+        out = subprocess.run([cc, '-dumpversion'],
+                             capture_output=True, text=True)
         # -std=c99 is default from this version on
-        if LooseVersion(out.stdout) >= LooseVersion('5.0'):
+        if _pep440.parse(out.stdout) >= _pep440.Version('5.0'):
             return False
         return True
 
     class new_build_clib(build_clib):
         def build_a_library(self, build_info, lib_name, libraries):
+            from numpy.distutils.ccompiler_opt import NPY_CXX_FLAGS
             if _needs_gcc_c99_flag(self):
                 build_info['extra_cflags'] = ['-std=c99']
-            build_info['extra_cxxflags'] = ['-std=c++11']
+            build_info['extra_cxxflags'] = NPY_CXX_FLAGS
             build_clib.build_a_library(self, build_info, lib_name, libraries)
 
     class new_build_ext(build_ext):
@@ -226,6 +225,31 @@ def build_extension(self, ext):
 
 
 def generate_cython():
+    # Check Cython version
+    from numpy.compat import _pep440
+    try:
+        # try the cython in the installed python first (somewhat related to
+        # scipy/scipy#2397)
+        import Cython
+        from Cython.Compiler.Version import version as cython_version
+    except ImportError as e:
+        # The `cython` command need not point to the version installed in the
+        # Python running this script, so raise an error to avoid the chance of
+        # using the wrong version of Cython.
+        msg = 'Cython needs to be installed in Python as a module'
+        raise OSError(msg) from e
+    else:
+        # Note: keep in sync with that in pyproject.toml
+        # Update for Python 3.11
+        required_version = '0.29.30'
+
+        if _pep440.parse(cython_version) < _pep440.Version(required_version):
+            cython_path = Cython.__file__
+            msg = 'Building NumPy requires Cython >= {}, found {} at {}'
+            msg = msg.format(required_version, cython_version, cython_path)
+            raise RuntimeError(msg)
+
+    # Process files
     cwd = os.path.abspath(os.path.dirname(__file__))
     print("Cythonizing sources")
     for d in ('random',):
@@ -282,7 +306,7 @@ def parse_setuppy_commands():
 
               - `pip install .`       (from a git repo or downloaded source
                                        release)
-              - `pip install numpy`   (last NumPy release on PyPi)
+              - `pip install numpy`   (last NumPy release on PyPI)
 
             """))
         return True
@@ -294,7 +318,7 @@ def parse_setuppy_commands():
 
             To install NumPy from here with reliable uninstall, we recommend
             that you use `pip install .`. To install the latest NumPy release
-            from PyPi, use `pip install numpy`.
+            from PyPI, use `pip install numpy`.
 
             For help with build/installation issues, please ask on the
             numpy-discussion mailing list.  If you are sure that you have run
@@ -362,7 +386,7 @@ def get_docs_url():
     if 'dev' in VERSION:
         return "https://numpy.org/devdocs"
     else:
-        # For releases, this URL ends up on pypi.
+        # For releases, this URL ends up on PyPI.
         # By pinning the version, users looking at old PyPI releases can get
         # to the associated docs easily.
         return "https://numpy.org/doc/{}.{}".format(MAJOR, MINOR)
@@ -391,8 +415,9 @@ def setup_package():
         name='numpy',
         maintainer="NumPy Developers",
         maintainer_email="numpy-discussion@python.org",
-        description=DOCLINES[0],
-        long_description="\n".join(DOCLINES[2:]),
+        description="Fundamental package for array computing in Python",
+        long_description=Path("README.md").read_text(encoding="utf-8"),
+        long_description_content_type="text/markdown",
         url="https://www.numpy.org",
         author="Travis E. Oliphant et al.",
         download_url="https://pypi.python.org/pypi/numpy",
@@ -401,7 +426,7 @@ def setup_package():
             "Documentation": get_docs_url(),
             "Source Code": "https://github.com/numpy/numpy",
         },
-        license='BSD',
+        license='BSD-3-Clause',
         classifiers=[_f for _f in CLASSIFIERS.split('\n') if _f],
         platforms=["Windows", "Linux", "Solaris", "Mac OS-X", "Unix"],
         test_suite='pytest',
@@ -412,6 +437,7 @@ def setup_package():
         entry_points={
             'console_scripts': f2py_cmds,
             'array_api': ['numpy = numpy.array_api'],
+            'pyinstaller40': ['hook-dirs = numpy:_pyinstaller_hooks_dir'],
         },
     )
 
@@ -437,6 +463,9 @@ def setup_package():
     else:
         #from numpy.distutils.core import setup
         from setuptools import setup
+        # workaround for broken --no-build-isolation with newer setuptools,
+        # see gh-21288
+        metadata["packages"] = []
 
     try:
         setup(**metadata)
diff --git a/site.cfg.example b/site.cfg.example
index 1a6b36d2c6eb..4df01a2106e3 100644
--- a/site.cfg.example
+++ b/site.cfg.example
@@ -85,10 +85,11 @@
 # ATLAS
 # -----
 # ATLAS is an open source optimized implementation of the BLAS and LAPACK
-# routines. NumPy will try to build against ATLAS by default when available in
-# the system library dirs. To build NumPy against a custom installation of
-# ATLAS you can add an explicit section such as the following. Here we assume
-# that ATLAS was configured with ``prefix=/opt/atlas``.
+# routines. NumPy will try to build against ATLAS when available in
+# the system library dirs (and OpenBLAS, MKL and BLIS are not installed). To
+# build NumPy against a custom installation of ATLAS you can add an explicit
+# section such as the following. Here we assume that ATLAS was configured with
+# ``prefix=/opt/atlas``.
 #
 # [atlas]
 # library_dirs = /opt/atlas/lib
@@ -96,29 +97,11 @@
 
 # OpenBLAS
 # --------
-# OpenBLAS is another open source optimized implementation of BLAS and LAPACK
-# and can be seen as an alternative to ATLAS. To build NumPy against OpenBLAS
-# instead of ATLAS, use this section instead of the above, adjusting as needed
-# for your configuration (in the following example we installed OpenBLAS with
-# ``make install PREFIX=/opt/OpenBLAS``.
-# OpenBLAS is generically installed as a shared library, to force the OpenBLAS
-# library linked to also be used at runtime you can utilize the
-# runtime_library_dirs variable.
-#
-# **Warning**: OpenBLAS, by default, is built in multithreaded mode. Due to the
-# way Python's multiprocessing is implemented, a multithreaded OpenBLAS can
-# cause programs using both to hang as soon as a worker process is forked on
-# POSIX systems (Linux, Mac).
-# This is fixed in OpenBLAS 0.2.9 for the pthread build, the OpenMP build using
-# GNU openmp is as of gcc-4.9 not fixed yet.
-# Python 3.4 will introduce a new feature in multiprocessing, called the
-# "forkserver", which solves this problem. For older versions, make sure
-# OpenBLAS is built using pthreads or use Python threads instead of
-# multiprocessing.
-# (This problem does not exist with multithreaded ATLAS.)
-#
-# https://docs.python.org/library/multiprocessing.html#contexts-and-start-methods
-# https://github.com/xianyi/OpenBLAS/issues/294
+# OpenBLAS is an open source optimized implementation of BLAS and LAPACK
+# and is the default choice for NumPy itself (CI, wheels). OpenBLAS will be
+# selected above ATLAS and Netlib BLAS/LAPACK.  OpenBLAS is generically
+# installed as a shared library, to force the OpenBLAS library linked to also
+# be used at runtime you can utilize the runtime_library_dirs variable.
 #
 # [openblas]
 # libraries = openblas
diff --git a/test_requirements.txt b/test_requirements.txt
index 256b26d9b84a..67b6a48667b8 100644
--- a/test_requirements.txt
+++ b/test_requirements.txt
@@ -1,13 +1,16 @@
-cython==0.29.24
-wheel<0.37.1
-setuptools<49.2.0
+cython>=0.29.30,<3.0
+wheel==0.37.0
+setuptools==59.2.0
 hypothesis==6.24.1
 pytest==6.2.5
 pytz==2021.3
 pytest-cov==3.0.0
-pickle5; python_version == '3.7' and platform_python_implementation != 'PyPy'
 # for numpy.random.test.test_extending
 cffi; python_version < '3.10'
 # For testing types. Notes on the restrictions:
 # - Mypy relies on C API features not present in PyPy
-mypy==0.910; platform_python_implementation != "PyPy"
+# NOTE: Keep mypy in sync with environment.yml
+mypy==0.981; platform_python_implementation != "PyPy"
+typing_extensions>=4.2.0
+# for optional f2py encoding detection
+charset-normalizer
diff --git a/tools/allocation_tracking/README.md b/tools/allocation_tracking/README.md
index fd4f2c871940..6cc4c2a582f4 100644
--- a/tools/allocation_tracking/README.md
+++ b/tools/allocation_tracking/README.md
@@ -1,11 +1,7 @@
-Example for using the `PyDataMem_SetEventHook` to track allocations inside numpy.
-
-`alloc_hook.pyx` implements a hook in Cython that calls back into a python
-function. `track_allocations.py` uses it for a simple listing of allocations.
-It can be built with the `setup.py` file in this folder.
-
 Note that since Python 3.6 the builtin tracemalloc module can be used to
 track allocations inside numpy.
 Numpy places its CPU memory allocations into the `np.lib.tracemalloc_domain`
 domain.
 See https://docs.python.org/3/library/tracemalloc.html.
+
+The tool that used to be here has been deprecated.
diff --git a/tools/allocation_tracking/alloc_hook.pyx b/tools/allocation_tracking/alloc_hook.pyx
deleted file mode 100644
index eeefe1704a6c..000000000000
--- a/tools/allocation_tracking/alloc_hook.pyx
+++ /dev/null
@@ -1,42 +0,0 @@
-# A cython wrapper for using python functions as callbacks for
-# PyDataMem_SetEventHook.
-
-cimport numpy as np
-
-cdef extern from "Python.h":
-    object PyLong_FromVoidPtr(void *)
-    void *PyLong_AsVoidPtr(object)
-
-ctypedef void PyDataMem_EventHookFunc(void *inp, void *outp, size_t size,
-                                      void *user_data)
-cdef extern from "numpy/arrayobject.h":
-    PyDataMem_EventHookFunc * \
-        PyDataMem_SetEventHook(PyDataMem_EventHookFunc *newhook,
-                               void *user_data, void **old_data)
-
-np.import_array()
-
-cdef void pyhook(void *old, void *new, size_t size, void *user_data):
-    cdef object pyfunc =  user_data
-    pyfunc(PyLong_FromVoidPtr(old),
-           PyLong_FromVoidPtr(new),
-           size)
-
-class NumpyAllocHook:
-    def __init__(self, callback):
-        self.callback = callback
-
-    def __enter__(self):
-        cdef void *old_hook, *old_data
-        old_hook =  \
-            PyDataMem_SetEventHook( pyhook,
-                                     self.callback,
-                                     &old_data)
-        self.old_hook = PyLong_FromVoidPtr(old_hook)
-        self.old_data = PyLong_FromVoidPtr(old_data)
-
-    def __exit__(self):
-        PyDataMem_SetEventHook( \
-                                    PyLong_AsVoidPtr(self.old_hook),
-                                 PyLong_AsVoidPtr(self.old_data),
-                                 0)
diff --git a/tools/allocation_tracking/setup.py b/tools/allocation_tracking/setup.py
deleted file mode 100644
index 4462f9f4ec8c..000000000000
--- a/tools/allocation_tracking/setup.py
+++ /dev/null
@@ -1,9 +0,0 @@
-from distutils.core import setup
-from distutils.extension import Extension
-from Cython.Distutils import build_ext
-import numpy
-
-setup(
-    cmdclass = {'build_ext': build_ext},
-    ext_modules = [Extension("alloc_hook", ["alloc_hook.pyx"],
-                             include_dirs=[numpy.get_include()])])
diff --git a/tools/allocation_tracking/sorttable.js b/tools/allocation_tracking/sorttable.js
deleted file mode 100644
index c9528873e011..000000000000
--- a/tools/allocation_tracking/sorttable.js
+++ /dev/null
@@ -1,493 +0,0 @@
-/*
-  SortTable
-  version 2
-  7th April 2007
-  Stuart Langridge, https://www.kryogenix.org/code/browser/sorttable/
-  
-  Instructions:
-  Download this file
-  Add  to your HTML
-  Add class="sortable" to any table you'd like to make sortable
-  Click on the headers to sort
-  
-  Thanks to many, many people for contributions and suggestions.
-  Licenced as X11: https://www.kryogenix.org/code/browser/licence.html
-  This basically means: do what you want with it.
-*/
-
- 
-var stIsIE = /*@cc_on!@*/false;
-
-sorttable = {
-  init: function() {
-    // quit if this function has already been called
-    if (arguments.callee.done) return;
-    // flag this function so we don't do the same thing twice
-    arguments.callee.done = true;
-    // kill the timer
-    if (_timer) clearInterval(_timer);
-    
-    if (!document.createElement || !document.getElementsByTagName) return;
-    
-    sorttable.DATE_RE = /^(\d\d?)[\/\.-](\d\d?)[\/\.-]((\d\d)?\d\d)$/;
-    
-    forEach(document.getElementsByTagName('table'), function(table) {
-      if (table.className.search(/\bsortable\b/) != -1) {
-        sorttable.makeSortable(table);
-      }
-    });
-    
-  },
-  
-  makeSortable: function(table) {
-    if (table.getElementsByTagName('thead').length == 0) {
-      // table doesn't have a tHead. Since it should have, create one and
-      // put the first table row in it.
-      the = document.createElement('thead');
-      the.appendChild(table.rows[0]);
-      table.insertBefore(the,table.firstChild);
-    }
-    // Safari doesn't support table.tHead, sigh
-    if (table.tHead == null) table.tHead = table.getElementsByTagName('thead')[0];
-    
-    if (table.tHead.rows.length != 1) return; // can't cope with two header rows
-    
-    // Sorttable v1 put rows with a class of "sortbottom" at the bottom (as
-    // "total" rows, for example). This is B&R, since what you're supposed
-    // to do is put them in a tfoot. So, if there are sortbottom rows,
-    // for backwards compatibility, move them to tfoot (creating it if needed).
-    sortbottomrows = [];
-    for (var i=0; i5' : ' ▴';
-            this.appendChild(sortrevind);
-            return;
-          }
-          if (this.className.search(/\bsorttable_sorted_reverse\b/) != -1) {
-            // if we're already sorted by this column in reverse, just 
-            // re-reverse the table, which is quicker
-            sorttable.reverse(this.sorttable_tbody);
-            this.className = this.className.replace('sorttable_sorted_reverse',
-                                                    'sorttable_sorted');
-            this.removeChild(document.getElementById('sorttable_sortrevind'));
-            sortfwdind = document.createElement('span');
-            sortfwdind.id = "sorttable_sortfwdind";
-            sortfwdind.innerHTML = stIsIE ? ' 6' : ' ▾';
-            this.appendChild(sortfwdind);
-            return;
-          }
-          
-          // remove sorttable_sorted classes
-          theadrow = this.parentNode;
-          forEach(theadrow.childNodes, function(cell) {
-            if (cell.nodeType == 1) { // an element
-              cell.className = cell.className.replace('sorttable_sorted_reverse','');
-              cell.className = cell.className.replace('sorttable_sorted','');
-            }
-          });
-          sortfwdind = document.getElementById('sorttable_sortfwdind');
-          if (sortfwdind) { sortfwdind.parentNode.removeChild(sortfwdind); }
-          sortrevind = document.getElementById('sorttable_sortrevind');
-          if (sortrevind) { sortrevind.parentNode.removeChild(sortrevind); }
-          
-          this.className += ' sorttable_sorted';
-          sortfwdind = document.createElement('span');
-          sortfwdind.id = "sorttable_sortfwdind";
-          sortfwdind.innerHTML = stIsIE ? ' 6' : ' ▾';
-          this.appendChild(sortfwdind);
-
-	        // build an array to sort. This is a Schwartzian transform thing,
-	        // i.e., we "decorate" each row with the actual sort key,
-	        // sort based on the sort keys, and then put the rows back in order
-	        // which is a lot faster because you only do getInnerText once per row
-	        row_array = [];
-	        col = this.sorttable_columnindex;
-	        rows = this.sorttable_tbody.rows;
-	        for (var j=0; j 12) {
-            // definitely dd/mm
-            return sorttable.sort_ddmm;
-          } else if (second > 12) {
-            return sorttable.sort_mmdd;
-          } else {
-            // looks like a date, but we can't tell which, so assume
-            // that it's dd/mm (English imperialism!) and keep looking
-            sortfn = sorttable.sort_ddmm;
-          }
-        }
-      }
-    }
-    return sortfn;
-  },
-  
-  getInnerText: function(node) {
-    // gets the text we want to use for sorting for a cell.
-    // strips leading and trailing whitespace.
-    // this is *not* a generic getInnerText function; it's special to sorttable.
-    // for example, you can override the cell text with a customkey attribute.
-    // it also gets .value for  fields.
-    
-    hasInputs = (typeof node.getElementsByTagName == 'function') &&
-                 node.getElementsByTagName('input').length;
-    
-    if (node.getAttribute("sorttable_customkey") != null) {
-      return node.getAttribute("sorttable_customkey");
-    }
-    else if (typeof node.textContent != 'undefined' && !hasInputs) {
-      return node.textContent.replace(/^\s+|\s+$/g, '');
-    }
-    else if (typeof node.innerText != 'undefined' && !hasInputs) {
-      return node.innerText.replace(/^\s+|\s+$/g, '');
-    }
-    else if (typeof node.text != 'undefined' && !hasInputs) {
-      return node.text.replace(/^\s+|\s+$/g, '');
-    }
-    else {
-      switch (node.nodeType) {
-        case 3:
-          if (node.nodeName.toLowerCase() == 'input') {
-            return node.value.replace(/^\s+|\s+$/g, '');
-          }
-        case 4:
-          return node.nodeValue.replace(/^\s+|\s+$/g, '');
-          break;
-        case 1:
-        case 11:
-          var innerText = '';
-          for (var i = 0; i < node.childNodes.length; i++) {
-            innerText += sorttable.getInnerText(node.childNodes[i]);
-          }
-          return innerText.replace(/^\s+|\s+$/g, '');
-          break;
-        default:
-          return '';
-      }
-    }
-  },
-  
-  reverse: function(tbody) {
-    // reverse the rows in a tbody
-    newrows = [];
-    for (var i=0; i=0; i--) {
-       tbody.appendChild(newrows[i]);
-    }
-    delete newrows;
-  },
-  
-  /* sort functions
-     each sort function takes two parameters, a and b
-     you are comparing a[0] and b[0] */
-  sort_numeric: function(a,b) {
-    aa = parseFloat(a[0].replace(/[^0-9.-]/g,''));
-    if (isNaN(aa)) aa = 0;
-    bb = parseFloat(b[0].replace(/[^0-9.-]/g,'')); 
-    if (isNaN(bb)) bb = 0;
-    return aa-bb;
-  },
-  sort_alpha: function(a,b) {
-    if (a[0]==b[0]) return 0;
-    if (a[0] 0 ) {
-                var q = list[i]; list[i] = list[i+1]; list[i+1] = q;
-                swap = true;
-            }
-        } // for
-        t--;
-
-        if (!swap) break;
-
-        for(var i = t; i > b; --i) {
-            if ( comp_func(list[i], list[i-1]) < 0 ) {
-                var q = list[i]; list[i] = list[i-1]; list[i-1] = q;
-                swap = true;
-            }
-        } // for
-        b++;
-
-    } // while(swap)
-  }  
-}
-
-/* ******************************************************************
-   Supporting functions: bundled here to avoid depending on a library
-   ****************************************************************** */
-
-// Dean Edwards/Matthias Miller/John Resig
-
-/* for Mozilla/Opera9 */
-if (document.addEventListener) {
-    document.addEventListener("DOMContentLoaded", sorttable.init, false);
-}
-
-/* for Internet Explorer */
-/*@cc_on @*/
-/*@if (@_win32)
-    document.write("\n')
-            f.write('\n')
-            f.write("\n")
-            cols = "event#,lineinfo,bytes allocated,bytes freed,#allocations,#frees,max memory usage,long lived bytes".split(',')
-            for header in cols:
-                f.write("  ".format(header))
-            f.write("\n\n")
-            for idx, event in enumerate(self.allocation_trace):
-                f.write("\n")
-                event = [idx] + list(event)
-                for col, val in zip(cols, event):
-                    if col == 'lineinfo':
-                        # special handling
-                        try:
-                            filename, line, module, code, index = val
-                            val = "{0}({1}): {2}".format(filename, line, code[index])
-                        except Exception:
-                            # sometimes this info is not available (from eval()?)
-                            val = str(val)
-                    f.write("  ".format(val))
-                f.write("\n\n")
-            f.write("
{0}
{0}
\n")
-
-
-if __name__ == '__main__':
-    tracker = AllocationTracker(1000)
-    with tracker:
-        for i in range(100):
-            np.zeros(i * 100)
-            np.zeros(i * 200)
-    tracker.write_html("allocations.html")
diff --git a/tools/changelog.py b/tools/changelog.py
index 444d96882216..7b7e66ddb511 100755
--- a/tools/changelog.py
+++ b/tools/changelog.py
@@ -39,9 +39,6 @@
 from git import Repo
 from github import Github
 
-if sys.version_info[:2] < (3, 6):
-    raise RuntimeError("Python version must be >= 3.6")
-
 this_repo = Repo(os.path.join(os.path.dirname(__file__), ".."))
 
 author_msg =\
diff --git a/tools/ci/cirrus_general.yml b/tools/ci/cirrus_general.yml
new file mode 100644
index 000000000000..252a459699b7
--- /dev/null
+++ b/tools/ci/cirrus_general.yml
@@ -0,0 +1,99 @@
+build_and_store_wheels: &BUILD_AND_STORE_WHEELS
+  install_cibuildwheel_script:
+    - python -m pip install cibuildwheel==2.11.2
+  cibuildwheel_script:
+    - cibuildwheel
+  wheels_artifacts:
+    path: "wheelhouse/*"
+
+
+######################################################################
+# Build linux_aarch64 natively
+######################################################################
+
+linux_aarch64_task:
+  compute_engine_instance:
+    image_project: cirrus-images
+    image: family/docker-builder-arm64
+    architecture: arm64
+    platform: linux
+    cpu: 2
+    memory: 8G
+  matrix:
+    # build in a matrix because building and testing all four wheels in a
+    # single task takes longer than 60 mins (the default time limit for a
+    # cirrus-ci task).
+    - env:
+        CIBW_BUILD: cp38-*
+        EXPECT_CPU_FEATURES: NEON NEON_FP16 NEON_VFPV4 ASIMD ASIMDHP ASIMDDP ASIMDFHM
+    - env:
+        CIBW_BUILD: cp39-*
+    - env:
+        CIBW_BUILD: cp310-*
+    - env:
+        CIBW_BUILD: cp311-*
+
+  build_script: |
+    apt install -y python3-venv python-is-python3 gfortran libatlas-base-dev libgfortran5 eatmydata
+    git fetch origin
+    ./tools/travis-before-install.sh
+    which python
+    echo $CIRRUS_CHANGE_MESSAGE
+  <<: *BUILD_AND_STORE_WHEELS
+
+
+######################################################################
+# Upload all wheels
+######################################################################
+
+wheels_upload_task:
+  # Artifacts don't seem to be persistent from task to task.
+  # Rather than upload wheels at the end of each cibuildwheel run we do a
+  # final upload here. This is because a run may be on different OS for
+  # which bash, etc, may not be present.
+  depends_on:
+    - linux_aarch64
+  compute_engine_instance:
+    image_project: cirrus-images
+    image: family/docker-builder
+    platform: linux
+    cpu: 1
+
+  env:
+    NUMPY_STAGING_UPLOAD_TOKEN: ENCRYPTED[!5a69522ae0c2af9edb2bc1cdfeaca6292fb3666d9ecd82dca0615921834a6ce3b702352835d8bde4ea2a9ed5ef8424ac!]
+    NUMPY_NIGHTLY_UPLOAD_TOKEN: ENCRYPTED[!196422e6c3419a3b1d79815e1026094a215cb0f346fe34ed0f9d3ca1c19339df7398d04556491b1e0420fc1fe3713289!]
+
+  upload_script: |
+    apt-get install -y python3-venv python-is-python3 curl
+    export IS_SCHEDULE_DISPATCH="false"
+    export IS_PUSH="false"
+
+    # cron job
+    if [[ "$CIRRUS_CRON" == "weekly" ]]; then
+      export IS_SCHEDULE_DISPATCH="true"
+    fi
+
+    # a manual build was started
+    if [[ "$CIRRUS_BUILD_SOURCE" == "api" && "$CIRRUS_COMMIT_MESSAGE" == "API build for null" ]]; then
+      export IS_SCHEDULE_DISPATCH="true"
+    fi
+
+    # only upload wheels to staging if it's a tag beginning with 'v' and you're
+    # on a maintenance branch
+    if [[ "$CIRRUS_TAG" == v* ]] && [[ $CIRRUS_TAG != *"dev0"* ]]; then
+      export IS_PUSH="true"
+    fi
+
+    # The name of the zip file is derived from the `wheels_artifact` line.
+    # If you change the artifact line to `myfile_artifact` then it would be
+    # called myfile.zip
+
+    curl https://api.cirrus-ci.com/v1/artifact/build/$CIRRUS_BUILD_ID/wheels.zip --output wheels.zip
+    unzip wheels.zip
+
+    source ./tools/wheels/upload_wheels.sh
+    # IS_PUSH takes precedence over IS_SCHEDULE_DISPATCH
+    set_upload_vars
+
+    # Will be skipped if not a push/tag/scheduled build
+    upload_wheels
diff --git a/tools/ci/push_docs_to_repo.py b/tools/ci/push_docs_to_repo.py
index 058f748ec1af..e34522a2945a 100755
--- a/tools/ci/push_docs_to_repo.py
+++ b/tools/ci/push_docs_to_repo.py
@@ -46,7 +46,7 @@ def run(cmd, stdout=True):
 
 run(['git', 'init'])
 # ensure the working branch is called "main"
-# (`--initial-branch=main` appared to have failed on older git versions):
+# (`--initial-branch=main` appeared to have failed on older git versions):
 run(['git', 'checkout', '-b', 'main'])
 run(['git', 'remote', 'add', 'origin',  args.remote])
 run(['git', 'config', '--local', 'user.name', args.committer])
diff --git a/tools/cythonize.py b/tools/cythonize.py
index c06962cf98a9..311a52c915a2 100755
--- a/tools/cythonize.py
+++ b/tools/cythonize.py
@@ -18,10 +18,6 @@
 files; while waiting for a proper build system. Uses file hashes to
 figure out if rebuild is needed.
 
-For now, this script should be run by developers when changing Cython files
-only, and the resulting C files checked in, so that end-users (and Python-only
-developers) do not get the Cython/Tempita dependencies.
-
 Originally written by Dag Sverre Seljebotn, and copied here from:
 
 https://raw.github.com/dagss/private-scipy-refactor/cythonize/cythonize.py
@@ -48,33 +44,8 @@ def process_pyx(fromfile, tofile):
     if tofile.endswith('.cxx'):
         flags.append('--cplus')
 
-    try:
-        # try the cython in the installed python first (somewhat related to scipy/scipy#2397)
-        import Cython
-        from Cython.Compiler.Version import version as cython_version
-    except ImportError as e:
-        # The `cython` command need not point to the version installed in the
-        # Python running this script, so raise an error to avoid the chance of
-        # using the wrong version of Cython.
-        msg = 'Cython needs to be installed in Python as a module'
-        raise OSError(msg) from e
-    else:
-        # check the version, and invoke through python
-        from distutils.version import LooseVersion
-
-        # Cython 0.29.21 is required for Python 3.9 and there are
-        # other fixes in the 0.29 series that are needed even for earlier
-        # Python versions.
-        # Note: keep in sync with that in pyproject.toml
-        # Update for Python 3.10
-        required_version = LooseVersion('0.29.24')
-
-        if LooseVersion(cython_version) < required_version:
-            cython_path = Cython.__file__
-            raise RuntimeError(f'Building {VENDOR} requires Cython >= {required_version}'
-                               f', found {cython_version} at {cython_path}')
-        subprocess.check_call(
-            [sys.executable, '-m', 'cython'] + flags + ["-o", tofile, fromfile])
+    subprocess.check_call(
+        [sys.executable, '-m', 'cython'] + flags + ["-o", tofile, fromfile])
 
 
 def process_tempita_pyx(fromfile, tofile):
diff --git a/tools/download-wheels.py b/tools/download-wheels.py
index dd066d9adba9..41e1e9e5d849 100644
--- a/tools/download-wheels.py
+++ b/tools/download-wheels.py
@@ -31,11 +31,17 @@
 import urllib3
 from bs4 import BeautifulSoup
 
-__version__ = '0.1'
+__version__ = "0.1"
 
 # Edit these for other projects.
-STAGING_URL = 'https://anaconda.org/multibuild-wheels-staging/numpy'
-PREFIX = 'numpy'
+STAGING_URL = "https://anaconda.org/multibuild-wheels-staging/numpy"
+PREFIX = "numpy"
+
+# Name endings of the files to download.
+WHL = r"-.*\.whl$"
+ZIP = r"\.zip$"
+GZIP = r"\.tar\.gz$"
+SUFFIX = rf"({WHL}|{GZIP}|{ZIP})"
 
 
 def get_wheel_names(version):
@@ -50,11 +56,11 @@ def get_wheel_names(version):
         The release version. For instance, "1.18.3".
 
     """
-    http = urllib3.PoolManager(cert_reqs='CERT_REQUIRED')
-    tmpl = re.compile(rf"^.*{PREFIX}-{version}-.*\.whl$")
+    http = urllib3.PoolManager(cert_reqs="CERT_REQUIRED")
+    tmpl = re.compile(rf"^.*{PREFIX}-{version}{SUFFIX}")
     index_url = f"{STAGING_URL}/files"
-    index_html = http.request('GET', index_url)
-    soup = BeautifulSoup(index_html.data, 'html.parser')
+    index_html = http.request("GET", index_url)
+    soup = BeautifulSoup(index_html.data, "html.parser")
     return soup.findAll(text=tmpl)
 
 
@@ -72,20 +78,20 @@ def download_wheels(version, wheelhouse):
         Directory in which to download the wheels.
 
     """
-    http = urllib3.PoolManager(cert_reqs='CERT_REQUIRED')
+    http = urllib3.PoolManager(cert_reqs="CERT_REQUIRED")
     wheel_names = get_wheel_names(version)
 
     for i, wheel_name in enumerate(wheel_names):
         wheel_url = f"{STAGING_URL}/{version}/download/{wheel_name}"
         wheel_path = os.path.join(wheelhouse, wheel_name)
-        with open(wheel_path, 'wb') as f:
-            with http.request('GET', wheel_url, preload_content=False,) as r:
+        with open(wheel_path, "wb") as f:
+            with http.request("GET", wheel_url, preload_content=False,) as r:
                 print(f"{i + 1:<4}{wheel_name}")
                 shutil.copyfileobj(r, f)
     print(f"\nTotal files downloaded: {len(wheel_names)}")
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     parser = argparse.ArgumentParser()
     parser.add_argument(
         "version",
diff --git a/tools/find_deprecated_escaped_characters.py b/tools/find_deprecated_escaped_characters.py
index 22efaae65b69..d7225b8e85f6 100644
--- a/tools/find_deprecated_escaped_characters.py
+++ b/tools/find_deprecated_escaped_characters.py
@@ -7,7 +7,7 @@
 be written as '\\(' or r'\('.
 
 """
-import sys
+
 
 def main(root):
     """Find deprecated escape sequences.
@@ -56,9 +56,6 @@ def main(root):
 if __name__ == "__main__":
     from argparse import ArgumentParser
 
-    if sys.version_info[:2] < (3, 6):
-        raise RuntimeError("Python version must be >= 3.6")
-
     parser = ArgumentParser(description="Find deprecated escaped characters")
     parser.add_argument('root', help='directory or file to be checked')
     args = parser.parse_args()
diff --git a/tools/functions_missing_types.py b/tools/functions_missing_types.py
index 0461aabd3634..99c6887a981b 100755
--- a/tools/functions_missing_types.py
+++ b/tools/functions_missing_types.py
@@ -32,7 +32,6 @@
         "math",
         # Accidentally public, deprecated, or shouldn't be used
         "Tester",
-        "alen",
         "add_docstring",
         "add_newdoc",
         "add_newdoc_ufunc",
diff --git a/tools/gitpod/Dockerfile b/tools/gitpod/Dockerfile
index e2e0e1bc9571..dd5561750243 100644
--- a/tools/gitpod/Dockerfile
+++ b/tools/gitpod/Dockerfile
@@ -27,7 +27,7 @@
 # OS/ARCH: linux/amd64
 FROM gitpod/workspace-base:latest
 
-ARG MAMBAFORGE_VERSION="4.10.0-0"
+ARG MAMBAFORGE_VERSION="4.11.0-0"
 ARG CONDA_ENV=numpy-dev
 
 
@@ -53,10 +53,10 @@ RUN apt-get update && \
     texlive-latex-extra \
     vim && \
     # this needs to be done after installing dirmngr
-    apt-key adv --keyserver keyserver.ubuntu.com --recv-key C99B11DEB97541F0 && \
-    apt-add-repository https://cli.github.com/packages && \
+    apt-key adv --keyserver keyserver.ubuntu.com --recv-key 23F3D4EA75716059 && \ 
+    apt-add-repository https://cli.github.com/packages && \ 
     apt-get install -yq --no-install-recommends \
-    gh && \
+    gh && \ 
     locale-gen en_US.UTF-8 && \
     apt-get clean && \
     rm -rf /var/cache/apt/* &&\
diff --git a/tools/gitpod/gitpod.Dockerfile b/tools/gitpod/gitpod.Dockerfile
index 7894be5bc358..8dac0d597d5c 100644
--- a/tools/gitpod/gitpod.Dockerfile
+++ b/tools/gitpod/gitpod.Dockerfile
@@ -34,6 +34,7 @@ COPY --from=clone --chown=gitpod /tmp/numpy ${WORKSPACE}
 WORKDIR ${WORKSPACE}
 
 # Build numpy to populate the cache used by ccache
+RUN git config --global --add safe.directory /workspace/numpy
 RUN git submodule update --init --depth=1 -- numpy/core/src/umath/svml
 RUN conda activate ${CONDA_ENV} && \ 
     python setup.py build_ext --inplace && \
diff --git a/tools/gitpod/settings.json b/tools/gitpod/settings.json
index 8f070c04c05a..50296336dde4 100644
--- a/tools/gitpod/settings.json
+++ b/tools/gitpod/settings.json
@@ -1,9 +1,8 @@
 {
-    "restructuredtext.languageServer.disabled": true,
-    "restructuredtext.builtDocumentationPath": "${workspaceRoot}/doc/build/html",
-    "restructuredtext.confPath": "",
     "restructuredtext.updateOnTextChanged": "true",
     "restructuredtext.updateDelay": 300,
-    "restructuredtext.linter.disabled": true,
-    "python.pythonPath": "/home/gitpod/mambaforge3/envs/numpy-dev/bin/python"
+    "restructuredtext.linter.disabledLinters": ["doc8","rst-lint", "rstcheck"],
+    "python.defaultInterpreterPath": "/home/gitpod/mambaforge3/envs/numpy-dev/bin/python",
+    "esbonio.sphinx.buildDir": "${workspaceRoot}/doc/build/html",
+    "esbonio.sphinx.confDir": ""
 }
\ No newline at end of file
diff --git a/tools/lint_diff.ini b/tools/lint_diff.ini
index 9e31050b78a4..cfa2c5af9dae 100644
--- a/tools/lint_diff.ini
+++ b/tools/lint_diff.ini
@@ -2,4 +2,4 @@
 max_line_length = 79
 statistics = True
 ignore = E121,E122,E123,E125,E126,E127,E128,E226,E241,E251,E265,E266,E302,E402,E704,E712,E721,E731,E741,W291,W293,W391,W503,W504
-exclude = numpy/__config__.py,numpy/typing/tests/data
+exclude = versioneer.py,numpy/_version.py,numpy/__config__.py,numpy/typing/tests/data
diff --git a/tools/openblas_support.py b/tools/openblas_support.py
index 4eb72dbc9b4b..ed43804af122 100644
--- a/tools/openblas_support.py
+++ b/tools/openblas_support.py
@@ -13,8 +13,8 @@
 from urllib.request import urlopen, Request
 from urllib.error import HTTPError
 
-OPENBLAS_V = '0.3.18'
-OPENBLAS_LONG = 'v0.3.18'
+OPENBLAS_V = '0.3.21'
+OPENBLAS_LONG = 'v0.3.21'
 BASE_LOC = 'https://anaconda.org/multibuild-wheels-staging/openblas-libs'
 BASEURL = f'{BASE_LOC}/{OPENBLAS_LONG}/download'
 SUPPORTED_PLATFORMS = [
@@ -54,13 +54,10 @@ def get_ilp64():
 
 
 def get_manylinux(arch):
-    if arch in ('x86_64', 'i686'):
-        default = '2010'
-    else:
-        default = '2014'
+    default = '2014'
     ret = os.environ.get("MB_ML_VER", default)
     # XXX For PEP 600 this can be a glibc version
-    assert ret in ('1', '2010', '2014', '_2_24'), f'invalid MB_ML_VER {ret}'
+    assert ret in ('2010', '2014', '_2_24'), f'invalid MB_ML_VER {ret}'
     return ret
 
 
@@ -77,16 +74,16 @@ def download_openblas(target, plat, ilp64):
         suffix = f'manylinux{ml_ver}_{arch}.tar.gz'
         typ = 'tar.gz'
     elif plat == 'macosx-x86_64':
-        suffix = 'macosx_10_9_x86_64-gf_1becaaa.tar.gz'
+        suffix = 'macosx_10_9_x86_64-gf_c469a42.tar.gz'
         typ = 'tar.gz'
     elif plat == 'macosx-arm64':
-        suffix = 'macosx_11_0_arm64-gf_f26990f.tar.gz'
+        suffix = 'macosx_11_0_arm64-gf_5272328.tar.gz'
         typ = 'tar.gz'
     elif osname == 'win':
         if plat == "win-32":
-            suffix = 'win32-gcc_8_1_0.zip'
+            suffix = 'win32-gcc_8_3_0.zip'
         else:
-            suffix = 'win_amd64-gcc_8_1_0.zip'
+            suffix = 'win_amd64-gcc_10_3_0.zip'
         typ = 'zip'
 
     if not suffix:
@@ -102,11 +99,11 @@ def download_openblas(target, plat, ilp64):
     if response.status != 200:
         print(f'Could not download "{filename}"', file=sys.stderr)
         return None
-    print(f"Downloading {length} from {filename}", file=sys.stderr)
+    # print(f"Downloading {length} from {filename}", file=sys.stderr)
     data = response.read()
     # Verify hash
     key = os.path.basename(filename)
-    print("Saving to file", file=sys.stderr)
+    # print("Saving to file", file=sys.stderr)
     with open(target, 'wb') as fid:
         fid.write(data)
     return typ
@@ -133,28 +130,34 @@ def setup_openblas(plat=get_plat(), ilp64=get_ilp64()):
     if osname == 'win':
         if not typ == 'zip':
             return f'expecting to download zipfile on windows, not {typ}'
-        return unpack_windows_zip(tmp)
+        return unpack_windows_zip(tmp, plat)
     else:
         if not typ == 'tar.gz':
             return 'expecting to download tar.gz, not %s' % str(typ)
         return unpack_targz(tmp)
 
 
-def unpack_windows_zip(fname):
+def unpack_windows_zip(fname, plat):
+    unzip_base = os.path.join(gettempdir(), 'openblas')
+    if not os.path.exists(unzip_base):
+        os.mkdir(unzip_base)
     with zipfile.ZipFile(fname, 'r') as zf:
-        # Get the openblas.a file, but not openblas.dll.a nor openblas.dev.a
-        lib = [x for x in zf.namelist() if OPENBLAS_LONG in x and
-               x.endswith('a') and not x.endswith('dll.a') and
-               not x.endswith('dev.a')]
-        if not lib:
-            return 'could not find libopenblas_%s*.a ' \
-                    'in downloaded zipfile' % OPENBLAS_LONG
-        if get_ilp64() is None:
-            target = os.path.join(gettempdir(), 'openblas.a')
-        else:
-            target = os.path.join(gettempdir(), 'openblas64_.a')
-        with open(target, 'wb') as fid:
-            fid.write(zf.read(lib[0]))
+        zf.extractall(unzip_base)
+    if plat == "win-32":
+        target = os.path.join(unzip_base, "32")
+    else:
+        target = os.path.join(unzip_base, "64")
+    # Copy the lib to openblas.lib. Once we can properly use pkg-config
+    # this will not be needed
+    lib = glob.glob(os.path.join(target, 'lib', '*.lib'))
+    assert len(lib) == 1
+    for f in lib:
+        shutil.copy(f, os.path.join(target, 'lib', 'openblas.lib'))
+        shutil.copy(f, os.path.join(target, 'lib', 'openblas64_.lib'))
+    # Copy the dll from bin to lib so system_info can pick it up
+    dll = glob.glob(os.path.join(target, 'bin', '*.dll'))
+    for f in dll:
+        shutil.copy(f, os.path.join(target, 'lib'))
     return target
 
 
@@ -235,7 +238,8 @@ def make_init(dirname):
 
 def test_setup(plats):
     '''
-    Make sure all the downloadable files exist and can be opened
+    Make sure all the downloadable files needed for wheel building
+    exist and can be opened
     '''
     def items():
         """ yields all combinations of arch, ilp64
@@ -243,19 +247,8 @@ def items():
         for plat in plats:
             yield plat, None
             osname, arch = plat.split("-")
-            if arch not in ('i686', 'arm64', '32'):
+            if arch not in ('i686', '32'):
                 yield plat, '64_'
-            if osname == "linux" and arch in ('i686', 'x86_64'):
-                oldval = os.environ.get('MB_ML_VER', None)
-                os.environ['MB_ML_VER'] = '1'
-                yield plat, None
-                # Once we create x86_64 and i686 manylinux2014 wheels...
-                # os.environ['MB_ML_VER'] = '2014'
-                # yield arch, None, False
-                if oldval:
-                    os.environ['MB_ML_VER'] = oldval
-                else:
-                    os.environ.pop('MB_ML_VER')
 
     errs = []
     for plat, ilp64 in items():
@@ -273,7 +266,7 @@ def items():
                 continue
             if not target:
                 raise RuntimeError(f'Could not setup {plat}')
-            print(target)
+            print('success with', plat, ilp64)
             if osname == 'win':
                 if not target.endswith('.a'):
                     raise RuntimeError("Not .a extracted!")
@@ -291,32 +284,24 @@ def items():
         raise errs[0]
 
 
-def test_version(expected_version, ilp64=get_ilp64()):
+def test_version(expected_version=None):
     """
     Assert that expected OpenBLAS version is
-    actually available via NumPy
+    actually available via NumPy. Requires threadpoolctl
     """
     import numpy
-    import ctypes
+    import threadpoolctl
 
-    dll = ctypes.CDLL(numpy.core._multiarray_umath.__file__)
-    if ilp64 == "64_":
-        get_config = dll.openblas_get_config64_
-    else:
-        get_config = dll.openblas_get_config
-    get_config.restype = ctypes.c_char_p
-    res = get_config()
-    print('OpenBLAS get_config returned', str(res))
+    data = threadpoolctl.threadpool_info()
+    if len(data) != 1:
+        raise ValueError(f"expected single threadpool_info result, got {data}")
     if not expected_version:
         expected_version = OPENBLAS_V
-    check_str = b'OpenBLAS %s' % expected_version.encode()
-    print(check_str)
-    assert check_str in res, f'{expected_version} not found in {res}'
-    if ilp64:
-        assert b"USE64BITINT" in res
-    else:
-        assert b"USE64BITINT" not in res
-
+    if data[0]['version'] != expected_version:
+        raise ValueError(
+            f"expected OpenBLAS version {expected_version}, got {data}"
+        )
+    print("OK")
 
 if __name__ == '__main__':
     import argparse
diff --git a/tools/pypy-test.sh b/tools/pypy-test.sh
deleted file mode 100755
index e6c6ae719c91..000000000000
--- a/tools/pypy-test.sh
+++ /dev/null
@@ -1,49 +0,0 @@
-#!/usr/bin/env bash
-
-# Exit if a command fails
-set -e
-set -o pipefail
-# Print expanded commands
-set -x
-
-sudo apt-get -yq update
-sudo apt-get -yq install gfortran-5
-export F77=gfortran-5
-export F90=gfortran-5
-
-# Download the proper OpenBLAS x64 precompiled library
-target=$(python3 tools/openblas_support.py)
-ls -lR "$target"
-echo getting OpenBLAS into $target
-export LD_LIBRARY_PATH=$target/lib
-export LIB=$target/lib
-export INCLUDE=$target/include
-
-# Use a site.cfg to build with local openblas
-cat << EOF > site.cfg
-[openblas]
-libraries = openblas
-library_dirs = $target/lib:$LIB
-include_dirs = $target/lib:$LIB
-runtime_library_dirs = $target/lib
-EOF
-
-echo getting PyPy 3.6-v7.3.2
-wget -q https://downloads.python.org/pypy/pypy3.6-v7.3.2-linux64.tar.bz2 -O pypy.tar.bz2
-mkdir -p pypy3
-(cd pypy3; tar --strip-components=1 -xf ../pypy.tar.bz2)
-pypy3/bin/pypy3 -mensurepip
-pypy3/bin/pypy3 -m pip install --upgrade pip
-pypy3/bin/pypy3 -m pip install --user -r test_requirements.txt --no-warn-script-location
-
-echo
-echo pypy3 version
-pypy3/bin/pypy3 -c "import sys; print(sys.version)"
-echo
-
-pypy3/bin/pypy3 runtests.py --debug-info --show-build-log -v -- -rsx \
-      --junitxml=junit/test-results.xml --durations 10
-
-echo Make sure the correct openblas has been linked in
-pypy3/bin/pypy3 -mpip install --no-build-isolation .
-pypy3/bin/pypy3 tools/openblas_support.py --check_version
diff --git a/tools/refguide_check.py b/tools/refguide_check.py
index 21ba5a448dcc..1d230b385e7c 100644
--- a/tools/refguide_check.py
+++ b/tools/refguide_check.py
@@ -42,7 +42,6 @@
 from doctest import NORMALIZE_WHITESPACE, ELLIPSIS, IGNORE_EXCEPTION_DETAIL
 
 from docutils.parsers.rst import directives
-from pkg_resources import parse_version
 
 import sphinx
 import numpy as np
@@ -52,20 +51,10 @@
 
 SKIPBLOCK = doctest.register_optionflag('SKIPBLOCK')
 
-if parse_version(sphinx.__version__) >= parse_version('1.5'):
-    # Enable specific Sphinx directives
-    from sphinx.directives.other import SeeAlso, Only
-    directives.register_directive('seealso', SeeAlso)
-    directives.register_directive('only', Only)
-else:
-    # Remove sphinx directives that don't run without Sphinx environment.
-    # Sphinx < 1.5 installs all directives on import...
-    directives._directives.pop('versionadded', None)
-    directives._directives.pop('versionchanged', None)
-    directives._directives.pop('moduleauthor', None)
-    directives._directives.pop('sectionauthor', None)
-    directives._directives.pop('codeauthor', None)
-    directives._directives.pop('toctree', None)
+# Enable specific Sphinx directives
+from sphinx.directives.other import SeeAlso, Only
+directives.register_directive('seealso', SeeAlso)
+directives.register_directive('only', Only)
 
 
 BASE_MODULE = "numpy"
@@ -104,6 +93,8 @@
     'numpy.random.vonmises': None,
     'numpy.random.power': None,
     'numpy.random.zipf': None,
+    # cases where NumPy docstrings import things from other 3'rd party libs:
+    'numpy.core.from_dlpack': None,
     # remote / local file IO with DataSource is problematic in doctest:
     'numpy.lib.DataSource': None,
     'numpy.lib.Repository': None,
@@ -131,14 +122,15 @@
     'c-info.ufunc-tutorial.rst',
     'c-info.python-as-glue.rst',
     'f2py.getting-started.rst',
+    'f2py-examples.rst',
     'arrays.nditer.cython.rst',
+    'how-to-verify-bug.rst',
     # See PR 17222, these should be fixed
-    'basics.byteswapping.rst',
     'basics.dispatch.rst',
-    'basics.indexing.rst',
     'basics.subclassing.rst',
-    'basics.types.rst',
+    'basics.interoperability.rst',
     'misc.rst',
+    'TESTS.rst'
 ]
 
 # these names are not required to be present in ALL despite being in
@@ -1167,7 +1159,12 @@ def main(argv):
         init_matplotlib()
 
     for submodule_name in module_names:
-        module_name = BASE_MODULE + '.' + submodule_name
+        prefix = BASE_MODULE + '.'
+        if not submodule_name.startswith(prefix):
+            module_name = prefix + submodule_name
+        else:
+            module_name = submodule_name
+
         __import__(module_name)
         module = sys.modules[module_name]
 
diff --git a/tools/swig/README b/tools/swig/README
index 7fa0599c6b4f..c539c597f8c6 100644
--- a/tools/swig/README
+++ b/tools/swig/README
@@ -15,7 +15,7 @@ system used here, can be found in the NumPy reference guide.
 Testing
 -------
 The tests are a good example of what we are trying to do with numpy.i.
-The files related to testing are are in the test subdirectory::
+The files related to testing are in the test subdirectory::
 
     Vector.h
     Vector.cxx
diff --git a/tools/swig/numpy.i b/tools/swig/numpy.i
index 99ed073abe11..c8c26cbcd3d6 100644
--- a/tools/swig/numpy.i
+++ b/tools/swig/numpy.i
@@ -48,7 +48,7 @@
 
 %fragment("NumPy_Backward_Compatibility", "header")
 {
-%#if NPY_API_VERSION < 0x00000007
+%#if NPY_API_VERSION < NPY_1_7_API_VERSION
 %#define NPY_ARRAY_DEFAULT NPY_DEFAULT
 %#define NPY_ARRAY_FARRAY  NPY_FARRAY
 %#define NPY_FORTRANORDER  NPY_FORTRAN
@@ -69,7 +69,7 @@
 {
 /* Macros to extract array attributes.
  */
-%#if NPY_API_VERSION < 0x00000007
+%#if NPY_API_VERSION < NPY_1_7_API_VERSION
 %#define is_array(a)            ((a) && PyArray_Check((PyArrayObject*)a))
 %#define array_type(a)          (int)(PyArray_TYPE((PyArrayObject*)a))
 %#define array_numdims(a)       (((PyArrayObject*)a)->nd)
@@ -165,13 +165,11 @@
     return PyArray_EquivTypenums(actual_type, desired_type);
   }
 
-%#ifdef SWIGPY_USE_CAPSULE
-  void free_cap(PyObject * cap)
+void free_cap(PyObject * cap)
   {
     void* array = (void*) PyCapsule_GetPointer(cap,SWIGPY_CAPSULE_NAME);
     if (array != NULL) free(array);
   }
-%#endif
 
 
 }
@@ -293,7 +291,7 @@
       Py_INCREF(array_descr(ary));
       result = (PyArrayObject*) PyArray_FromArray(ary,
                                                   array_descr(ary),
-%#if NPY_API_VERSION < 0x00000007
+%#if NPY_API_VERSION < NPY_1_7_API_VERSION
                                                   NPY_FORTRANORDER);
 %#else
                                                   NPY_ARRAY_F_CONTIGUOUS);
@@ -524,7 +522,7 @@
     return success;
   }
 
-  /* Require the given PyArrayObject to to be Fortran ordered.  If the
+  /* Require the given PyArrayObject to be Fortran ordered.  If the
    * the PyArrayObject is already Fortran ordered, do nothing.  Else,
    * set the Fortran ordering flag and recompute the strides.
    */
@@ -2459,13 +2457,9 @@
 
   if (!array) SWIG_fail;
 
-%#ifdef SWIGPY_USE_CAPSULE
-    PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap);
-%#else
-    PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free);
-%#endif
+PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap);
 
-%#if NPY_API_VERSION < 0x00000007
+%#if NPY_API_VERSION < NPY_1_7_API_VERSION
   PyArray_BASE(array) = cap;
 %#else
   PyArray_SetBaseObject(array,cap);
@@ -2493,13 +2487,9 @@
 
   if (!array) SWIG_fail;
 
-%#ifdef SWIGPY_USE_CAPSULE
-    PyObject* cap = PyCapsule_New((void*)(*$2), SWIGPY_CAPSULE_NAME, free_cap);
-%#else
-    PyObject* cap = PyCObject_FromVoidPtr((void*)(*$2), free);
-%#endif
+PyObject* cap = PyCapsule_New((void*)(*$2), SWIGPY_CAPSULE_NAME, free_cap);
 
-%#if NPY_API_VERSION < 0x00000007
+%#if NPY_API_VERSION < NPY_1_7_API_VERSION
   PyArray_BASE(array) = cap;
 %#else
   PyArray_SetBaseObject(array,cap);
@@ -2528,13 +2518,9 @@
 
   if (!array) SWIG_fail;
 
-%#ifdef SWIGPY_USE_CAPSULE
-    PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap);
-%#else
-    PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free);
-%#endif
+PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap);
 
-%#if NPY_API_VERSION < 0x00000007
+%#if NPY_API_VERSION < NPY_1_7_API_VERSION
   PyArray_BASE(array) = cap;
 %#else
   PyArray_SetBaseObject(array,cap);
@@ -2563,13 +2549,9 @@
 
   if (!array) SWIG_fail;
 
-%#ifdef SWIGPY_USE_CAPSULE
-    PyObject* cap = PyCapsule_New((void*)(*$3), SWIGPY_CAPSULE_NAME, free_cap);
-%#else
-    PyObject* cap = PyCObject_FromVoidPtr((void*)(*$3), free);
-%#endif
+PyObject* cap = PyCapsule_New((void*)(*$3), SWIGPY_CAPSULE_NAME, free_cap);
 
-%#if NPY_API_VERSION < 0x00000007
+%#if NPY_API_VERSION < NPY_1_7_API_VERSION
   PyArray_BASE(array) = cap;
 %#else
   PyArray_SetBaseObject(array,cap);
@@ -2598,13 +2580,9 @@
 
   if (!array || !require_fortran(array)) SWIG_fail;
 
-%#ifdef SWIGPY_USE_CAPSULE
-    PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap);
-%#else
-    PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free);
-%#endif
+PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap);
 
-%#if NPY_API_VERSION < 0x00000007
+%#if NPY_API_VERSION < NPY_1_7_API_VERSION
   PyArray_BASE(array) = cap;
 %#else
   PyArray_SetBaseObject(array,cap);
@@ -2633,13 +2611,9 @@
 
   if (!array || !require_fortran(array)) SWIG_fail;
 
-%#ifdef SWIGPY_USE_CAPSULE
-    PyObject* cap = PyCapsule_New((void*)(*$3), SWIGPY_CAPSULE_NAME, free_cap);
-%#else
-    PyObject* cap = PyCObject_FromVoidPtr((void*)(*$3), free);
-%#endif
+PyObject* cap = PyCapsule_New((void*)(*$3), SWIGPY_CAPSULE_NAME, free_cap);
 
-%#if NPY_API_VERSION < 0x00000007
+%#if NPY_API_VERSION < NPY_1_7_API_VERSION
   PyArray_BASE(array) = cap;
 %#else
   PyArray_SetBaseObject(array,cap);
@@ -2670,13 +2644,9 @@
 
   if (!array) SWIG_fail;
 
-%#ifdef SWIGPY_USE_CAPSULE
-    PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap);
-%#else
-    PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free);
-%#endif
+PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap);
 
-%#if NPY_API_VERSION < 0x00000007
+%#if NPY_API_VERSION < NPY_1_7_API_VERSION
   PyArray_BASE(array) = cap;
 %#else
   PyArray_SetBaseObject(array,cap);
@@ -2707,13 +2677,9 @@
 
   if (!array) SWIG_fail;
 
-%#ifdef SWIGPY_USE_CAPSULE
-    PyObject* cap = PyCapsule_New((void*)(*$4), SWIGPY_CAPSULE_NAME, free_cap);
-%#else
-    PyObject* cap = PyCObject_FromVoidPtr((void*)(*$4), free);
-%#endif
+PyObject* cap = PyCapsule_New((void*)(*$4), SWIGPY_CAPSULE_NAME, free_cap);
 
-%#if NPY_API_VERSION < 0x00000007
+%#if NPY_API_VERSION < NPY_1_7_API_VERSION
   PyArray_BASE(array) = cap;
 %#else
   PyArray_SetBaseObject(array,cap);
@@ -2744,13 +2710,9 @@
 
   if (!array || !require_fortran(array)) SWIG_fail;
 
-%#ifdef SWIGPY_USE_CAPSULE
-    PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap);
-%#else
-    PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free);
-%#endif
+PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap);
 
-%#if NPY_API_VERSION < 0x00000007
+%#if NPY_API_VERSION < NPY_1_7_API_VERSION
   PyArray_BASE(array) = cap;
 %#else
   PyArray_SetBaseObject(array,cap);
@@ -2781,13 +2743,9 @@
 
   if (!array || !require_fortran(array)) SWIG_fail;
 
-%#ifdef SWIGPY_USE_CAPSULE
-    PyObject* cap = PyCapsule_New((void*)(*$4), SWIGPY_CAPSULE_NAME, free_cap);
-%#else
-    PyObject* cap = PyCObject_FromVoidPtr((void*)(*$4), free);
-%#endif
+PyObject* cap = PyCapsule_New((void*)(*$4), SWIGPY_CAPSULE_NAME, free_cap);
 
-%#if NPY_API_VERSION < 0x00000007
+%#if NPY_API_VERSION < NPY_1_7_API_VERSION
   PyArray_BASE(array) = cap;
 %#else
   PyArray_SetBaseObject(array,cap);
@@ -2819,13 +2777,9 @@
 
   if (!array) SWIG_fail;
 
-%#ifdef SWIGPY_USE_CAPSULE
-    PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap);
-%#else
-    PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free);
-%#endif
+PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap);
 
-%#if NPY_API_VERSION < 0x00000007
+%#if NPY_API_VERSION < NPY_1_7_API_VERSION
   PyArray_BASE(array) = cap;
 %#else
   PyArray_SetBaseObject(array,cap);
@@ -2857,13 +2811,9 @@
 
   if (!array) SWIG_fail;
 
-%#ifdef SWIGPY_USE_CAPSULE
-    PyObject* cap = PyCapsule_New((void*)(*$5), SWIGPY_CAPSULE_NAME, free_cap);
-%#else
-    PyObject* cap = PyCObject_FromVoidPtr((void*)(*$5), free);
-%#endif
+PyObject* cap = PyCapsule_New((void*)(*$5), SWIGPY_CAPSULE_NAME, free_cap);
 
-%#if NPY_API_VERSION < 0x00000007
+%#if NPY_API_VERSION < NPY_1_7_API_VERSION
   PyArray_BASE(array) = cap;
 %#else
   PyArray_SetBaseObject(array,cap);
@@ -2895,13 +2845,9 @@
 
   if (!array || !require_fortran(array)) SWIG_fail;
 
-%#ifdef SWIGPY_USE_CAPSULE
-    PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap);
-%#else
-    PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free);
-%#endif
+PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap);
 
-%#if NPY_API_VERSION < 0x00000007
+%#if NPY_API_VERSION < NPY_1_7_API_VERSION
   PyArray_BASE(array) = cap;
 %#else
   PyArray_SetBaseObject(array,cap);
@@ -2933,13 +2879,9 @@
 
   if (!array || !require_fortran(array)) SWIG_fail;
 
-%#ifdef SWIGPY_USE_CAPSULE
-    PyObject* cap = PyCapsule_New((void*)(*$5), SWIGPY_CAPSULE_NAME, free_cap);
-%#else
-    PyObject* cap = PyCObject_FromVoidPtr((void*)(*$5), free);
-%#endif
+PyObject* cap = PyCapsule_New((void*)(*$5), SWIGPY_CAPSULE_NAME, free_cap);
 
-%#if NPY_API_VERSION < 0x00000007
+%#if NPY_API_VERSION < NPY_1_7_API_VERSION
   PyArray_BASE(array) = cap;
 %#else
   PyArray_SetBaseObject(array,cap);
diff --git a/tools/swig/pyfragments.swg b/tools/swig/pyfragments.swg
index 558633733da3..eac817322242 100644
--- a/tools/swig/pyfragments.swg
+++ b/tools/swig/pyfragments.swg
@@ -52,7 +52,7 @@
     }
 %#endif
     if (!PyArray_IsScalar(obj,Integer)) return SWIG_TypeError;
-    PyArray_Descr * longDescr = PyArray_DescrNewFromType(NPY_LONG);
+    PyArray_Descr * longDescr = PyArray_DescrFromType(NPY_LONG);
     PyArray_CastScalarToCtype(obj, (void*)val, longDescr);
     Py_DECREF(longDescr);
     return SWIG_OK;
@@ -102,7 +102,7 @@
     }
 %#endif
     if (!PyArray_IsScalar(obj,Integer)) return SWIG_TypeError;
-    PyArray_Descr * ulongDescr = PyArray_DescrNewFromType(NPY_ULONG);
+    PyArray_Descr * ulongDescr = PyArray_DescrFromType(NPY_ULONG);
     PyArray_CastScalarToCtype(obj, (void*)val, ulongDescr);
     Py_DECREF(ulongDescr);
     return SWIG_OK;
diff --git a/tools/travis-test.sh b/tools/travis-test.sh
index b395942fba8a..6216c239baf4 100755
--- a/tools/travis-test.sh
+++ b/tools/travis-test.sh
@@ -36,20 +36,23 @@ setup_base()
   sysflags="$($PYTHON -c "from distutils import sysconfig; \
     print (sysconfig.get_config_var('CFLAGS'))")"
   export CFLAGS="$sysflags $werrors -Wlogical-op -Wno-sign-compare"
-  # SIMD extensions that need to be tested on both runtime and compile-time via (test_simd.py)
-  # any specified features will be ignored if they're not supported by compiler or platform
-  # note: it almost the same default value of --simd-test execpt adding policy `$werror` to treat all
-  # warnings as errors
-  simd_test="\$werror BASELINE SSE2 SSE42 XOP FMA4 (FMA3 AVX2) AVX512F AVX512_SKX VSX VSX2 VSX3 NEON ASIMD"
-  # We used to use 'setup.py install' here, but that has the terrible
-  # behaviour that if a copy of the package is already installed in the
-  # install location, then the new copy just gets dropped on top of it.
-  # Travis typically has a stable numpy release pre-installed, and if we
-  # don't remove it, then we can accidentally end up e.g. running old
-  # test modules that were in the stable release but have been removed
-  # from main. (See gh-2765, gh-2768.)  Using 'pip install' also has
-  # the advantage that it tests that numpy is 'pip install' compatible,
-  # see e.g. gh-2766...
+
+  build_args=()
+  # Strictly disable all kinds of optimizations
+  if [ -n "$WITHOUT_OPTIMIZATIONS" ]; then
+      build_args+=("--disable-optimization")
+  # only disable SIMD optimizations
+  elif [ -n "$WITHOUT_SIMD" ]; then
+      build_args+=("--cpu-baseline=none" "--cpu-dispatch=none")
+  elif [ -n "$CPU_DISPATCH" ]; then
+      build_args+=("--cpu-dispatch=$CPU_DISPATCH")
+  else
+    # SIMD extensions that need to be tested on both runtime and compile-time via (test_simd.py)
+    # any specified features will be ignored if they're not supported by compiler or platform
+    # note: it almost the same default value of --simd-test execpt adding policy `$werror` to treat all
+    # warnings as errors
+    build_args+=("--simd-test=\$werror BASELINE SSE2 SSE42 XOP FMA4 (FMA3 AVX2) AVX512F AVX512_SKX VSX VSX2 VSX3 NEON ASIMD VX VXE VXE2")
+  fi
   if [ -z "$USE_DEBUG" ]; then
     # activates '-Werror=undef' when DEBUG isn't enabled since _cffi_backend'
     # extension breaks the build due to the following error:
@@ -58,11 +61,11 @@ setup_base()
     # #if !HAVE_FFI_PREP_CIF_VAR && defined(__arm64__) && defined(__APPLE__)
     #
     export CFLAGS="$CFLAGS -Werror=undef"
-    $PYTHON setup.py build --simd-test "$simd_test" install 2>&1 | tee log
+    $PYTHON setup.py build "${build_args[@]}" install 2>&1 | tee log
   else
     # The job run with USE_DEBUG=1 on travis needs this.
     export CFLAGS=$CFLAGS" -Wno-maybe-uninitialized"
-    $PYTHON setup.py build --simd-test "$simd_test" build_src --verbose-cfg build_ext --inplace 2>&1 | tee log
+    $PYTHON setup.py build "${build_args[@]}" build_src --verbose-cfg build_ext --inplace 2>&1 | tee log
   fi
   grep -v "_configtest" log \
     | grep -vE "ld returned 1|no files found matching" \
@@ -83,7 +86,7 @@ run_test()
   # in test_requirements.txt) does not provide a wheel, and the source tar
   # file does not install correctly when Python's optimization level is set
   # to strip docstrings (see https://github.com/eliben/pycparser/issues/291).
-  PYTHONOPTIMIZE="" $PIP install -r test_requirements.txt
+  PYTHONOPTIMIZE="" $PIP install -r test_requirements.txt pyinstaller
   DURATIONS_FLAG="--durations 10"
 
   if [ -n "$USE_DEBUG" ]; then
@@ -103,15 +106,54 @@ run_test()
     "import os; import numpy; print(os.path.dirname(numpy.__file__))")
   export PYTHONWARNINGS=default
 
+  # This guard protects against any sudden unexpected changes that may adversely
+  # affect the compile-time SIMD features detection which could leave the SIMD code
+  # inactivated. Until now we have faced two cases:
+  #
+  # 1. Hardening the compile-time test files of Neon/ASIMD features without checking
+  # the sanity of the modification leading to disabling all optimizations on aarch64.
+  # see gh-21747
+  #
+  # 2. A sudden compiler upgrades by CI side on s390x that causes conflicts with the
+  # installed assembler leading to disabling the whole VX/E features, which made us
+  # merge SIMD code without testing it. Later, it was discovered that this code
+  # disrupted the NumPy build.
+  # see gh-21750, gh-21748
+  if [ -n "$EXPECT_CPU_FEATURES" ]; then
+    as_expected=$($PYTHON << EOF
+from numpy.core._multiarray_umath import (__cpu_baseline__, __cpu_dispatch__)
+features = __cpu_baseline__ + __cpu_dispatch__
+expected = '$EXPECT_CPU_FEATURES'.upper().split()
+diff = set(expected).difference(set(features))
+if diff:
+    print("Unexpected compile-time CPU features detection!\n"
+          f"The current build is missing the support of CPU features '{diff}':\n"
+          "This error is triggered because of one of the following reasons:\n\n"
+          f"1. The compiler for somehow no longer supports any of these CPU features {diff}\n"
+          f"Note that the current build reports the support of the following features:\n{features}\n\n"
+          "2. Your code messed up the testing process! please check the build log and trace\n"
+          "compile-time feature tests and make sure that your patch has nothing to do with the tests failures."
+          )
+EOF
+)
+    if [ -n "$as_expected" ]; then
+      echo "$as_expected"
+      exit 1
+    fi
+  fi
+
   if [ -n "$CHECK_BLAS" ]; then
+    $PYTHON -m pip install threadpoolctl
     $PYTHON ../tools/openblas_support.py --check_version
   fi
 
   if [ -n "$RUN_FULL_TESTS" ]; then
+    # Travis has a limit on log length that is causeing test failutes.
+    # The fix here is to remove the "-v" from the runtest arguments.
     export PYTHONWARNINGS="ignore::DeprecationWarning:virtualenv"
-    $PYTHON -b ../runtests.py -n -v --mode=full $DURATIONS_FLAG $COVERAGE_FLAG
+    $PYTHON -b ../runtests.py -n --mode=full $DURATIONS_FLAG $COVERAGE_FLAG
   else
-    $PYTHON ../runtests.py -n -v $DURATIONS_FLAG -- -rs
+    $PYTHON ../runtests.py -n $DURATIONS_FLAG -- -rs
   fi
 
   if [ -n "$RUN_COVERAGE" ]; then
@@ -139,7 +181,7 @@ run_test()
     pushd ../benchmarks
     $PYTHON `which asv` check --python=same
     $PYTHON `which asv` machine --machine travis
-    $PYTHON `which asv` dev 2>&1| tee asv-output.log
+    $PYTHON `which asv` dev -q 2>&1| tee asv-output.log
     if grep -q Traceback asv-output.log; then
       echo "Some benchmarks have errors!"
       exit 1
diff --git a/tools/wheels/LICENSE_win32.txt b/tools/wheels/LICENSE_win32.txt
new file mode 100644
index 000000000000..1014d77cd3ed
--- /dev/null
+++ b/tools/wheels/LICENSE_win32.txt
@@ -0,0 +1,938 @@
+
+----
+
+This binary distribution of NumPy also bundles the following software:
+
+
+Name: OpenBLAS
+Files: extra-dll\libopenb*.dll
+Description: bundled as a dynamically linked library
+Availability: https://github.com/xianyi/OpenBLAS/
+License: 3-clause BSD
+  Copyright (c) 2011-2014, The OpenBLAS Project
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are
+  met:
+
+     1. Redistributions of source code must retain the above copyright
+        notice, this list of conditions and the following disclaimer.
+
+     2. 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.
+     3. Neither the name of the OpenBLAS project nor the names of
+        its 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.
+
+
+Name: LAPACK
+Files: extra-dll\libopenb*.dll
+Description: bundled in OpenBLAS
+Availability: https://github.com/xianyi/OpenBLAS/
+License 3-clause BSD
+  Copyright (c) 1992-2013 The University of Tennessee and The University
+                          of Tennessee Research Foundation.  All rights
+                          reserved.
+  Copyright (c) 2000-2013 The University of California Berkeley. All
+                          rights reserved.
+  Copyright (c) 2006-2013 The University of Colorado Denver.  All rights
+                          reserved.
+
+  $COPYRIGHT$
+
+  Additional copyrights may follow
+
+  $HEADER$
+
+  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 listed
+    in this license in the documentation and/or other materials
+    provided with the distribution.
+
+  - Neither the name of the copyright holders nor the names of its
+    contributors may be used to endorse or promote products derived from
+    this software without specific prior written permission.
+
+  The copyright holders provide no reassurances that the source code
+  provided does not infringe any patent, copyright, or any other
+  intellectual property rights of third parties.  The copyright holders
+  disclaim any liability to any recipient for claims brought against
+  recipient by any third party for infringement of that parties
+  intellectual property rights.
+
+  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.
+
+
+Name: GCC runtime library
+Files: extra-dll\*.dll
+Description: statically linked, in DLL files compiled with gfortran only
+Availability: https://gcc.gnu.org/viewcvs/gcc/
+License: GPLv3 + runtime exception
+  Copyright (C) 2002-2017 Free Software Foundation, Inc.
+
+  Libgfortran is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 3, or (at your option)
+  any later version.
+
+  Libgfortran is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  Under Section 7 of GPL version 3, you are granted additional
+  permissions described in the GCC Runtime Library Exception, version
+  3.1, as published by the Free Software Foundation.
+
+  You should have received a copy of the GNU General Public License and
+  a copy of the GCC Runtime Library Exception along with this program;
+  see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+  .
+
+
+Name: Microsoft Visual C++ Runtime Files
+Files: extra-dll\msvcp140.dll
+License: MSVC
+  https://www.visualstudio.com/license-terms/distributable-code-microsoft-visual-studio-2015-rc-microsoft-visual-studio-2015-sdk-rc-includes-utilities-buildserver-files/#visual-c-runtime
+
+  Subject to the License Terms for the software, you may copy and
+  distribute with your program any of the files within the followng
+  folder and its subfolders except as noted below. You may not modify
+  these files.
+
+    C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\redist
+
+  You may not distribute the contents of the following folders:
+
+    C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\redist\debug_nonredist
+    C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\redist\onecore\debug_nonredist
+
+  Subject to the License Terms for the software, you may copy and
+  distribute the following files with your program in your program’s
+  application local folder or by deploying them into the Global
+  Assembly Cache (GAC):
+
+  VC\atlmfc\lib\mfcmifc80.dll
+  VC\atlmfc\lib\amd64\mfcmifc80.dll
+
+
+Name: Microsoft Visual C++ Runtime Files
+Files: extra-dll\msvc*90.dll, extra-dll\Microsoft.VC90.CRT.manifest
+License: MSVC
+  For your convenience, we have provided the following folders for
+  use when redistributing VC++ runtime files. Subject to the license
+  terms for the software, you may redistribute the folder
+  (unmodified) in the application local folder as a sub-folder with
+  no change to the folder name. You may also redistribute all the
+  files (*.dll and *.manifest) within a folder, listed below the
+  folder for your convenience, as an entire set.
+
+  \VC\redist\x86\Microsoft.VC90.ATL\
+   atl90.dll
+   Microsoft.VC90.ATL.manifest
+  \VC\redist\ia64\Microsoft.VC90.ATL\
+   atl90.dll
+   Microsoft.VC90.ATL.manifest
+  \VC\redist\amd64\Microsoft.VC90.ATL\
+   atl90.dll
+   Microsoft.VC90.ATL.manifest
+  \VC\redist\x86\Microsoft.VC90.CRT\
+   msvcm90.dll
+   msvcp90.dll
+   msvcr90.dll
+   Microsoft.VC90.CRT.manifest
+  \VC\redist\ia64\Microsoft.VC90.CRT\
+   msvcm90.dll
+   msvcp90.dll
+   msvcr90.dll
+   Microsoft.VC90.CRT.manifest
+
+----
+
+Full text of license texts referred to above follows (that they are
+listed below does not necessarily imply the conditions apply to the
+present binary release):
+
+----
+
+GCC RUNTIME LIBRARY EXCEPTION
+
+Version 3.1, 31 March 2009
+
+Copyright (C) 2009 Free Software Foundation, Inc. 
+
+Everyone is permitted to copy and distribute verbatim copies of this
+license document, but changing it is not allowed.
+
+This GCC Runtime Library Exception ("Exception") is an additional
+permission under section 7 of the GNU General Public License, version
+3 ("GPLv3"). It applies to a given file (the "Runtime Library") that
+bears a notice placed by the copyright holder of the file stating that
+the file is governed by GPLv3 along with this Exception.
+
+When you use GCC to compile a program, GCC may combine portions of
+certain GCC header files and runtime libraries with the compiled
+program. The purpose of this Exception is to allow compilation of
+non-GPL (including proprietary) programs to use, in this way, the
+header files and runtime libraries covered by this Exception.
+
+0. Definitions.
+
+A file is an "Independent Module" if it either requires the Runtime
+Library for execution after a Compilation Process, or makes use of an
+interface provided by the Runtime Library, but is not otherwise based
+on the Runtime Library.
+
+"GCC" means a version of the GNU Compiler Collection, with or without
+modifications, governed by version 3 (or a specified later version) of
+the GNU General Public License (GPL) with the option of using any
+subsequent versions published by the FSF.
+
+"GPL-compatible Software" is software whose conditions of propagation,
+modification and use would permit combination with GCC in accord with
+the license of GCC.
+
+"Target Code" refers to output from any compiler for a real or virtual
+target processor architecture, in executable form or suitable for
+input to an assembler, loader, linker and/or execution
+phase. Notwithstanding that, Target Code does not include data in any
+format that is used as a compiler intermediate representation, or used
+for producing a compiler intermediate representation.
+
+The "Compilation Process" transforms code entirely represented in
+non-intermediate languages designed for human-written code, and/or in
+Java Virtual Machine byte code, into Target Code. Thus, for example,
+use of source code generators and preprocessors need not be considered
+part of the Compilation Process, since the Compilation Process can be
+understood as starting with the output of the generators or
+preprocessors.
+
+A Compilation Process is "Eligible" if it is done using GCC, alone or
+with other GPL-compatible software, or if it is done without using any
+work based on GCC. For example, using non-GPL-compatible Software to
+optimize any GCC intermediate representations would not qualify as an
+Eligible Compilation Process.
+
+1. Grant of Additional Permission.
+
+You have permission to propagate a work of Target Code formed by
+combining the Runtime Library with Independent Modules, even if such
+propagation would otherwise violate the terms of GPLv3, provided that
+all Target Code was generated by Eligible Compilation Processes. You
+may then convey such a combination under terms of your choice,
+consistent with the licensing of the Independent Modules.
+
+2. No Weakening of GCC Copyleft.
+
+The availability of this Exception does not imply any general
+presumption that third-party software is unaffected by the copyleft
+requirements of the license of GCC.
+
+----
+
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. 
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    
+    Copyright (C)   
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see .
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+      Copyright (C)   
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+.
\ No newline at end of file
diff --git a/tools/wheels/cibw_before_build.sh b/tools/wheels/cibw_before_build.sh
index 36410ba1fa34..9eebce4342f4 100644
--- a/tools/wheels/cibw_before_build.sh
+++ b/tools/wheels/cibw_before_build.sh
@@ -1,37 +1,46 @@
 set -xe
 
 PROJECT_DIR="$1"
-UNAME="$(uname)"
+PLATFORM=$(PYTHONPATH=tools python -c "import openblas_support; print(openblas_support.get_plat())")
 
 # Update license
-if [[ $UNAME == "Linux" ]] ; then
+if [[ $RUNNER_OS == "Linux" ]] ; then
     cat $PROJECT_DIR/tools/wheels/LICENSE_linux.txt >> $PROJECT_DIR/LICENSE.txt
-elif [[ $UNAME == "Darwin" ]]; then
+elif [[ $RUNNER_OS == "macOS" ]]; then
     cat $PROJECT_DIR/tools/wheels/LICENSE_osx.txt >> $PROJECT_DIR/LICENSE.txt
+elif [[ $RUNNER_OS == "Windows" ]]; then
+    cat $PROJECT_DIR/tools/wheels/LICENSE_win32.txt >> $PROJECT_DIR/LICENSE.txt
 fi
 
 # Install Openblas
-if [[ $UNAME == "Linux" || $UNAME == "Darwin" ]] ; then
+if [[ $RUNNER_OS == "Linux" || $RUNNER_OS == "macOS" ]] ; then
     basedir=$(python tools/openblas_support.py)
     cp -r $basedir/lib/* /usr/local/lib
     cp $basedir/include/* /usr/local/include
+    if [[ $RUNNER_OS == "macOS" && $PLATFORM == "macosx-arm64" ]]; then
+        sudo mkdir -p /opt/arm64-builds/lib /opt/arm64-builds/include
+        sudo chown -R $USER /opt/arm64-builds
+        cp -r $basedir/lib/* /opt/arm64-builds/lib
+        cp $basedir/include/* /opt/arm64-builds/include
+    fi
+elif [[ $RUNNER_OS == "Windows" ]]; then
+    PYTHONPATH=tools python -c "import openblas_support; openblas_support.make_init('numpy')"
+    target=$(python tools/openblas_support.py)
+    ls /tmp
+    mkdir -p openblas
+    # bash on windows does not like cp -r $target/* openblas
+    for f in $(ls $target); do
+        cp -r $target/$f openblas
+    done
+    ls openblas
 fi
 
-# Install GFortran
-if [[ $UNAME == "Darwin" ]]; then
-    # same version of gfortran as the openblas-libs and numpy-wheel builds
-    curl -L https://github.com/MacPython/gfortran-install/raw/master/archives/gfortran-4.9.0-Mavericks.dmg -o gfortran.dmg
-    GFORTRAN_SHA256=$(shasum -a 256 gfortran.dmg)
-    KNOWN_SHA256="d2d5ca5ba8332d63bbe23a07201c4a0a5d7e09ee56f0298a96775f928c3c4b30  gfortran.dmg"
-    if [ "$GFORTRAN_SHA256" != "$KNOWN_SHA256" ]; then
-        echo sha256 mismatch
-        exit 1
+if [[ $RUNNER_OS == "macOS" ]]; then
+    # Install same version of gfortran as the openblas-libs builds
+    if [[ $PLATFORM == "macosx-arm64" ]]; then
+        PLAT="arm64"
     fi
-    hdiutil attach -mountpoint /Volumes/gfortran gfortran.dmg
-    sudo installer -pkg /Volumes/gfortran/gfortran.pkg -target /
-    otool -L /usr/local/gfortran/lib/libgfortran.3.dylib
-    # Manually symlink gfortran-4.9 to plain gfortran for f2py.
-    # No longer needed after Feb 13 2020 as gfortran is already present
-    # and the attempted link errors. Keep this for future reference.
-    # ln -s /usr/local/bin/gfortran-4.9 /usr/local/bin/gfortran
+    source $PROJECT_DIR/tools/wheels/gfortran_utils.sh
+    install_gfortran
+    pip install delocate==0.10.4
 fi
diff --git a/tools/wheels/cibw_test_command.sh b/tools/wheels/cibw_test_command.sh
index f09395e847a1..36c275f32d91 100644
--- a/tools/wheels/cibw_test_command.sh
+++ b/tools/wheels/cibw_test_command.sh
@@ -1,15 +1,35 @@
-# This script is used by .github/workflows/wheels.yml to build wheels with
-# cibuildwheel. It runs the full test suite, checks for lincense inclusion
-# and that the openblas version is correct.
+# This script is used by .github/workflows/wheels.yml to run the full test
+# suite, checks for lincense inclusion and that the openblas version is correct.
 set -xe
 
 PROJECT_DIR="$1"
-UNAME="$(uname)"
 
+python -m pip install threadpoolctl
 python -c "import numpy; numpy.show_config()"
-python -c "import sys; import numpy; sys.exit(not numpy.test('full', extra_argv=['-vv']))"
-
-python $PROJECT_DIR/tools/wheels/check_license.py
-if [[ $UNAME == "Linux" || $UNAME == "Darwin" ]] ; then
-    python $PROJECT_DIR/tools/openblas_support.py --check_version
+if [[ $RUNNER_OS == "Windows" ]]; then
+    # GH 20391
+    PY_DIR=$(python -c "import sys; print(sys.prefix)")
+    mkdir $PY_DIR/libs
+fi
+if [[ $RUNNER_OS == "macOS"  && $RUNNER_ARCH == "X64" ]]; then
+  # Not clear why this is needed but it seems on x86_64 this is not the default
+  # and without it f2py tests fail
+  export DYLD_LIBRARY_PATH="$DYLD_LIBRARY_PATH:/usr/local/lib"
+  # Needed so gfortran (not clang) can find system libraries like libm (-lm)
+  # in f2py tests
+  export LIBRARY_PATH="$LIBRARY_PATH:/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/lib"
+else
+  # For some reason the macos-x86_64 runner does not work with threadpoolctl
+  # Skip this check there
+  python $PROJECT_DIR/tools/openblas_support.py --check_version
 fi
+# Set available memory value to avoid OOM problems on aarch64.
+# See gh-22418.
+export NPY_AVAILABLE_MEM="4 GB"
+if [[ $(python -c "import sys; print(sys.implementation.name)") == "pypy" ]]; then
+  # make PyPy more verbose, try to catch a segfault
+  python -c "import sys; import numpy; sys.exit(not numpy.test(label='full', verbose=2))"
+else
+  python -c "import sys; import numpy; sys.exit(not numpy.test(label='full'))"
+fi
+python $PROJECT_DIR/tools/wheels/check_license.py
diff --git a/tools/wheels/gfortran_utils.sh b/tools/wheels/gfortran_utils.sh
new file mode 100644
index 000000000000..39357b3feacf
--- /dev/null
+++ b/tools/wheels/gfortran_utils.sh
@@ -0,0 +1,191 @@
+# This file is vendored from github.com/MacPython/gfortran-install It is
+# licensed under BSD-2 which is copied as a comment below
+
+# Copyright 2016-2021 Matthew Brett, Isuru Fernando, Matti Picus
+
+# 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.
+
+# 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 HOLDER 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.
+
+# Bash utilities for use with gfortran
+
+ARCHIVE_SDIR="${ARCHIVE_SDIR:-archives}"
+
+GF_UTIL_DIR=$(dirname "${BASH_SOURCE[0]}")
+
+function get_distutils_platform {
+    # Report platform as in form of distutils get_platform.
+    # This is like the platform tag that pip will use.
+    # Modify fat architecture tags on macOS to reflect compiled architecture
+
+    # Deprecate this function once get_distutils_platform_ex is used in all
+    # downstream projects
+    local plat=$1
+    case $plat in
+        i686|x86_64|arm64|universal2|intel|aarch64|s390x|ppc64le) ;;
+        *) echo Did not recognize plat $plat; return 1 ;;
+    esac
+    local uname=${2:-$(uname)}
+    if [ "$uname" != "Darwin" ]; then
+        if [ "$plat" == "intel" ]; then
+            echo plat=intel not allowed for Manylinux
+            return 1
+        fi
+        echo "manylinux1_$plat"
+        return
+    fi
+    # The gfortran downloads build for macos 10.9
+    local target="10_9"
+    echo "macosx_${target}_${plat}"
+}
+
+function get_distutils_platform_ex {
+    # Report platform as in form of distutils get_platform.
+    # This is like the platform tag that pip will use.
+    # Modify fat architecture tags on macOS to reflect compiled architecture
+    # For non-darwin, report manylinux version
+    local plat=$1
+    local mb_ml_ver=${MB_ML_VER:-1}
+    case $plat in
+        i686|x86_64|arm64|universal2|intel|aarch64|s390x|ppc64le) ;;
+        *) echo Did not recognize plat $plat; return 1 ;;
+    esac
+    local uname=${2:-$(uname)}
+    if [ "$uname" != "Darwin" ]; then
+        if [ "$plat" == "intel" ]; then
+            echo plat=intel not allowed for Manylinux
+            return 1
+        fi
+        echo "manylinux${mb_ml_ver}_${plat}"
+        return
+    fi
+    # The gfortran downloads build for macos 10.9
+    local target="10_9"
+    echo "macosx_${target}_${plat}"
+}
+
+function get_macosx_target {
+    # Report MACOSX_DEPLOYMENT_TARGET as given by distutils get_platform.
+    python3 -c "import sysconfig as s; print(s.get_config_vars()['MACOSX_DEPLOYMENT_TARGET'])"
+}
+
+function check_gfortran {
+    # Check that gfortran exists on the path
+    if [ -z "$(which gfortran)" ]; then
+        echo Missing gfortran
+        exit 1
+    fi
+}
+
+function get_gf_lib_for_suf {
+    local suffix=$1
+    local prefix=$2
+    local plat=${3:-$PLAT}
+    local uname=${4:-$(uname)}
+    if [ -z "$prefix" ]; then echo Prefix not defined; exit 1; fi
+    local plat_tag=$(get_distutils_platform_ex $plat $uname)
+    if [ -n "$suffix" ]; then suffix="-$suffix"; fi
+    local fname="$prefix-${plat_tag}${suffix}.tar.gz"
+    local out_fname="${ARCHIVE_SDIR}/$fname"
+    [ -s $out_fname ] || (echo "$out_fname is empty"; exit 24)
+    echo "$out_fname"
+}
+
+if [ "$(uname)" == "Darwin" ]; then
+    mac_target=${MACOSX_DEPLOYMENT_TARGET:-$(get_macosx_target)}
+    export MACOSX_DEPLOYMENT_TARGET=$mac_target
+    # Keep this for now as some builds might depend on this being
+    # available before install_gfortran is called
+    export GFORTRAN_SHA=c469a420d2d003112749dcdcbe3c684eef42127e
+    # Set SDKROOT env variable if not set
+    export SDKROOT=${SDKROOT:-$(xcrun --show-sdk-path)}
+
+    function download_and_unpack_gfortran {
+	local arch=$1
+	local type=$2
+        curl -L -O https://github.com/isuruf/gcc/releases/download/gcc-11.3.0-2/gfortran-darwin-${arch}-${type}.tar.gz
+	case ${arch}-${type} in
+	    arm64-native)
+	        export GFORTRAN_SHA=142290685240f4f86cdf359cb2030d586105d7e4
+		;;
+	    arm64-cross)
+		export GFORTRAN_SHA=527232845abc5af21f21ceacc46fb19c190fe804
+		;;
+	    x86_64-native)
+		export GFORTRAN_SHA=c469a420d2d003112749dcdcbe3c684eef42127e
+		;;
+	    x86_64-cross)
+		export GFORTRAN_SHA=107604e57db97a0ae3e7ca7f5dd722959752f0b3
+		;;
+	esac
+        if [[ "$(shasum gfortran-darwin-${arch}-${type}.tar.gz)" != "${GFORTRAN_SHA}  gfortran-darwin-${arch}-${type}.tar.gz" ]]; then
+            echo "shasum mismatch for gfortran-darwin-${arch}-${type}"
+            exit 1
+        fi
+        sudo mkdir -p /opt/
+        sudo cp "gfortran-darwin-${arch}-${type}.tar.gz" /opt/gfortran-darwin-${arch}-${type}.tar.gz
+        pushd /opt
+            sudo tar -xvf gfortran-darwin-${arch}-${type}.tar.gz
+            sudo rm gfortran-darwin-${arch}-${type}.tar.gz
+        popd
+	if [[ "${type}" == "native" ]]; then
+	    # Link these into /usr/local so that there's no need to add rpath or -L
+	    for f in libgfortran.dylib libgfortran.5.dylib libgcc_s.1.dylib libgcc_s.1.1.dylib libquadmath.dylib libquadmath.0.dylib; do
+                ln -sf /opt/gfortran-darwin-${arch}-${type}/lib/$f /usr/local/lib/$f
+            done
+	    # Add it to PATH
+	    ln -sf /opt/gfortran-darwin-${arch}-${type}/bin/gfortran /usr/local/bin/gfortran
+	fi
+    }
+
+    function install_arm64_cross_gfortran {
+	download_and_unpack_gfortran arm64 cross
+        export FC_ARM64="$(find /opt/gfortran-darwin-arm64-cross/bin -name "*-gfortran")"
+        local libgfortran="$(find /opt/gfortran-darwin-arm64-cross/lib -name libgfortran.dylib)"
+        local libdir=$(dirname $libgfortran)
+
+        export FC_ARM64_LDFLAGS="-L$libdir -Wl,-rpath,$libdir"
+        if [[ "${PLAT:-}" == "arm64" ]]; then
+            export FC=$FC_ARM64
+        fi
+    }
+    function install_gfortran {
+        download_and_unpack_gfortran $(uname -m) native
+        check_gfortran
+        if [[ "${PLAT:-}" == "universal2" || "${PLAT:-}" == "arm64" ]]; then
+            install_arm64_cross_gfortran
+        fi
+    }
+
+    function get_gf_lib {
+        # Get lib with gfortran suffix
+        get_gf_lib_for_suf "gf_${GFORTRAN_SHA:0:7}" $@
+    }
+else
+    function install_gfortran {
+        # No-op - already installed on manylinux image
+        check_gfortran
+    }
+
+    function get_gf_lib {
+        # Get library with no suffix
+        get_gf_lib_for_suf "" $@
+    }
+fi
diff --git a/tools/wheels/upload_wheels.sh b/tools/wheels/upload_wheels.sh
new file mode 100644
index 000000000000..6694caf019c5
--- /dev/null
+++ b/tools/wheels/upload_wheels.sh
@@ -0,0 +1,56 @@
+set_travis_vars() {
+    # Set env vars
+    echo "TRAVIS_EVENT_TYPE is $TRAVIS_EVENT_TYPE"
+    echo "TRAVIS_TAG is $TRAVIS_TAG"
+    if [[ "$TRAVIS_EVENT_TYPE" == "push" && "$TRAVIS_TAG" == v* ]]; then
+      IS_PUSH="true"
+    else
+      IS_PUSH="false"
+    fi
+    if [[ "$TRAVIS_EVENT_TYPE" == "cron" ]]; then
+      IS_SCHEDULE_DISPATCH="true"
+    else
+      IS_SCHEDULE_DISPATCH="false"
+    fi
+}
+set_upload_vars() {
+    echo "IS_PUSH is $IS_PUSH"
+    echo "IS_SCHEDULE_DISPATCH is $IS_SCHEDULE_DISPATCH"
+    if [[ "$IS_PUSH" == "true" ]]; then
+        echo push and tag event
+        export ANACONDA_ORG="multibuild-wheels-staging"
+        export TOKEN="$NUMPY_STAGING_UPLOAD_TOKEN"
+        export ANACONDA_UPLOAD="true"
+    elif [[ "$IS_SCHEDULE_DISPATCH" == "true" ]]; then
+        echo scheduled or dispatched event
+        export ANACONDA_ORG="scipy-wheels-nightly"
+        export TOKEN="$NUMPY_NIGHTLY_UPLOAD_TOKEN"
+        export ANACONDA_UPLOAD="true"
+    else
+        echo non-dispatch event
+        export ANACONDA_UPLOAD="false"
+    fi
+}
+upload_wheels() {
+    echo ${PWD}
+    if [[ ${ANACONDA_UPLOAD} == true ]]; then
+        if [[ -z ${TOKEN} ]]; then
+            echo no token set, not uploading
+        else
+            python -m pip install \
+            git+https://github.com/Anaconda-Platform/anaconda-client.git@be1e14936a8e947da94d026c990715f0596d7043
+            # sdists are located under dist folder when built through setup.py
+            if compgen -G "./dist/*.gz"; then
+                echo "Found sdist"
+                anaconda -q -t ${TOKEN} upload --skip -u ${ANACONDA_ORG} ./dist/*.gz
+            elif compgen -G "./wheelhouse/*.whl"; then
+                echo "Found wheel"
+                anaconda -q -t ${TOKEN} upload --skip -u ${ANACONDA_ORG} ./wheelhouse/*.whl
+            else
+                echo "Files do not exist"
+                return 1
+            fi
+            echo "PyPI-style index: https://pypi.anaconda.org/$ANACONDA_ORG/simple"
+        fi
+    fi
+}
diff --git a/tox.ini b/tox.ini
index 9bc2bbac36dd..f47551398ad8 100644
--- a/tox.ini
+++ b/tox.ini
@@ -13,7 +13,7 @@
 #     - Use pip to install the numpy sdist into the virtualenv
 #     - Run the numpy tests
 # To run against a specific subset of Python versions, use:
-#   tox -e py37
+#   tox -e py39
 
 # Extra arguments will be passed to runtests.py. To run
 # the full testsuite:
@@ -26,18 +26,13 @@
 
 [tox]
 envlist =
-  py37,py38,py39,
-  py37-not-relaxed-strides
+  py38,py39
 
 [testenv]
 deps= -Ur{toxinidir}/test_requirements.txt
 changedir={envdir}
 commands={envpython} -b {toxinidir}/runtests.py --mode=full {posargs:}
 
-[testenv:py37-not-relaxed-strides]
-basepython=python3.7
-env=NPY_RELAXED_STRIDES_CHECKING=0
-
 # Not run by default. Set up the way you want then use 'tox -e debug'
 # if you want it:
 [testenv:debug]
diff --git a/versioneer.py b/versioneer.py
index 7aa415ac8a9b..07ecc67bf2b4 100644
--- a/versioneer.py
+++ b/versioneer.py
@@ -1,5 +1,5 @@
 
-# Version: 0.19
+# Version: 0.26
 
 """The Versioneer - like a rocketeer, but for versions.
 
@@ -9,12 +9,12 @@
 * like a rocketeer, but for versions!
 * https://github.com/python-versioneer/python-versioneer
 * Brian Warner
-* License: Public Domain
-* Compatible with: Python 3.6, 3.7, 3.8, 3.9 and pypy3
+* License: Public Domain (Unlicense)
+* Compatible with: Python 3.7, 3.8, 3.9, 3.10 and pypy3
 * [![Latest Version][pypi-image]][pypi-url]
 * [![Build Status][travis-image]][travis-url]
 
-This is a tool for managing a recorded version number in distutils-based
+This is a tool for managing a recorded version number in setuptools-based
 python projects. The goal is to remove the tedious and error-prone "update
 the embedded version string" step from your release process. Making a new
 release should be as easy as recording a new tag in your version-control
@@ -23,10 +23,32 @@
 
 ## Quick Install
 
+Versioneer provides two installation modes. The "classic" vendored mode installs
+a copy of versioneer into your repository. The experimental build-time dependency mode
+is intended to allow you to skip this step and simplify the process of upgrading.
+
+### Vendored mode
+
+* `pip install versioneer` to somewhere in your $PATH
+* add a `[tool.versioneer]` section to your `pyproject.toml or a
+  `[versioneer]` section to your `setup.cfg` (see [Install](INSTALL.md))
+* run `versioneer install --vendor` in your source tree, commit the results
+* verify version information with `python setup.py version`
+
+### Build-time dependency mode
+
 * `pip install versioneer` to somewhere in your $PATH
-* add a `[versioneer]` section to your setup.cfg (see [Install](INSTALL.md))
-* run `versioneer install` in your source tree, commit the results
-* Verify version information with `python setup.py version`
+* add a `[tool.versioneer]` section to your `pyproject.toml or a
+  `[versioneer]` section to your `setup.cfg` (see [Install](INSTALL.md))
+* add `versioneer` to the `requires` key of the `build-system` table in
+  `pyproject.toml`:
+  ```toml
+  [build-system]
+  requires = ["setuptools", "versioneer"]
+  build-backend = "setuptools.build_meta"
+  ```
+* run `versioneer install --no-vendor` in your source tree, commit the results
+* verify version information with `python setup.py version`
 
 ## Version Identifiers
 
@@ -231,9 +253,10 @@
 To upgrade your project to a new release of Versioneer, do the following:
 
 * install the new Versioneer (`pip install -U versioneer` or equivalent)
-* edit `setup.cfg`, if necessary, to include any new configuration settings
-  indicated by the release notes. See [UPGRADING](./UPGRADING.md) for details.
-* re-run `versioneer install` in your source tree, to replace
+* edit `setup.cfg` and `pyproject.toml`, if necessary,
+  to include any new configuration settings indicated by the release notes.
+  See [UPGRADING](./UPGRADING.md) for details.
+* re-run `versioneer install --[no-]vendor` in your source tree, to replace
   `SRC/_version.py`
 * commit any changed files
 
@@ -256,6 +279,8 @@
   dependency
 * [minver](https://github.com/jbweston/miniver) - a lightweight reimplementation of
   versioneer
+* [versioningit](https://github.com/jwodder/versioningit) - a PEP 518-based setuptools
+  plugin
 
 ## License
 
@@ -272,6 +297,11 @@
 [travis-url]: https://travis-ci.com/github/python-versioneer/python-versioneer
 
 """
+# pylint:disable=invalid-name,import-outside-toplevel,missing-function-docstring
+# pylint:disable=missing-class-docstring,too-many-branches,too-many-statements
+# pylint:disable=raise-missing-from,too-many-lines,too-many-locals,import-error
+# pylint:disable=too-few-public-methods,redefined-outer-name,consider-using-with
+# pylint:disable=attribute-defined-outside-init,too-many-arguments
 
 import configparser
 import errno
@@ -280,6 +310,14 @@
 import re
 import subprocess
 import sys
+from pathlib import Path
+from typing import Callable, Dict
+import functools
+try:
+    import tomli
+    have_tomli = True
+except ImportError:
+    have_tomli = False
 
 
 class VersioneerConfig:
@@ -314,12 +352,12 @@ def get_root():
         # module-import table will cache the first one. So we can't use
         # os.path.dirname(__file__), as that will find whichever
         # versioneer.py was first imported, even in later projects.
-        me = os.path.realpath(os.path.abspath(__file__))
-        me_dir = os.path.normcase(os.path.splitext(me)[0])
+        my_path = os.path.realpath(os.path.abspath(__file__))
+        me_dir = os.path.normcase(os.path.splitext(my_path)[0])
         vsr_dir = os.path.normcase(os.path.splitext(versioneer_py)[0])
-        if me_dir != vsr_dir:
+        if me_dir != vsr_dir and "VERSIONEER_PEP518" not in globals():
             print("Warning: build in %s is using versioneer.py from %s"
-                  % (os.path.dirname(me), versioneer_py))
+                  % (os.path.dirname(my_path), versioneer_py))
     except NameError:
         pass
     return root
@@ -327,30 +365,39 @@ def get_root():
 
 def get_config_from_root(root):
     """Read the project setup.cfg file to determine Versioneer config."""
-    # This might raise EnvironmentError (if setup.cfg is missing), or
+    # This might raise OSError (if setup.cfg is missing), or
     # configparser.NoSectionError (if it lacks a [versioneer] section), or
     # configparser.NoOptionError (if it lacks "VCS="). See the docstring at
     # the top of versioneer.py for instructions on writing your setup.cfg .
-    setup_cfg = os.path.join(root, "setup.cfg")
-    parser = configparser.ConfigParser()
-    with open(setup_cfg, "r") as f:
-        parser.read_file(f)
-    VCS = parser.get("versioneer", "VCS")  # mandatory
-
-    def get(parser, name):
-        if parser.has_option("versioneer", name):
-            return parser.get("versioneer", name)
-        return None
+    root = Path(root)
+    pyproject_toml = root / "pyproject.toml"
+    setup_cfg = root / "setup.cfg"
+    section = None
+    if pyproject_toml.exists() and have_tomli:
+        try:
+            with open(pyproject_toml, 'rb') as fobj:
+                pp = tomli.load(fobj)
+            section = pp['tool']['versioneer']
+        except (tomli.TOMLDecodeError, KeyError):
+            pass
+    if not section:
+        parser = configparser.ConfigParser()
+        with open(setup_cfg) as cfg_file:
+            parser.read_file(cfg_file)
+        parser.get("versioneer", "VCS")  # raise error if missing
+
+        section = parser["versioneer"]
+
     cfg = VersioneerConfig()
-    cfg.VCS = VCS
-    cfg.style = get(parser, "style") or ""
-    cfg.versionfile_source = get(parser, "versionfile_source")
-    cfg.versionfile_build = get(parser, "versionfile_build")
-    cfg.tag_prefix = get(parser, "tag_prefix")
-    if cfg.tag_prefix in ("''", '""'):
+    cfg.VCS = section['VCS']
+    cfg.style = section.get("style", "")
+    cfg.versionfile_source = section.get("versionfile_source")
+    cfg.versionfile_build = section.get("versionfile_build")
+    cfg.tag_prefix = section.get("tag_prefix")
+    if cfg.tag_prefix in ("''", '""', None):
         cfg.tag_prefix = ""
-    cfg.parentdir_prefix = get(parser, "parentdir_prefix")
-    cfg.verbose = get(parser, "verbose")
+    cfg.parentdir_prefix = section.get("parentdir_prefix")
+    cfg.verbose = section.get("verbose")
     return cfg
 
 
@@ -359,17 +406,15 @@ class NotThisMethod(Exception):
 
 
 # these dictionaries contain VCS-specific tools
-LONG_VERSION_PY = {}
-HANDLERS = {}
+LONG_VERSION_PY: Dict[str, str] = {}
+HANDLERS: Dict[str, Dict[str, Callable]] = {}
 
 
 def register_vcs_handler(vcs, method):  # decorator
     """Create decorator to mark a method as the handler of a VCS."""
     def decorate(f):
         """Store f in HANDLERS[vcs][method]."""
-        if vcs not in HANDLERS:
-            HANDLERS[vcs] = {}
-        HANDLERS[vcs][method] = f
+        HANDLERS.setdefault(vcs, {})[method] = f
         return f
     return decorate
 
@@ -378,17 +423,25 @@ def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False,
                 env=None):
     """Call the given command(s)."""
     assert isinstance(commands, list)
-    p = None
-    for c in commands:
+    process = None
+
+    popen_kwargs = {}
+    if sys.platform == "win32":
+        # This hides the console window if pythonw.exe is used
+        startupinfo = subprocess.STARTUPINFO()
+        startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+        popen_kwargs["startupinfo"] = startupinfo
+
+    for command in commands:
         try:
-            dispcmd = str([c] + args)
+            dispcmd = str([command] + args)
             # remember shell=False, so use git.cmd on windows, not just git
-            p = subprocess.Popen([c] + args, cwd=cwd, env=env,
-                                 stdout=subprocess.PIPE,
-                                 stderr=(subprocess.PIPE if hide_stderr
-                                         else None))
+            process = subprocess.Popen([command] + args, cwd=cwd, env=env,
+                                       stdout=subprocess.PIPE,
+                                       stderr=(subprocess.PIPE if hide_stderr
+                                               else None), **popen_kwargs)
             break
-        except EnvironmentError:
+        except OSError:
             e = sys.exc_info()[1]
             if e.errno == errno.ENOENT:
                 continue
@@ -400,13 +453,13 @@ def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False,
         if verbose:
             print("unable to find command, tried %s" % (commands,))
         return None, None
-    stdout = p.communicate()[0].strip().decode()
-    if p.returncode != 0:
+    stdout = process.communicate()[0].strip().decode()
+    if process.returncode != 0:
         if verbose:
             print("unable to run %s (error)" % dispcmd)
             print("stdout was %s" % stdout)
-        return None, p.returncode
-    return stdout, p.returncode
+        return None, process.returncode
+    return stdout, process.returncode
 
 
 LONG_VERSION_PY['git'] = r'''
@@ -416,8 +469,9 @@ def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False,
 # directories (produced by setup.py build) will contain a much shorter file
 # that just contains the computed version number.
 
-# This file is released into the public domain. Generated by
-# versioneer-0.19 (https://github.com/python-versioneer/python-versioneer)
+# This file is released into the public domain.
+# Generated by versioneer-0.26
+# https://github.com/python-versioneer/python-versioneer
 
 """Git implementation of _version.py."""
 
@@ -426,6 +480,8 @@ def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False,
 import re
 import subprocess
 import sys
+from typing import Callable, Dict
+import functools
 
 
 def get_keywords():
@@ -463,8 +519,8 @@ class NotThisMethod(Exception):
     """Exception raised if a method is not valid for the current scenario."""
 
 
-LONG_VERSION_PY = {}
-HANDLERS = {}
+LONG_VERSION_PY: Dict[str, str] = {}
+HANDLERS: Dict[str, Dict[str, Callable]] = {}
 
 
 def register_vcs_handler(vcs, method):  # decorator
@@ -482,17 +538,25 @@ def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False,
                 env=None):
     """Call the given command(s)."""
     assert isinstance(commands, list)
-    p = None
-    for c in commands:
+    process = None
+
+    popen_kwargs = {}
+    if sys.platform == "win32":
+        # This hides the console window if pythonw.exe is used
+        startupinfo = subprocess.STARTUPINFO()
+        startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+        popen_kwargs["startupinfo"] = startupinfo
+
+    for command in commands:
         try:
-            dispcmd = str([c] + args)
+            dispcmd = str([command] + args)
             # remember shell=False, so use git.cmd on windows, not just git
-            p = subprocess.Popen([c] + args, cwd=cwd, env=env,
-                                 stdout=subprocess.PIPE,
-                                 stderr=(subprocess.PIPE if hide_stderr
-                                         else None))
+            process = subprocess.Popen([command] + args, cwd=cwd, env=env,
+                                       stdout=subprocess.PIPE,
+                                       stderr=(subprocess.PIPE if hide_stderr
+                                               else None), **popen_kwargs)
             break
-        except EnvironmentError:
+        except OSError:
             e = sys.exc_info()[1]
             if e.errno == errno.ENOENT:
                 continue
@@ -504,13 +568,13 @@ def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False,
         if verbose:
             print("unable to find command, tried %%s" %% (commands,))
         return None, None
-    stdout = p.communicate()[0].strip().decode()
-    if p.returncode != 0:
+    stdout = process.communicate()[0].strip().decode()
+    if process.returncode != 0:
         if verbose:
             print("unable to run %%s (error)" %% dispcmd)
             print("stdout was %%s" %% stdout)
-        return None, p.returncode
-    return stdout, p.returncode
+        return None, process.returncode
+    return stdout, process.returncode
 
 
 def versions_from_parentdir(parentdir_prefix, root, verbose):
@@ -522,15 +586,14 @@ def versions_from_parentdir(parentdir_prefix, root, verbose):
     """
     rootdirs = []
 
-    for i in range(3):
+    for _ in range(3):
         dirname = os.path.basename(root)
         if dirname.startswith(parentdir_prefix):
             return {"version": dirname[len(parentdir_prefix):],
                     "full-revisionid": None,
                     "dirty": False, "error": None, "date": None}
-        else:
-            rootdirs.append(root)
-            root = os.path.dirname(root)  # up a level
+        rootdirs.append(root)
+        root = os.path.dirname(root)  # up a level
 
     if verbose:
         print("Tried directories %%s but none started with prefix %%s" %%
@@ -547,22 +610,21 @@ def git_get_keywords(versionfile_abs):
     # _version.py.
     keywords = {}
     try:
-        f = open(versionfile_abs, "r")
-        for line in f.readlines():
-            if line.strip().startswith("git_refnames ="):
-                mo = re.search(r'=\s*"(.*)"', line)
-                if mo:
-                    keywords["refnames"] = mo.group(1)
-            if line.strip().startswith("git_full ="):
-                mo = re.search(r'=\s*"(.*)"', line)
-                if mo:
-                    keywords["full"] = mo.group(1)
-            if line.strip().startswith("git_date ="):
-                mo = re.search(r'=\s*"(.*)"', line)
-                if mo:
-                    keywords["date"] = mo.group(1)
-        f.close()
-    except EnvironmentError:
+        with open(versionfile_abs, "r") as fobj:
+            for line in fobj:
+                if line.strip().startswith("git_refnames ="):
+                    mo = re.search(r'=\s*"(.*)"', line)
+                    if mo:
+                        keywords["refnames"] = mo.group(1)
+                if line.strip().startswith("git_full ="):
+                    mo = re.search(r'=\s*"(.*)"', line)
+                    if mo:
+                        keywords["full"] = mo.group(1)
+                if line.strip().startswith("git_date ="):
+                    mo = re.search(r'=\s*"(.*)"', line)
+                    if mo:
+                        keywords["date"] = mo.group(1)
+    except OSError:
         pass
     return keywords
 
@@ -570,8 +632,8 @@ def git_get_keywords(versionfile_abs):
 @register_vcs_handler("git", "keywords")
 def git_versions_from_keywords(keywords, tag_prefix, verbose):
     """Get version information from git keywords."""
-    if not keywords:
-        raise NotThisMethod("no keywords at all, weird")
+    if "refnames" not in keywords:
+        raise NotThisMethod("Short version file found")
     date = keywords.get("date")
     if date is not None:
         # Use only the last line.  Previous lines may contain GPG signature
@@ -590,11 +652,11 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose):
         if verbose:
             print("keywords are unexpanded, not using")
         raise NotThisMethod("unexpanded keywords, not a git-archive tarball")
-    refs = set([r.strip() for r in refnames.strip("()").split(",")])
+    refs = {r.strip() for r in refnames.strip("()").split(",")}
     # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of
     # just "foo-1.0". If we see a "tag: " prefix, prefer those.
     TAG = "tag: "
-    tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)])
+    tags = {r[len(TAG):] for r in refs if r.startswith(TAG)}
     if not tags:
         # Either we're using git < 1.8.3, or there really are no tags. We use
         # a heuristic: assume all version tags have a digit. The old git %%d
@@ -603,7 +665,7 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose):
         # between branches and tags. By ignoring refnames without digits, we
         # filter out many common branch names like "release" and
         # "stabilization", as well as "HEAD" and "master".
-        tags = set([r for r in refs if re.search(r'\d', r)])
+        tags = {r for r in refs if re.search(r'\d', r)}
         if verbose:
             print("discarding '%%s', no digits" %% ",".join(refs - tags))
     if verbose:
@@ -612,6 +674,11 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose):
         # sorting will prefer e.g. "2.0" over "2.0rc1"
         if ref.startswith(tag_prefix):
             r = ref[len(tag_prefix):]
+            # Filter out refs that exactly match prefix or that don't start
+            # with a number once the prefix is stripped (mostly a concern
+            # when prefix is '')
+            if not re.match(r'\d', r):
+                continue
             if verbose:
                 print("picking %%s" %% r)
             return {"version": r,
@@ -627,7 +694,7 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose):
 
 
 @register_vcs_handler("git", "pieces_from_vcs")
-def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
+def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command):
     """Get version from 'git describe' in the root of the source tree.
 
     This only gets called if the git-archive 'subst' keywords were *not*
@@ -638,8 +705,15 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
     if sys.platform == "win32":
         GITS = ["git.cmd", "git.exe"]
 
-    out, rc = run_command(GITS, ["rev-parse", "--git-dir"], cwd=root,
-                          hide_stderr=True)
+    # GIT_DIR can interfere with correct operation of Versioneer.
+    # It may be intended to be passed to the Versioneer-versioned project,
+    # but that should not change where we get our version from.
+    env = os.environ.copy()
+    env.pop("GIT_DIR", None)
+    runner = functools.partial(runner, env=env)
+
+    _, rc = runner(GITS, ["rev-parse", "--git-dir"], cwd=root,
+                   hide_stderr=not verbose)
     if rc != 0:
         if verbose:
             print("Directory %%s not under git control" %% root)
@@ -647,15 +721,15 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
 
     # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty]
     # if there isn't one, this yields HEX[-dirty] (no NUM)
-    describe_out, rc = run_command(GITS, ["describe", "--tags", "--dirty=",
-                                          "--always", "--long",
-                                          "--match", "%%s*" %% tag_prefix],
-                                   cwd=root)
+    describe_out, rc = runner(GITS, [
+        "describe", "--tags", "--dirty=", "--always", "--long",
+        "--match", f"{tag_prefix}[[:digit:]]*"
+    ], cwd=root)
     # --long was added in git-1.5.5
     if describe_out is None:
         raise NotThisMethod("'git describe' failed")
     describe_out = describe_out.strip()
-    full_out, rc = run_command(GITS, ["rev-parse", "HEAD"], cwd=root)
+    full_out, rc = runner(GITS, ["rev-parse", "HEAD"], cwd=root)
     if full_out is None:
         raise NotThisMethod("'git rev-parse' failed")
     full_out = full_out.strip()
@@ -665,6 +739,39 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
     pieces["short"] = full_out[:7]  # maybe improved later
     pieces["error"] = None
 
+    branch_name, rc = runner(GITS, ["rev-parse", "--abbrev-ref", "HEAD"],
+                             cwd=root)
+    # --abbrev-ref was added in git-1.6.3
+    if rc != 0 or branch_name is None:
+        raise NotThisMethod("'git rev-parse --abbrev-ref' returned error")
+    branch_name = branch_name.strip()
+
+    if branch_name == "HEAD":
+        # If we aren't exactly on a branch, pick a branch which represents
+        # the current commit. If all else fails, we are on a branchless
+        # commit.
+        branches, rc = runner(GITS, ["branch", "--contains"], cwd=root)
+        # --contains was added in git-1.5.4
+        if rc != 0 or branches is None:
+            raise NotThisMethod("'git branch --contains' returned error")
+        branches = branches.split("\n")
+
+        # Remove the first line if we're running detached
+        if "(" in branches[0]:
+            branches.pop(0)
+
+        # Strip off the leading "* " from the list of branches.
+        branches = [branch[2:] for branch in branches]
+        if "master" in branches:
+            branch_name = "master"
+        elif not branches:
+            branch_name = None
+        else:
+            # Pick the first branch that is returned. Good or bad.
+            branch_name = branches[0]
+
+    pieces["branch"] = branch_name
+
     # parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty]
     # TAG might have hyphens.
     git_describe = describe_out
@@ -681,7 +788,7 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
         # TAG-NUM-gHEX
         mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe)
         if not mo:
-            # unparseable. Maybe git-describe is misbehaving?
+            # unparsable. Maybe git-describe is misbehaving?
             pieces["error"] = ("unable to parse git-describe output: '%%s'"
                                %% describe_out)
             return pieces
@@ -706,13 +813,11 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
     else:
         # HEX: no tags
         pieces["closest-tag"] = None
-        count_out, rc = run_command(GITS, ["rev-list", "HEAD", "--count"],
-                                    cwd=root)
-        pieces["distance"] = int(count_out)  # total number of commits
+        out, rc = runner(GITS, ["rev-list", "HEAD", "--left-right"], cwd=root)
+        pieces["distance"] = len(out.split())  # total number of commits
 
     # commit date: see ISO-8601 comment in git_versions_from_keywords()
-    date = run_command(GITS, ["show", "-s", "--format=%%ci", "HEAD"],
-                       cwd=root)[0].strip()
+    date = runner(GITS, ["show", "-s", "--format=%%ci", "HEAD"], cwd=root)[0].strip()
     # Use only the last line.  Previous lines may contain GPG signature
     # information.
     date = date.splitlines()[-1]
@@ -753,16 +858,64 @@ def render_pep440(pieces):
     return rendered
 
 
+def render_pep440_branch(pieces):
+    """TAG[[.dev0]+DISTANCE.gHEX[.dirty]] .
+
+    The ".dev0" means not master branch. Note that .dev0 sorts backwards
+    (a feature branch will appear "older" than the master branch).
+
+    Exceptions:
+    1: no tags. 0[.dev0]+untagged.DISTANCE.gHEX[.dirty]
+    """
+    if pieces["closest-tag"]:
+        rendered = pieces["closest-tag"]
+        if pieces["distance"] or pieces["dirty"]:
+            if pieces["branch"] != "master":
+                rendered += ".dev0"
+            rendered += plus_or_dot(pieces)
+            rendered += "%%d.g%%s" %% (pieces["distance"], pieces["short"])
+            if pieces["dirty"]:
+                rendered += ".dirty"
+    else:
+        # exception #1
+        rendered = "0"
+        if pieces["branch"] != "master":
+            rendered += ".dev0"
+        rendered += "+untagged.%%d.g%%s" %% (pieces["distance"],
+                                          pieces["short"])
+        if pieces["dirty"]:
+            rendered += ".dirty"
+    return rendered
+
+
+def pep440_split_post(ver):
+    """Split pep440 version string at the post-release segment.
+
+    Returns the release segments before the post-release and the
+    post-release version number (or -1 if no post-release segment is present).
+    """
+    vc = str.split(ver, ".post")
+    return vc[0], int(vc[1] or 0) if len(vc) == 2 else None
+
+
 def render_pep440_pre(pieces):
-    """TAG[.post0.devDISTANCE] -- No -dirty.
+    """TAG[.postN.devDISTANCE] -- No -dirty.
 
     Exceptions:
     1: no tags. 0.post0.devDISTANCE
     """
     if pieces["closest-tag"]:
-        rendered = pieces["closest-tag"]
         if pieces["distance"]:
-            rendered += ".post0.dev%%d" %% pieces["distance"]
+            # update the post release segment
+            tag_version, post_version = pep440_split_post(pieces["closest-tag"])
+            rendered = tag_version
+            if post_version is not None:
+                rendered += ".post%%d.dev%%d" %% (post_version + 1, pieces["distance"])
+            else:
+                rendered += ".post0.dev%%d" %% (pieces["distance"])
+        else:
+            # no commits, use the tag as the version
+            rendered = pieces["closest-tag"]
     else:
         # exception #1
         rendered = "0.post0.dev%%d" %% pieces["distance"]
@@ -796,6 +949,35 @@ def render_pep440_post(pieces):
     return rendered
 
 
+def render_pep440_post_branch(pieces):
+    """TAG[.postDISTANCE[.dev0]+gHEX[.dirty]] .
+
+    The ".dev0" means not master branch.
+
+    Exceptions:
+    1: no tags. 0.postDISTANCE[.dev0]+gHEX[.dirty]
+    """
+    if pieces["closest-tag"]:
+        rendered = pieces["closest-tag"]
+        if pieces["distance"] or pieces["dirty"]:
+            rendered += ".post%%d" %% pieces["distance"]
+            if pieces["branch"] != "master":
+                rendered += ".dev0"
+            rendered += plus_or_dot(pieces)
+            rendered += "g%%s" %% pieces["short"]
+            if pieces["dirty"]:
+                rendered += ".dirty"
+    else:
+        # exception #1
+        rendered = "0.post%%d" %% pieces["distance"]
+        if pieces["branch"] != "master":
+            rendered += ".dev0"
+        rendered += "+g%%s" %% pieces["short"]
+        if pieces["dirty"]:
+            rendered += ".dirty"
+    return rendered
+
+
 def render_pep440_old(pieces):
     """TAG[.postDISTANCE[.dev0]] .
 
@@ -872,10 +1054,14 @@ def render(pieces, style):
 
     if style == "pep440":
         rendered = render_pep440(pieces)
+    elif style == "pep440-branch":
+        rendered = render_pep440_branch(pieces)
     elif style == "pep440-pre":
         rendered = render_pep440_pre(pieces)
     elif style == "pep440-post":
         rendered = render_pep440_post(pieces)
+    elif style == "pep440-post-branch":
+        rendered = render_pep440_post_branch(pieces)
     elif style == "pep440-old":
         rendered = render_pep440_old(pieces)
     elif style == "git-describe":
@@ -911,7 +1097,7 @@ def get_versions():
         # versionfile_source is the relative path from the top of the source
         # tree (where the .git directory might live) to this file. Invert
         # this to find the root from __file__.
-        for i in cfg.versionfile_source.split('/'):
+        for _ in cfg.versionfile_source.split('/'):
             root = os.path.dirname(root)
     except NameError:
         return {"version": "0+unknown", "full-revisionid": None,
@@ -946,8 +1132,8 @@ def git_get_keywords(versionfile_abs):
     # _version.py.
     keywords = {}
     try:
-        with open(versionfile_abs, "r") as f:
-            for line in f.readlines():
+        with open(versionfile_abs, "r") as fobj:
+            for line in fobj:
                 if line.strip().startswith("git_refnames ="):
                     mo = re.search(r'=\s*"(.*)"', line)
                     if mo:
@@ -960,7 +1146,7 @@ def git_get_keywords(versionfile_abs):
                     mo = re.search(r'=\s*"(.*)"', line)
                     if mo:
                         keywords["date"] = mo.group(1)
-    except EnvironmentError:
+    except OSError:
         pass
     return keywords
 
@@ -968,8 +1154,8 @@ def git_get_keywords(versionfile_abs):
 @register_vcs_handler("git", "keywords")
 def git_versions_from_keywords(keywords, tag_prefix, verbose):
     """Get version information from git keywords."""
-    if not keywords:
-        raise NotThisMethod("no keywords at all, weird")
+    if "refnames" not in keywords:
+        raise NotThisMethod("Short version file found")
     date = keywords.get("date")
     if date is not None:
         # Use only the last line.  Previous lines may contain GPG signature
@@ -988,11 +1174,11 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose):
         if verbose:
             print("keywords are unexpanded, not using")
         raise NotThisMethod("unexpanded keywords, not a git-archive tarball")
-    refs = set([r.strip() for r in refnames.strip("()").split(",")])
+    refs = {r.strip() for r in refnames.strip("()").split(",")}
     # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of
     # just "foo-1.0". If we see a "tag: " prefix, prefer those.
     TAG = "tag: "
-    tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)])
+    tags = {r[len(TAG):] for r in refs if r.startswith(TAG)}
     if not tags:
         # Either we're using git < 1.8.3, or there really are no tags. We use
         # a heuristic: assume all version tags have a digit. The old git %d
@@ -1001,7 +1187,7 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose):
         # between branches and tags. By ignoring refnames without digits, we
         # filter out many common branch names like "release" and
         # "stabilization", as well as "HEAD" and "master".
-        tags = set([r for r in refs if re.search(r'\d', r)])
+        tags = {r for r in refs if re.search(r'\d', r)}
         if verbose:
             print("discarding '%s', no digits" % ",".join(refs - tags))
     if verbose:
@@ -1010,6 +1196,11 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose):
         # sorting will prefer e.g. "2.0" over "2.0rc1"
         if ref.startswith(tag_prefix):
             r = ref[len(tag_prefix):]
+            # Filter out refs that exactly match prefix or that don't start
+            # with a number once the prefix is stripped (mostly a concern
+            # when prefix is '')
+            if not re.match(r'\d', r):
+                continue
             if verbose:
                 print("picking %s" % r)
             return {"version": r,
@@ -1025,7 +1216,7 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose):
 
 
 @register_vcs_handler("git", "pieces_from_vcs")
-def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
+def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command):
     """Get version from 'git describe' in the root of the source tree.
 
     This only gets called if the git-archive 'subst' keywords were *not*
@@ -1036,8 +1227,15 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
     if sys.platform == "win32":
         GITS = ["git.cmd", "git.exe"]
 
-    out, rc = run_command(GITS, ["rev-parse", "--git-dir"], cwd=root,
-                          hide_stderr=True)
+    # GIT_DIR can interfere with correct operation of Versioneer.
+    # It may be intended to be passed to the Versioneer-versioned project,
+    # but that should not change where we get our version from.
+    env = os.environ.copy()
+    env.pop("GIT_DIR", None)
+    runner = functools.partial(runner, env=env)
+
+    _, rc = runner(GITS, ["rev-parse", "--git-dir"], cwd=root,
+                   hide_stderr=not verbose)
     if rc != 0:
         if verbose:
             print("Directory %s not under git control" % root)
@@ -1045,15 +1243,15 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
 
     # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty]
     # if there isn't one, this yields HEX[-dirty] (no NUM)
-    describe_out, rc = run_command(GITS, ["describe", "--tags", "--dirty=",
-                                          "--always", "--long",
-                                          "--match", "%s*" % tag_prefix],
-                                   cwd=root)
+    describe_out, rc = runner(GITS, [
+        "describe", "--tags", "--dirty=", "--always", "--long",
+        "--match", f"{tag_prefix}[[:digit:]]*"
+    ], cwd=root)
     # --long was added in git-1.5.5
     if describe_out is None:
         raise NotThisMethod("'git describe' failed")
     describe_out = describe_out.strip()
-    full_out, rc = run_command(GITS, ["rev-parse", "HEAD"], cwd=root)
+    full_out, rc = runner(GITS, ["rev-parse", "HEAD"], cwd=root)
     if full_out is None:
         raise NotThisMethod("'git rev-parse' failed")
     full_out = full_out.strip()
@@ -1063,6 +1261,39 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
     pieces["short"] = full_out[:7]  # maybe improved later
     pieces["error"] = None
 
+    branch_name, rc = runner(GITS, ["rev-parse", "--abbrev-ref", "HEAD"],
+                             cwd=root)
+    # --abbrev-ref was added in git-1.6.3
+    if rc != 0 or branch_name is None:
+        raise NotThisMethod("'git rev-parse --abbrev-ref' returned error")
+    branch_name = branch_name.strip()
+
+    if branch_name == "HEAD":
+        # If we aren't exactly on a branch, pick a branch which represents
+        # the current commit. If all else fails, we are on a branchless
+        # commit.
+        branches, rc = runner(GITS, ["branch", "--contains"], cwd=root)
+        # --contains was added in git-1.5.4
+        if rc != 0 or branches is None:
+            raise NotThisMethod("'git branch --contains' returned error")
+        branches = branches.split("\n")
+
+        # Remove the first line if we're running detached
+        if "(" in branches[0]:
+            branches.pop(0)
+
+        # Strip off the leading "* " from the list of branches.
+        branches = [branch[2:] for branch in branches]
+        if "master" in branches:
+            branch_name = "master"
+        elif not branches:
+            branch_name = None
+        else:
+            # Pick the first branch that is returned. Good or bad.
+            branch_name = branches[0]
+
+    pieces["branch"] = branch_name
+
     # parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty]
     # TAG might have hyphens.
     git_describe = describe_out
@@ -1079,7 +1310,7 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
         # TAG-NUM-gHEX
         mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe)
         if not mo:
-            # unparseable. Maybe git-describe is misbehaving?
+            # unparsable. Maybe git-describe is misbehaving?
             pieces["error"] = ("unable to parse git-describe output: '%s'"
                                % describe_out)
             return pieces
@@ -1104,13 +1335,11 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
     else:
         # HEX: no tags
         pieces["closest-tag"] = None
-        count_out, rc = run_command(GITS, ["rev-list", "HEAD", "--count"],
-                                    cwd=root)
-        pieces["distance"] = int(count_out)  # total number of commits
+        out, rc = runner(GITS, ["rev-list", "HEAD", "--left-right"], cwd=root)
+        pieces["distance"] = len(out.split())  # total number of commits
 
     # commit date: see ISO-8601 comment in git_versions_from_keywords()
-    date = run_command(GITS, ["show", "-s", "--format=%ci", "HEAD"],
-                       cwd=root)[0].strip()
+    date = runner(GITS, ["show", "-s", "--format=%ci", "HEAD"], cwd=root)[0].strip()
     # Use only the last line.  Previous lines may contain GPG signature
     # information.
     date = date.splitlines()[-1]
@@ -1119,7 +1348,7 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
     return pieces
 
 
-def do_vcs_install(manifest_in, versionfile_source, ipy):
+def do_vcs_install(versionfile_source, ipy):
     """Git-specific installation logic for Versioneer.
 
     For Git, this means creating/changing .gitattributes to mark _version.py
@@ -1128,29 +1357,31 @@ def do_vcs_install(manifest_in, versionfile_source, ipy):
     GITS = ["git"]
     if sys.platform == "win32":
         GITS = ["git.cmd", "git.exe"]
-    files = [manifest_in, versionfile_source]
+    files = [versionfile_source]
     if ipy:
         files.append(ipy)
-    try:
-        me = __file__
-        if me.endswith(".pyc") or me.endswith(".pyo"):
-            me = os.path.splitext(me)[0] + ".py"
-        versioneer_file = os.path.relpath(me)
-    except NameError:
-        versioneer_file = "versioneer.py"
-    files.append(versioneer_file)
+    if "VERSIONEER_PEP518" not in globals():
+        try:
+            my_path = __file__
+            if my_path.endswith(".pyc") or my_path.endswith(".pyo"):
+                my_path = os.path.splitext(my_path)[0] + ".py"
+            versioneer_file = os.path.relpath(my_path)
+        except NameError:
+            versioneer_file = "versioneer.py"
+        files.append(versioneer_file)
     present = False
     try:
-        with open(".gitattributes", "r") as f:
-            for line in f.readlines():
+        with open(".gitattributes", "r") as fobj:
+            for line in fobj:
                 if line.strip().startswith(versionfile_source):
                     if "export-subst" in line.strip().split()[1:]:
                         present = True
-    except EnvironmentError:
+                        break
+    except OSError:
         pass
     if not present:
-        with open(".gitattributes", "a+") as f:
-            f.write("%s export-subst\n" % versionfile_source)
+        with open(".gitattributes", "a+") as fobj:
+            fobj.write(f"{versionfile_source} export-subst\n")
         files.append(".gitattributes")
     run_command(GITS, ["add", "--"] + files)
 
@@ -1164,15 +1395,14 @@ def versions_from_parentdir(parentdir_prefix, root, verbose):
     """
     rootdirs = []
 
-    for i in range(3):
+    for _ in range(3):
         dirname = os.path.basename(root)
         if dirname.startswith(parentdir_prefix):
             return {"version": dirname[len(parentdir_prefix):],
                     "full-revisionid": None,
                     "dirty": False, "error": None, "date": None}
-        else:
-            rootdirs.append(root)
-            root = os.path.dirname(root)  # up a level
+        rootdirs.append(root)
+        root = os.path.dirname(root)  # up a level
 
     if verbose:
         print("Tried directories %s but none started with prefix %s" %
@@ -1181,7 +1411,7 @@ def versions_from_parentdir(parentdir_prefix, root, verbose):
 
 
 SHORT_VERSION_PY = """
-# This file was generated by 'versioneer.py' (0.19) from
+# This file was generated by 'versioneer.py' (0.26) from
 # revision-control system data, or from the parent directory name of an
 # unpacked source archive. Distribution tarballs contain a pre-generated copy
 # of this file.
@@ -1203,7 +1433,7 @@ def versions_from_file(filename):
     try:
         with open(filename) as f:
             contents = f.read()
-    except EnvironmentError:
+    except OSError:
         raise NotThisMethod("unable to read _version.py")
     mo = re.search(r"version_json = '''\n(.*)'''  # END VERSION_JSON",
                    contents, re.M | re.S)
@@ -1258,16 +1488,64 @@ def render_pep440(pieces):
     return rendered
 
 
+def render_pep440_branch(pieces):
+    """TAG[[.dev0]+DISTANCE.gHEX[.dirty]] .
+
+    The ".dev0" means not master branch. Note that .dev0 sorts backwards
+    (a feature branch will appear "older" than the master branch).
+
+    Exceptions:
+    1: no tags. 0[.dev0]+untagged.DISTANCE.gHEX[.dirty]
+    """
+    if pieces["closest-tag"]:
+        rendered = pieces["closest-tag"]
+        if pieces["distance"] or pieces["dirty"]:
+            if pieces["branch"] != "master":
+                rendered += ".dev0"
+            rendered += plus_or_dot(pieces)
+            rendered += "%d.g%s" % (pieces["distance"], pieces["short"])
+            if pieces["dirty"]:
+                rendered += ".dirty"
+    else:
+        # exception #1
+        rendered = "0"
+        if pieces["branch"] != "master":
+            rendered += ".dev0"
+        rendered += "+untagged.%d.g%s" % (pieces["distance"],
+                                          pieces["short"])
+        if pieces["dirty"]:
+            rendered += ".dirty"
+    return rendered
+
+
+def pep440_split_post(ver):
+    """Split pep440 version string at the post-release segment.
+
+    Returns the release segments before the post-release and the
+    post-release version number (or -1 if no post-release segment is present).
+    """
+    vc = str.split(ver, ".post")
+    return vc[0], int(vc[1] or 0) if len(vc) == 2 else None
+
+
 def render_pep440_pre(pieces):
-    """TAG[.post0.devDISTANCE] -- No -dirty.
+    """TAG[.postN.devDISTANCE] -- No -dirty.
 
     Exceptions:
     1: no tags. 0.post0.devDISTANCE
     """
     if pieces["closest-tag"]:
-        rendered = pieces["closest-tag"]
         if pieces["distance"]:
-            rendered += ".post0.dev%d" % pieces["distance"]
+            # update the post release segment
+            tag_version, post_version = pep440_split_post(pieces["closest-tag"])
+            rendered = tag_version
+            if post_version is not None:
+                rendered += ".post%d.dev%d" % (post_version + 1, pieces["distance"])
+            else:
+                rendered += ".post0.dev%d" % (pieces["distance"])
+        else:
+            # no commits, use the tag as the version
+            rendered = pieces["closest-tag"]
     else:
         # exception #1
         rendered = "0.post0.dev%d" % pieces["distance"]
@@ -1301,6 +1579,35 @@ def render_pep440_post(pieces):
     return rendered
 
 
+def render_pep440_post_branch(pieces):
+    """TAG[.postDISTANCE[.dev0]+gHEX[.dirty]] .
+
+    The ".dev0" means not master branch.
+
+    Exceptions:
+    1: no tags. 0.postDISTANCE[.dev0]+gHEX[.dirty]
+    """
+    if pieces["closest-tag"]:
+        rendered = pieces["closest-tag"]
+        if pieces["distance"] or pieces["dirty"]:
+            rendered += ".post%d" % pieces["distance"]
+            if pieces["branch"] != "master":
+                rendered += ".dev0"
+            rendered += plus_or_dot(pieces)
+            rendered += "g%s" % pieces["short"]
+            if pieces["dirty"]:
+                rendered += ".dirty"
+    else:
+        # exception #1
+        rendered = "0.post%d" % pieces["distance"]
+        if pieces["branch"] != "master":
+            rendered += ".dev0"
+        rendered += "+g%s" % pieces["short"]
+        if pieces["dirty"]:
+            rendered += ".dirty"
+    return rendered
+
+
 def render_pep440_old(pieces):
     """TAG[.postDISTANCE[.dev0]] .
 
@@ -1377,10 +1684,14 @@ def render(pieces, style):
 
     if style == "pep440":
         rendered = render_pep440(pieces)
+    elif style == "pep440-branch":
+        rendered = render_pep440_branch(pieces)
     elif style == "pep440-pre":
         rendered = render_pep440_pre(pieces)
     elif style == "pep440-post":
         rendered = render_pep440_post(pieces)
+    elif style == "pep440-post-branch":
+        rendered = render_pep440_post_branch(pieces)
     elif style == "pep440-old":
         rendered = render_pep440_old(pieces)
     elif style == "git-describe":
@@ -1481,7 +1792,7 @@ def get_version():
 
 
 def get_cmdclass(cmdclass=None):
-    """Get the custom setuptools/distutils subclasses used by Versioneer.
+    """Get the custom setuptools subclasses used by Versioneer.
 
     If the package uses a different cmdclass (e.g. one from numpy), it
     should be provide as an argument.
@@ -1503,8 +1814,8 @@ def get_cmdclass(cmdclass=None):
 
     cmds = {} if cmdclass is None else cmdclass.copy()
 
-    # we add "version" to both distutils and setuptools
-    from distutils.core import Command
+    # we add "version" to setuptools
+    from setuptools import Command
 
     class cmd_version(Command):
         description = "report generated version string"
@@ -1527,7 +1838,7 @@ def run(self):
                 print(" error: %s" % vers["error"])
     cmds["version"] = cmd_version
 
-    # we override "build_py" in both distutils and setuptools
+    # we override "build_py" in setuptools
     #
     # most invocation pathways end up running build_py:
     #  distutils/build -> build_py
@@ -1542,13 +1853,14 @@ def run(self):
     #   then does setup.py bdist_wheel, or sometimes setup.py install
     #  setup.py egg_info -> ?
 
+    # pip install -e . and setuptool/editable_wheel will invoke build_py
+    # but the build_py command is not expected to copy any files.
+
     # we override different "build_py" commands for both environments
     if 'build_py' in cmds:
         _build_py = cmds['build_py']
-    elif "setuptools" in sys.modules:
-        from setuptools.command.build_py import build_py as _build_py
     else:
-        from distutils.command.build_py import build_py as _build_py
+        from setuptools.command.build_py import build_py as _build_py
 
     class cmd_build_py(_build_py):
         def run(self):
@@ -1556,6 +1868,10 @@ def run(self):
             cfg = get_config_from_root(root)
             versions = get_versions()
             _build_py.run(self)
+            if getattr(self, "editable_mode", False):
+                # During editable installs `.py` and data files are
+                # not copied to build_lib
+                return
             # now locate _version.py in the new build/ directory and replace
             # it with an updated value
             if cfg.versionfile_build:
@@ -1565,10 +1881,10 @@ def run(self):
                 write_to_version_file(target_versionfile, versions)
     cmds["build_py"] = cmd_build_py
 
-    if "setuptools" in sys.modules:
-        from setuptools.command.build_ext import build_ext as _build_ext
+    if 'build_ext' in cmds:
+        _build_ext = cmds['build_ext']
     else:
-        from distutils.command.build_ext import build_ext as _build_ext
+        from setuptools.command.build_ext import build_ext as _build_ext
 
     class cmd_build_ext(_build_ext):
         def run(self):
@@ -1585,7 +1901,12 @@ def run(self):
             # now locate _version.py in the new build/ directory and replace
             # it with an updated value
             target_versionfile = os.path.join(self.build_lib,
-                                              cfg.versionfile_source)
+                                              cfg.versionfile_build)
+            if not os.path.exists(target_versionfile):
+                print(f"Warning: {target_versionfile} does not exist, skipping "
+                      "version update. This can happen if you are running build_ext "
+                      "without first running build_py.")
+                return
             print("UPDATING %s" % target_versionfile)
             write_to_version_file(target_versionfile, versions)
     cmds["build_ext"] = cmd_build_ext
@@ -1623,7 +1944,10 @@ def run(self):
         del cmds["build_py"]
 
     if 'py2exe' in sys.modules:  # py2exe enabled?
-        from py2exe.distutils_buildexe import py2exe as _py2exe
+        try:
+            from py2exe.setuptools_buildexe import py2exe as _py2exe
+        except ImportError:
+            from py2exe.distutils_buildexe import py2exe as _py2exe
 
         class cmd_py2exe(_py2exe):
             def run(self):
@@ -1647,13 +1971,48 @@ def run(self):
                              })
         cmds["py2exe"] = cmd_py2exe
 
+    # sdist farms its file list building out to egg_info
+    if 'egg_info' in cmds:
+        _egg_info = cmds['egg_info']
+    else:
+        from setuptools.command.egg_info import egg_info as _egg_info
+
+    class cmd_egg_info(_egg_info):
+        def find_sources(self):
+            # egg_info.find_sources builds the manifest list and writes it
+            # in one shot
+            super().find_sources()
+
+            # Modify the filelist and normalize it
+            root = get_root()
+            cfg = get_config_from_root(root)
+            self.filelist.append('versioneer.py')
+            if cfg.versionfile_source:
+                # There are rare cases where versionfile_source might not be
+                # included by default, so we must be explicit
+                self.filelist.append(cfg.versionfile_source)
+            self.filelist.sort()
+            self.filelist.remove_duplicates()
+
+            # The write method is hidden in the manifest_maker instance that
+            # generated the filelist and was thrown away
+            # We will instead replicate their final normalization (to unicode,
+            # and POSIX-style paths)
+            from setuptools import unicode_utils
+            normalized = [unicode_utils.filesys_decode(f).replace(os.sep, '/')
+                          for f in self.filelist.files]
+
+            manifest_filename = os.path.join(self.egg_info, 'SOURCES.txt')
+            with open(manifest_filename, 'w') as fobj:
+                fobj.write('\n'.join(normalized))
+
+    cmds['egg_info'] = cmd_egg_info
+
     # we override different "sdist" commands for both environments
     if 'sdist' in cmds:
         _sdist = cmds['sdist']
-    elif "setuptools" in sys.modules:
-        from setuptools.command.sdist import sdist as _sdist
     else:
-        from distutils.command.sdist import sdist as _sdist
+        from setuptools.command.sdist import sdist as _sdist
 
     class cmd_sdist(_sdist):
         def run(self):
@@ -1717,21 +2076,26 @@ def make_release_tree(self, base_dir, files):
 
 """
 
-INIT_PY_SNIPPET = """
+OLD_SNIPPET = """
 from ._version import get_versions
 __version__ = get_versions()['version']
 del get_versions
 """
 
+INIT_PY_SNIPPET = """
+from . import {0}
+__version__ = {0}.get_versions()['version']
+"""
+
 
 def do_setup():
     """Do main VCS-independent setup function for installing Versioneer."""
     root = get_root()
     try:
         cfg = get_config_from_root(root)
-    except (EnvironmentError, configparser.NoSectionError,
+    except (OSError, configparser.NoSectionError,
             configparser.NoOptionError) as e:
-        if isinstance(e, (EnvironmentError, configparser.NoSectionError)):
+        if isinstance(e, (OSError, configparser.NoSectionError)):
             print("Adding sample versioneer config to setup.cfg",
                   file=sys.stderr)
             with open(os.path.join(root, "setup.cfg"), "a") as f:
@@ -1755,54 +2119,28 @@ def do_setup():
         try:
             with open(ipy, "r") as f:
                 old = f.read()
-        except EnvironmentError:
+        except OSError:
             old = ""
-        if INIT_PY_SNIPPET not in old:
+        module = os.path.splitext(os.path.basename(cfg.versionfile_source))[0]
+        snippet = INIT_PY_SNIPPET.format(module)
+        if OLD_SNIPPET in old:
+            print(" replacing boilerplate in %s" % ipy)
+            with open(ipy, "w") as f:
+                f.write(old.replace(OLD_SNIPPET, snippet))
+        elif snippet not in old:
             print(" appending to %s" % ipy)
             with open(ipy, "a") as f:
-                f.write(INIT_PY_SNIPPET)
+                f.write(snippet)
         else:
             print(" %s unmodified" % ipy)
     else:
         print(" %s doesn't exist, ok" % ipy)
         ipy = None
 
-    # Make sure both the top-level "versioneer.py" and versionfile_source
-    # (PKG/_version.py, used by runtime code) are in MANIFEST.in, so
-    # they'll be copied into source distributions. Pip won't be able to
-    # install the package without this.
-    manifest_in = os.path.join(root, "MANIFEST.in")
-    simple_includes = set()
-    try:
-        with open(manifest_in, "r") as f:
-            for line in f:
-                if line.startswith("include "):
-                    for include in line.split()[1:]:
-                        simple_includes.add(include)
-    except EnvironmentError:
-        pass
-    # That doesn't cover everything MANIFEST.in can do
-    # (http://docs.python.org/2/distutils/sourcedist.html#commands), so
-    # it might give some false negatives. Appending redundant 'include'
-    # lines is safe, though.
-    if "versioneer.py" not in simple_includes:
-        print(" appending 'versioneer.py' to MANIFEST.in")
-        with open(manifest_in, "a") as f:
-            f.write("include versioneer.py\n")
-    else:
-        print(" 'versioneer.py' already in MANIFEST.in")
-    if cfg.versionfile_source not in simple_includes:
-        print(" appending versionfile_source ('%s') to MANIFEST.in" %
-              cfg.versionfile_source)
-        with open(manifest_in, "a") as f:
-            f.write("include %s\n" % cfg.versionfile_source)
-    else:
-        print(" versionfile_source already in MANIFEST.in")
-
     # Make VCS-specific changes. For git, this means creating/changing
     # .gitattributes to mark _version.py for export-subst keyword
     # substitution.
-    do_vcs_install(manifest_in, cfg.versionfile_source, ipy)
+    do_vcs_install(cfg.versionfile_source, ipy)
     return 0
 
 
@@ -1843,10 +2181,14 @@ def scan_setup_py():
     return errors
 
 
+def setup_command():
+    """Set up Versioneer and exit with appropriate error code."""
+    errors = do_setup()
+    errors += scan_setup_py()
+    sys.exit(1 if errors else 0)
+
+
 if __name__ == "__main__":
     cmd = sys.argv[1]
     if cmd == "setup":
-        errors = do_setup()
-        errors += scan_setup_py()
-        if errors:
-            sys.exit(1)
+        setup_command()